Fix for -wrap linker option and LTO, PR 33145

[dmikulin]

Summary

An attempt to fix PR33145, --wrap doesn't work with lto.
Wrapped symbols need to excluded from inter-procedural optimizations to prevent dropping symbols and allow the linker to process re-directs.
Current limitation: doesn't work with ThinLTO.

[davide]

There are no tests associated with this patch.

lld/ELF/SymbolTable.cpp

159–163

Can you explain why you need all three?

338–340

empty ifs are not really common in llvm.

lld/ELF/SymbolTable.h

140

A StringMap<bool> is a little silly.
If you really want a set container, you should use a proper one.

llvm/include/llvm/LTO/LTO.h

385

I'd say, LinkerRedefined.

llvm/lib/LTO/LTO.cpp

423

why do you need this being part of GlobalResolution?
If you do, please add a test showing that you fail switching the linkage earlier.

[ruiu]

Do you really need this much change? I expected something smaller than this. I mean, I thought what we need to do is to just pass a list of symbols which LTO should keep.

[dmikulin]

lld/ELF/SymbolTable.cpp

159–163

We need all three if we want to match non-LTO behavior.

• _wrap_bar is needed for the case where it is defined by the user but may be eliminated during LTO.
• _real_bar is needed for the test case in the PR: the direct call to _real_bar() from foo() will be bound and inlined by LTO to the user-defined _real_bar() instead of bar() if _real_bar() is not on the list.
• similarly, if bar() is not on the list, the call to bar() from foo() will be inlined instead of being routed to _wrap_bar().

338–340

I'll fix this. Negating the condition seamed counter-intuitive...

lld/ELF/SymbolTable.h

140

Is a set container like SmallSet good enough in this case? What's the worst case for the number of -wrap functions? I picked a map because we have to do a lookup in this container for every symbol.

llvm/include/llvm/LTO/LTO.h

385

I'll change this.

llvm/lib/LTO/LTO.cpp

423

You're right, I can do it sooner, in addRegularLTO(). I'll take out the GlobalRes stuff.

[davide]

lld/ELF/SymbolTable.cpp

159–163

Can you please add a test showing when 3) happens?

lld/ELF/SymbolTable.h

140

What I'm trying to say is that a map from something to bool is just a Set.
If you think your set will grow a lot (unlikely, but OK, I'd recommend DenseSet).

[dmikulin]

lld/ELF/SymbolTable.cpp

159–163

3. is also demonstrated by the test case in the PR. I'm working on regression tests for all known cases and will submit them with the new version of the patch.

lld/ELF/SymbolTable.h

140

OK, thanks. Will fix.

[pcc]

lld/ELF/SymbolTable.cpp

159–163

_wrap_bar is needed for the case where it is defined by the user but may be eliminated during LTO.

This one only requires VisibleToRegularObj, doesn't it?

338–340

Is the purpose of this code just to restore the binding of the original symbol? I think it would be simpler to have a post-LTO step that manually restores the binding for each renamed symbol rather than dealing with it here.

[pcc]

lld/ELF/SymbolTable.cpp

167

What about the rename target? If I pass --defsym=foo=bar, the linker should not allow IPO past foo, right?

[dmikulin]

lld/ELF/SymbolTable.cpp

159–163

Looks like it. Do we want to handle _wrap_* symbols specially and not set the weak binding for LTO?

167

Right. I'll add it to the list.

338–340

Yes, it was to restore the binding. I changed it to have a separate pass over renamed symbols after LTO.

[dmikulin]

Revised patch. Will add test cases tomorrow.

[pcc]

lld/ELF/SymbolTable.cpp

121

If you move the list of renamed symbols to Config you can avoid this lambda.

159–163

Up to you. Note that you can make LTO keep a symbol by calling addUndefined with the symbol name, so it wouldn't be *that* special.

179

You mean Alias here, right?

[davide]

I'll wait for your tests before another careful review. Some drive by comments.

lld/ELF/SymbolTable.cpp

132–134

Do you need an explicit iterator? Can't you use a range for ?

lld/ELF/SymbolTable.h

141

I'd be more explicit here. e.g. "this is a map from Symbol name to binding" or something like that.

[dmikulin]

lld/ELF/SymbolTable.cpp

121

OK, will do.

179

Of course.

lld/ELF/SymbolTable.h

141

OK

[dmikulin]

Addressed review comments. Added test cases. Tweaked saved pre-LTO bindings to more accurately reflect the state of the symbol table.

[davide]

This is getting better.
Please rebase the patch because it didn't apply cleanly.

lld/ELF/SymbolTable.cpp

132

Convention says all Variable names should start with capital letter. Also, i is a little vague.

llvm/include/llvm/LTO/LTO.h

370–372

Is this formatted? Doesn't seem so.

llvm/lib/LTO/LTO.cpp

421

If I remove this line, all the tests still pass.

442–443

If I comment out this line, all the tests still pass.

548–549

This needs a comment.

[dmikulin]

lld/ELF/SymbolTable.cpp

132

Changed it to RSI (Renamed Symbol Iterator)

llvm/lib/LTO/LTO.cpp

421

This was meant for ThinLTO support, which hasn't been implemented yet. I can take it out from this patch.

442–443

Added a test point for this

[pcc]

lld/test/ELF/lto/defsym.ll

13–14 ↗

(On Diff #100921)

These are addresses of PLT entries, right? Can you avoid magic numbers here and make what you are testing for more explicit? I think you can do that by making the symbols hidden and checking that the calls correspond to the correct symbol addresses. Same for wrap-2.ll.

llvm/lib/LTO/LTO.cpp

443

You also need to add support for 'r' to llvm-lto2. Please also add an llvm-lto2 based test that verifies that the linkage has changed.

[dmikulin]

Addressed review comments.
Made changes and added a test to llvm-lto2.

[dmikulin]

Changed the mapping from string --> binding to Symbol* --> binding.

[pcc]

lld/ELF/SymbolTable.cpp

172–198

Can we now replace these functions with something that applies the rename to each symbol in Config->RenamedSymbols? I think it should be possible with this change to how we declare RenamedSymbols.

struct RenamedSymbol {
  uint8_t OrigBinding;
  Symbol *Target;
};
MapVector<Symbol*, RenamedSymbol> RenamedSymbols;

[dmikulin]

lld/ELF/SymbolTable.cpp

172–198

But __wrap_ symbols are different: they need to be on the list, but they are not being replaced.

[pcc]

lld/ELF/SymbolTable.cpp

172–198

They only need to be marked as IsUsedInRegularObj. And that's taken care of for you by addUndefined.

[dmikulin]

lld/ELF/SymbolTable.cpp

172–198

Map it to NULL?

[davide]

lld/ELF/Config.h

102 ↗

(On Diff #101247)

This is the only field in Config that has a comment. Not sure how I feel about it, I'll defer it to Rui.

lld/ELF/SymbolTable.cpp

186–189

Is this bit needed? I don't see a test for it.

190

Can this ever be null? If so, you should check for it.
If not, you may as well inline this in the single use.

lld/ELF/SymbolTable.h

42–43

Unsorted.

llvm/lib/LTO/LTO.cpp

407–410

This comment is now stale after your change.

[pcc]

lld/ELF/SymbolTable.cpp

172–198

I mean that you can just set IsUsedInRegularObj on the __wrap_ symbol before you assign it to Target. Then LTO will keep it alive. There's no need to add it (as a key) to RenamedSymbols then.
http://llvm-cs.pcc.me.uk/tools/lld/ELF/LTO.cpp#136

[dmikulin]

lld/ELF/SymbolTable.cpp

172–198

This works fine for -wrap, but not for -defsym.

For -wrap, we want to keep the __real_ and the original symbols on the list, so the mappings are:
Real --> Orig and Orig --> Wrap
After we're done with LTO, we copy targets of the mapping back to their keys, Orig --> Real and Wrap --> Orig.

For -defsym, we want to preserve the original symbol, so we would add Orig --> Alias mapping to communicate with LTO. But after we're done, we need to copy Orig --> Alias. I added a flag to the mapping structure to reverse the direction of the copy, so now in the -defsym test the call to bar3() gets inlined and the call to bar2() goes to its alias, bar3. This sounds reasonable to me, just want to make sure it's acceptable.

[dmikulin]

lld/ELF/Config.h

102 ↗

(On Diff #101247)

Removed the comment. Now it's next to the RemappedSymbol structure.

lld/ELF/SymbolTable.cpp

186–189

It was moved here from SymbolTable::alias, there is a test case for it already.

190

It can't be null, I just find it easier to read, that's all.

[dmikulin]

Changed the way -defsym and -wrap are handled.

[pcc]

lld/ELF/Driver.cpp

972

This comment and the one below aren't really accurate any more because this code is used in the non-LTO case as well.

lld/ELF/LTO.cpp

133

I think this can just be Config->RenamedSymbols.count(Sym).

lld/ELF/SymbolTable.cpp

161

Is this function necessary? All callers pass a non-null SymbolBody, so they can just query the binding directly.

167–169

Move this comment to applySymbolRenames.

175

I'd minimise the diff here and rename this variable back.

[dmikulin]

Fixed comments.
Rebased the patch.

[davide]

lld/ELF/SymbolTable.cpp

180

You're setting IsUsedInRegularObj from what I can see, here, for all the symbols passed with --wrap.
Can you check this is really NFC? IIRC it could impact the way symbols are added (or not) to the symbol table.

198

Same here.

[• rafael]

This LGTM. I am not a big fan of keeping a copy or the original binding, but it sure saves a lot of plumbing.

Please just wait to see if Davide and Peter have something to add.

[pcc]

LGTM as well

lld/test/ELF/lto/wrap-1.ll

13 ↗

(On Diff #101289)

Please update this comment. I think you also want to test 'r' for __real_bar.

[davide]

I'm fine with this once Peter's comments are addressed. I'm not a fan of having to carry around the original binding as well, but I think it's tolerable.

[ruiu]

lld/ELF/Config.h

107 ↗

(On Diff #101289)

Please run clang-format-diff. It should be formatted as <Symbol *, RenamedSymbol>

lld/ELF/Driver.cpp

972

I prefer a more concrete comment. Handle -wrap option.

976

Ditto. Handle --defsym=sym=alias option.

lld/ELF/SymbolTable.cpp

179

Add a blank line before a comment.

197

Add a blank line before a comment.

203

It is not obvious why you need this function from the source code. You need to add a comment.

204

What is RSI? I found just KV (short for key-value) makes sense in most cases.

208

Ditto

[dmikulin]

lld/ELF/SymbolTable.cpp

204

RSI is supposed to be Renamed Symbol Iterator, but KV is ok with me too

lld/test/ELF/lto/wrap-1.ll

13 ↗

(On Diff #101289)

Resolutions file is driven by input file symbol tables. Since __real_bar is not defined in an object, it does not show up there. I added a definition and a test for the 'r' flag.

[davide]

There were some comments pending by Rui. You addressed them, but you still need to wait for an explicit LGTM before committing.
I don't think it's worth reverting this patch, but this is not okay and you should consider it next time.

lld/ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   // Return if there were name resolution errors.
   if (ErrorCount)
     return;
 
   Symtab.scanUndefinedFlags();
   Symtab.scanShlibUndefined();
   Symtab.scanVersionScript();
 
+  // Pass wrapped symbols to LTO
+  for (auto *Arg : Args.filtered(OPT_wrap))
+    Symtab.addLTOSymbolWrap(Arg->getValue());
+
+  // Pass alias symbols to LTO
+  for (std::pair<StringRef, StringRef> &Def : getDefsym(Args))
+    Symtab.addLTOSymbolAlias(Def.second);
+
   Symtab.addCombinedLTOObject();
   if (ErrorCount)
     return;
 
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
   for (StringRef Sym : Script->Opt.ReferencedSymbols)
     Symtab.addUndefined(Sym);

lld/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, this);
 
-    return make<DefinedRegular>(Name, /*IsLocal=*/true, StOther, Type, Value,
-                                Size, Sec, this);
+    return make<DefinedRegular>(Name, /*IsLocal=*/true, /*IsBitcode*/false,
+                                StOther, Type, Value, Size, Sec, this);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable), toString(this));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return elf::Symtab<ELFT>::X
         ->addUndefined(Name, /*IsLocal=*/false, Binding, StOther, Type,

lld/ELF/LTO.h

 class BitcodeFile;
 class InputFile;
 
 class BitcodeCompiler {
 public:
   BitcodeCompiler();
   ~BitcodeCompiler();
 
-  void add(BitcodeFile &F);
+  void add(BitcodeFile &F, llvm::StringMap<bool> &RenamedSymbols);
   std::vector<InputFile *> compile();
 
 private:
   std::unique_ptr<llvm::lto::LTO> LTOObj;
   std::vector<SmallString<0>> Buff;
   std::vector<std::unique_ptr<MemoryBuffer>> Files;
 };
 }
 }
 
 #endif

lld/ELF/LTO.cpp

static std::unique_ptr<lto::LTO> createLTO() {
   return llvm::make_unique<lto::LTO>(std::move(Conf), Backend,
                                      Config->LTOPartitions);
 }
 
 BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {}
 
 BitcodeCompiler::~BitcodeCompiler() = default;
 
-static void undefine(Symbol *S) {
-  replaceBody<Undefined>(S, S->body()->getName(), /*IsLocal=*/false,
-                         STV_DEFAULT, S->body()->Type, nullptr);
-}
-
-void BitcodeCompiler::add(BitcodeFile &F) {
+void BitcodeCompiler::add(BitcodeFile &F, llvm::StringMap<bool> &RenamedSymbols) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
   std::vector<Symbol *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     Symbol *Sym = Syms[SymNum];
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
     SymbolBody *B = Sym->body();
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     R.Prevailing = !ObjSym.isUndefined() && B->File == &F;
 
     R.VisibleToRegularObj =
         Sym->IsUsedInRegularObj || (R.Prevailing && Sym->includeInDynsym());
-    if (R.Prevailing)
-      undefine(Sym);
+    R.IsRenamed = RenamedSymbols.find(B->getName()) != RenamedSymbols.end();
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile(s).
 std::vector<InputFile *> BitcodeCompiler::compile() {
   std::vector<InputFile *> Ret;
   unsigned MaxTasks = LTOObj->getMaxTasks();

lld/ELF/LinkerScript.cpp

template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
   Sym->Binding = STB_GLOBAL;
   ExprValue Value = Cmd->Expression();
   SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
 
   // 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.isAbsolute() ? Value.getValue() : 0;
-  replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false, Visibility,
-                              STT_NOTYPE, SymValue, 0, Sec, nullptr);
+  replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false,
+                              /*IsBitcode*/false, Visibility, STT_NOTYPE,
+                              SymValue, 0, Sec, nullptr);
   return Sym->body();
 }
 
 OutputSection *LinkerScript::getOutputSection(const Twine &Loc,
                                               StringRef Name) {
   for (OutputSection *Sec : *OutputSections)
     if (Sec->Name == Name)
       return Sec;

lld/ELF/SymbolTable.h

 // add*() functions, which are called by input files as they are parsed. There
 // is one add* function per symbol type.
 template <class ELFT> class SymbolTable {
   typedef typename ELFT::Sym Elf_Sym;
 
 public:
   void addFile(InputFile *File);
   void addCombinedLTOObject();
+  void addLTOSymbolWrap(StringRef Name);
+  void addLTOSymbolAlias(StringRef Name);
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   ArrayRef<ObjectFile<ELFT> *> getObjectFiles() const { return ObjectFiles; }
   ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
   ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
 
   DefinedRegular *addAbsolute(StringRef Name,
                               uint8_t Visibility = llvm::ELF::STV_HIDDEN,
private:
   // A map from demangled symbol names to their symbol objects.
   // This mapping is 1:N because two symbols with different versions
   // can have the same name. We use this map to handle "extern C++ {}"
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<SymbolBody *>>> DemangledSyms;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
+  llvm::StringMap<bool> RenamedSymbols;
+  bool PostLTO = false;
 };
 
 template <class ELFT> struct Symtab { static SymbolTable<ELFT> *X; };
 template <class ELFT> SymbolTable<ELFT> *Symtab<ELFT>::X;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/SymbolTable.cpp

 // to the compiler at once, it can do whole-program optimization.
 template <class ELFT> void SymbolTable<ELFT>::addCombinedLTOObject() {
   if (BitcodeFiles.empty())
     return;
 
   // Compile bitcode files and replace bitcode symbols.
   LTO.reset(new BitcodeCompiler);
   for (BitcodeFile *F : BitcodeFiles)
-    LTO->add(*F);
+    LTO->add(*F, RenamedSymbols);
 
+  PostLTO = true;
   for (InputFile *File : LTO->compile()) {
     ObjectFile<ELFT> *Obj = cast<ObjectFile<ELFT>>(File);
     DenseSet<CachedHashStringRef> DummyGroups;
     Obj->parse(DummyGroups);
     ObjectFiles.push_back(Obj);
   }
 }
 
 template <class ELFT>
 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>(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 *SymbolTable<ELFT>::addIgnored(StringRef Name,
                                               uint8_t Visibility) {
   SymbolBody *S = find(Name);
   if (!S || S->isInCurrentDSO())
     return nullptr;
   return addAbsolute(Name, Visibility);
 }
 
 // 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.
 template <class ELFT> void SymbolTable<ELFT>::trace(StringRef Name) {
   Symtab.insert({CachedHashStringRef(Name), {-1, true}});
 }
 
+template <class ELFT> void SymbolTable<ELFT>::addLTOSymbolWrap(StringRef Name) {
+  Twine WrappedName = "__wrap_" + Name;
+  Twine RealName = "__real_" + Name;
+  RenamedSymbols[WrappedName.str()] = true;
+  RenamedSymbols[RealName.str()] = true;
+  RenamedSymbols[Name] = true;
+}
+
+template <class ELFT> void SymbolTable<ELFT>::addLTOSymbolAlias(StringRef Name) {
+  RenamedSymbols[Name] = true;
+}
+
 // 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) {
   SymbolBody *B = find(Name);
   if (!B)
     return;
   Symbol *Sym = B->symbol();
   Symbol *Real = addUndefined(Saver.save("__real_" + Name));
   Symbol *Wrap = addUndefined(Saver.save("__wrap_" + Name));
 
   // We rename symbols by replacing the old symbol's SymbolBody with the new
   // symbol's SymbolBody. This causes all SymbolBody pointers referring to the
   // old symbol to instead refer to the new symbol.
   memcpy(Real->Body.buffer, Sym->Body.buffer, sizeof(Sym->Body));
   memcpy(Sym->Body.buffer, Wrap->Body.buffer, sizeof(Wrap->Body));
 }
 
 // Creates alias for symbol. Used to implement --defsym=ALIAS=SYM.
 template <class ELFT>
 void SymbolTable<ELFT>::alias(StringRef Alias, StringRef Name) {
   SymbolBody *B = find(Name);
   if (!B) {
     error("-defsym: undefined symbol: " + Name);
     return;
   }
   Symbol *Sym = B->symbol();
   Symbol *AliasSym = addUndefined(Alias);
   memcpy(AliasSym->Body.buffer, Sym->Body.buffer, sizeof(AliasSym->Body));
 }
 
 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);
 }
 
 // Find an existing symbol or create and insert a new one.
 template <class ELFT>
 std::pair<Symbol *, bool> SymbolTable<ELFT>::insert(StringRef Name) {
   auto P = Symtab.insert(
       {CachedHashStringRef(Name), SymIndex((int)SymVector.size(), false)});
   SymIndex &V = P.first->second;
   bool IsNew = P.second;
 
   if (V.Idx == -1) {
else if (InputFile *F = L->fetch())
       addFile(F);
   }
   return S;
 }
 
 // We have a new defined symbol with the specified binding. Return 1 if the new
 // symbol should win, -1 if the new symbol should lose, or 0 if both symbols are
 // strong defined symbols.
-static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding) {
+static int compareDefined(Symbol *S, bool WasInserted, uint8_t Binding, bool postLTO) {
   if (WasInserted)
     return 1;
   SymbolBody *Body = S->body();
-  if (Body->isLazy() || !Body->isInCurrentDSO())
+  if ((postLTO && Body->isBitcode()) || Body->isLazy() || !Body->isInCurrentDSO())
     return 1;
   if (Binding == STB_WEAK)
     return -1;
   if (S->isWeak())
     return 1;
   return 0;
 }
 
 // We have a new non-common defined symbol with the specified binding. Return 1
 // if the new symbol should win, -1 if the new symbol should lose, or 0 if there
 // is a conflict. If the new symbol wins, also update the binding.
 template <typename ELFT>
 static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
-                                   bool IsAbsolute, typename ELFT::uint Value) {
-  if (int Cmp = compareDefined(S, WasInserted, Binding)) {
-    if (Cmp > 0)
+                                   bool IsAbsolute, typename ELFT::uint Value,
+                                   bool postLTO) {
+  SymbolBody *B = S->body();
+  if (int Cmp = compareDefined(S, WasInserted, Binding, postLTO)) {
+    if (Cmp > 0) {
+      if ((postLTO && B->isBitcode()) &&
+          Binding == STB_WEAK && S->Binding != STB_WEAK)
+        ;
+      else
         S->Binding = Binding;
+    }
     return Cmp;
   }
-  SymbolBody *B = S->body();
   if (isa<DefinedCommon>(B)) {
     // Non-common symbols take precedence over common symbols.
     if (Config->WarnCommon)
       warn("common " + S->body()->getName() + " is overridden");
     return 1;
   } else if (auto *R = dyn_cast<DefinedRegular>(B)) {
     if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
         R->Value == Value)
       return -1;
   }
   return 0;
 }
 
 template <class ELFT>
 Symbol *SymbolTable<ELFT>::addCommon(StringRef N, uint64_t Size,
                                      uint32_t Alignment, uint8_t Binding,
                                      uint8_t StOther, uint8_t Type,
                                      InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
-  int Cmp = compareDefined(S, WasInserted, Binding);
+  int Cmp = compareDefined(S, WasInserted, Binding, PostLTO);
   if (Cmp > 0) {
     S->Binding = Binding;
     replaceBody<DefinedCommon>(S, N, Size, Alignment, StOther, Type, File);
   } else if (Cmp == 0) {
     auto *C = dyn_cast<DefinedCommon>(S->body());
     if (!C) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
                                       uint8_t Type, uint64_t Value,
                                       uint64_t Size, uint8_t Binding,
                                       SectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
-                                          Section == nullptr, Value);
+                                          Section == nullptr, Value, PostLTO);
   if (Cmp > 0)
-    replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type,
-                                Value, Size, Section, File);
+    replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, /*IsBitcode*/false,
+                                StOther, Type, Value, Size, Section, File);
   else if (Cmp == 0)
     reportDuplicate<ELFT>(S->body(),
                           dyn_cast_or_null<InputSectionBase>(Section), Value);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *File, StringRef Name,

 Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
                                       uint8_t StOther, uint8_t Type,
                                       bool CanOmitFromDynSym, BitcodeFile *F) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, getVisibility(StOther), CanOmitFromDynSym, F);
   int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
-                                          /*IsAbs*/ false, /*Value*/ 0);
+                                          /*IsAbs*/ false, /*Value*/ 0,
+                                          PostLTO);
   if (Cmp > 0)
-    replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type, 0, 0,
-                                nullptr, F);
+    replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, /*IsBitcode*/true,
+                                StOther, Type, 0, 0, nullptr, F);
   else if (Cmp == 0)
     reportDuplicate(S->body(), F);
   return S;
 }
 
 template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
   auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())

lld/ELF/Symbols.h

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 isInCurrentDSO() const { return !isUndefined() && !isShared(); }
   bool isLocal() const { return IsLocal; }
+  bool isBitcode() const { return IsBitcode; }
   bool isPreemptible() const;
   StringRef getName() const { return Name; }
   uint8_t getVisibility() const { return StOther & 0x3; }
   void parseSymbolVersion();
 
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
public:
 
   uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t GlobalDynIndex = -1;
 
 protected:
-  SymbolBody(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
-             uint8_t Type);
+  SymbolBody(Kind K, StringRefZ Name, bool IsLocal, bool IsBitcode,
+             uint8_t StOther, uint8_t Type);
 
   const unsigned SymbolKind : 8;
 
 public:
   // True if the linker has to generate a copy relocation.
   // For SharedSymbol only.
   unsigned NeedsCopy : 1;
 
public:
   unsigned Is32BitMipsGot : 1;
 
   // True if this symbol is in the Iplt sub-section of the Plt.
   unsigned IsInIplt : 1;
 
   // True if this symbol is in the Igot sub-section of the .got.plt or .got.
   unsigned IsInIgot : 1;
 
+  // True if symbol was defined in a bitcode object
+  unsigned IsBitcode : 1;
+
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type
   uint8_t StOther; // st_other field value
 
   // The Type field may also have this value. It means that we have not yet seen
   // a non-Lazy symbol with this name, so we don't know what its type is. The
   // Type field is normally set to this value for Lazy symbols unless we saw a
   // weak undefined symbol first, in which case we need to remember the original

 
 protected:
   StringRefZ Name;
 };
 
 // The base class for any defined symbols.
 class Defined : public SymbolBody {
 public:
-  Defined(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type);
+  Defined(Kind K, StringRefZ Name, bool IsLocal, bool IsBitcode,
+          uint8_t StOther, uint8_t Type);
   static bool classof(const SymbolBody *S) { return S->isDefined(); }
 };
 
 class DefinedCommon : public Defined {
 public:
   DefinedCommon(StringRef N, uint64_t Size, uint32_t Alignment, uint8_t StOther,
                 uint8_t Type, InputFile *File);
 
public:
   uint32_t Alignment;
 
   uint64_t Size;
 };
 
 // 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,
-                 InputFile *File)
-      : Defined(SymbolBody::DefinedRegularKind, Name, IsLocal, StOther, Type),
+  DefinedRegular(StringRefZ Name, bool IsLocal, bool IsBitcode,
+                 uint8_t StOther, uint8_t Type, uint64_t Value, uint64_t Size,
+                 SectionBase *Section, InputFile *File)
+      : Defined(SymbolBody::DefinedRegularKind, Name, IsLocal, IsBitcode, StOther, Type),
         Value(Value), Size(Size), Section(Section) {
     this->File = File;
   }
 
   // Return true if the symbol is a PIC function.
   template <class ELFT> bool isMipsPIC() const;
 
   static bool classof(const SymbolBody *S) {

 class SharedSymbol : public Defined {
 public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::SharedKind;
   }
 
   SharedSymbol(InputFile *File, StringRef Name, uint8_t StOther, uint8_t Type,
                const void *ElfSym, const void *Verdef)
-      : Defined(SymbolBody::SharedKind, Name, /*IsLocal=*/false, StOther, Type),
+      : Defined(SymbolBody::SharedKind, Name, /*IsLocal=*/false,
+                /*IsBitcode*/false, StOther, Type),
         Verdef(Verdef), ElfSym(ElfSym) {
     // IFuncs defined in DSOs are treated as functions by the static linker.
     if (isGnuIFunc())
       Type = llvm::ELF::STT_FUNC;
     this->File = File;
   }
 
   template <class ELFT> uint64_t getShndx() const {
public:
   static bool classof(const SymbolBody *S) { return S->isLazy(); }
 
   // Returns an object file for this symbol, or a nullptr if the file
   // was already returned.
   InputFile *fetch();
 
 protected:
   Lazy(SymbolBody::Kind K, StringRef Name, uint8_t Type)
-      : SymbolBody(K, Name, /*IsLocal=*/false, llvm::ELF::STV_DEFAULT, Type) {}
+      : SymbolBody(K, Name, /*IsLocal=*/false, /*IsBitcode*/false, 
+                   llvm::ELF::STV_DEFAULT, Type) {}
 };
 
 // LazyArchive symbols represents symbols in archive files.
 class LazyArchive : public Lazy {
 public:
   LazyArchive(ArchiveFile &File, const llvm::object::Archive::Symbol S,
               uint8_t Type);
 

lld/ELF/Symbols.cpp

static uint64_t getSymVA(const SymbolBody &Body, int64_t &Addend) {
   case SymbolBody::LazyArchiveKind:
   case SymbolBody::LazyObjectKind:
     assert(Body.symbol()->IsUsedInRegularObj && "lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("invalid symbol kind");
 }
 
-SymbolBody::SymbolBody(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
-                       uint8_t Type)
+SymbolBody::SymbolBody(Kind K, StringRefZ Name, bool IsLocal, bool IsBitcode,
+                       uint8_t StOther, uint8_t Type)
     : SymbolKind(K), NeedsCopy(false), NeedsPltAddr(false), IsLocal(IsLocal),
       IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
-      IsInIgot(false), Type(Type), StOther(StOther), Name(Name) {}
+      IsInIgot(false), IsBitcode(IsBitcode), Type(Type), StOther(StOther),
+      Name(Name) {}
 
 // 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;
 
   // Shared symbols resolve to the definition in the DSO. The exceptions are
else
       symbol()->VersionId = Ver.Id | VERSYM_HIDDEN;
     return;
   }
 
   // It is an error if the specified version is not defined.
   error(toString(File) + ": symbol " + S + " has undefined version " + Verstr);
 }
 
-Defined::Defined(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
-                 uint8_t Type)
-    : SymbolBody(K, Name, IsLocal, StOther, Type) {}
+Defined::Defined(Kind K, StringRefZ Name, bool IsLocal, bool IsBitcode,
+                 uint8_t StOther, uint8_t Type)
+    : SymbolBody(K, Name, IsLocal, IsBitcode, StOther, Type) {}
 
 template <class ELFT> bool DefinedRegular::isMipsPIC() const {
   if (!Section || !isFunc())
     return false;
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
          (cast<InputSectionBase>(Section)
               ->template getFile<ELFT>()
               ->getObj()
               .getHeader()
               ->e_flags &
           EF_MIPS_PIC);
 }
 
 Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
                      uint8_t Type, InputFile *File)
-    : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type) {
+    : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, /*IsBitcode*/false,
+                 StOther, Type) {
   this->File = File;
 }
 
 DefinedCommon::DefinedCommon(StringRef Name, uint64_t Size, uint32_t Alignment,
                              uint8_t StOther, uint8_t Type, InputFile *File)
-    : Defined(SymbolBody::DefinedCommonKind, Name, /*IsLocal=*/false, StOther,
-              Type),
+    : Defined(SymbolBody::DefinedCommonKind, Name, /*IsLocal=*/false,
+              /*IsBitcode*/false, StOther, Type),
       Alignment(Alignment), Size(Size) {
   this->File = File;
 }
 
 // If a shared symbol is referred via a copy relocation, its alignment
 // becomes part of the ABI. This function returns a symbol alignment.
 // Because symbols don't have alignment attributes, we need to infer that.
 template <class ELFT> uint32_t SharedSymbol::getAlignment() const {

lld/ELF/SyntheticSections.cpp

InputSection *elf::createInterpSection() {
   auto *Sec =
       make<InputSection>(SHF_ALLOC, SHT_PROGBITS, 1, Contents, ".interp");
   Sec->Live = true;
   return Sec;
 }
 
 SymbolBody *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, nullptr);
+  auto *S = make<DefinedRegular>(Name, /*IsLocal*/ true, /*IsBitcode*/ false,
+                                 STV_DEFAULT, Type, Value, Size, Section,
+                                 nullptr);
   if (InX::SymTab)
     InX::SymTab->addSymbol(S);
   return S;
 }
 
 static size_t getHashSize() {
   switch (Config->BuildId) {
   case BuildIdKind::Fast:

lld/ELF/Writer.cpp

if (Sec->Sections.empty())
       continue;
 
     InputSection *IS = Sec->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,
-                             /*Value=*/0, /*Size=*/0, IS, nullptr);
+        make<DefinedRegular>("", /*IsLocal=*/true, /*IsBitcode*/false,
+                             /*StOther=*/0, STT_SECTION, /*Value=*/0,
+                             /*Size=*/0, IS, nullptr);
     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.
 //

llvm/include/llvm/LTO/LTO.h

struct GlobalResolution {
     /// The unmangled name of the global.
     std::string IRName;
 
     /// Keep track if the symbol is visible outside of ThinLTO (i.e. in
     /// either a regular object or the regular LTO partition).
     bool VisibleOutsideThinLTO = false;
 
     bool UnnamedAddr = true;
+    bool IsRenamed = false;
 
     /// This field keeps track of the partition number of this global. The
     /// regular LTO object is partition 0, while each ThinLTO object has its own
     /// partition number from 1 onwards.
     ///
     /// Any global that is defined or used by more than one partition, or that
     /// is referenced externally, may not be internalized.
     ///
private:
 
   mutable bool CalledGetMaxTasks = false;
 };
 
 /// The resolution for a symbol. The linker must provide a SymbolResolution for
 /// each global symbol based on its internal resolution of that symbol.
 struct SymbolResolution {
   SymbolResolution()
-      : Prevailing(0), FinalDefinitionInLinkageUnit(0), VisibleToRegularObj(0) {
+    : Prevailing(0), FinalDefinitionInLinkageUnit(0), VisibleToRegularObj(0),
+      IsRenamed(0) {
   }
   /// The linker has chosen this definition of the symbol.
   unsigned Prevailing : 1;
 
   /// The definition of this symbol is unpreemptable at runtime and is known to
   /// be in this linkage unit.
   unsigned FinalDefinitionInLinkageUnit : 1;
 
   /// The definition of this symbol is visible outside of the LTO unit.
   unsigned VisibleToRegularObj : 1;
+
+  /// Renamed version of the symbol which appeared in -wrap or -defsym linker
+  /// option.
+  unsigned IsRenamed : 1;
 };
 
 } // namespace lto
 } // namespace llvm
 
 #endif

llvm/lib/LTO/LTO.cpp

 // Add the given symbol to the GlobalResolutions map, and resolve its partition.
 void LTO::addSymbolToGlobalRes(const InputFile::Symbol &Sym,
                                SymbolResolution Res, unsigned Partition) {
   auto &GlobalRes = GlobalResolutions[Sym.getName()];
   GlobalRes.UnnamedAddr &= Sym.isUnnamedAddr();
   if (Res.Prevailing)
     GlobalRes.IRName = Sym.getIRName();
 
   // Set the partition to external if we know it is used elsewhere, e.g.
   // it is visible to a regular object, is referenced from llvm.compiler_used,
   // or was already recorded as being referenced from a different partition.
-  if (Res.VisibleToRegularObj || Sym.isUsed() ||
+  if (Res.IsRenamed || Res.VisibleToRegularObj || Sym.isUsed() ||
       (GlobalRes.Partition != GlobalResolution::Unknown &&
        GlobalRes.Partition != Partition)) {
     GlobalRes.Partition = GlobalResolution::External;
   } else
     // First recorded reference, save the current partition.
     GlobalRes.Partition = Partition;
 
   // Flag as visible outside of ThinLTO if visible from a regular object or
   // if this is a reference in the regular LTO partition.
   GlobalRes.VisibleOutsideThinLTO |=
-      (Res.VisibleToRegularObj || Sym.isUsed() ||
+      (Res.IsRenamed || Res.VisibleToRegularObj || Sym.isUsed() ||
        Partition == GlobalResolution::RegularLTO);
+  GlobalRes.IsRenamed = Res.IsRenamed;
 }
 
 static void writeToResolutionFile(raw_ostream &OS, InputFile *Input,
                                   ArrayRef<SymbolResolution> Res) {
   StringRef Path = Input->getName();
   OS << Path << '\n';
   auto ResI = Res.begin();
   for (const InputFile::Symbol &Sym : Input->symbols()) {
     assert(ResI != Res.end());
     SymbolResolution Res = *ResI++;
 
     OS << "-r=" << Path << ',' << Sym.getName() << ',';
     if (Res.Prevailing)
       OS << 'p';
     if (Res.FinalDefinitionInLinkageUnit)
       OS << 'l';
     if (Res.VisibleToRegularObj)
       OS << 'x';
+    if (Res.IsRenamed)
+      OS << 'r';
     OS << '\n';
   }
   OS.flush();
   assert(ResI == Res.end());
 }
 
 Error LTO::add(std::unique_ptr<InputFile> Input,
                ArrayRef<SymbolResolution> Res) {
for (const InputFile::Symbol &Sym : Syms) {
     ModuleSymbolTable::Symbol Msym = *MsymI++;
     Skip();
 
     if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
       if (Res.Prevailing) {
         if (Sym.isUndefined())
           continue;
         Keep.push_back(GV);
         switch (GV->getLinkage()) {
         default:
           break;
         case GlobalValue::LinkOnceAnyLinkage:
           GV->setLinkage(GlobalValue::WeakAnyLinkage);
           break;
         case GlobalValue::LinkOnceODRLinkage:
           GV->setLinkage(GlobalValue::WeakODRLinkage);
           break;
         }
for (const auto &R : GlobalResolutions) {
           RegularLTO.CombinedModule->getNamedValue(R.second.IRName);
       // Ignore symbols defined in other partitions.
       if (!GV || GV->hasLocalLinkage())
         continue;
       GV->setUnnamedAddr(R.second.UnnamedAddr ? GlobalValue::UnnamedAddr::Global
                                               : GlobalValue::UnnamedAddr::None);
       if (R.second.Partition == 0)
         GV->setLinkage(GlobalValue::InternalLinkage);
+      if (R.second.IsRenamed == true)
+        GV->setLinkage(GlobalValue::WeakAnyLinkage);
     }
 
     if (Conf.PostInternalizeModuleHook &&
         !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
       return Error::success();
   }
   return backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
                  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex);