[COFF] Improve JIT support of weak symbols

[v.g.vassilev]

Summary

Teach RuntimeDyld to handle COFF weak references and to consider comdat symbols as weak.

Patch by Lang Hames and Sunho Kim!

I struggle creating a test case but this patch fixes a large amount of test failures for Cling and ROOT (https://github.com/root-project/root/pull/10294) when moving llvm13 and orcv2. Can somebody help me how to test this?

[Hahnfeld]

ping @lhames

[v.g.vassilev]

Added a testcase by Sunho!

[v.g.vassilev]

clang-format

[lhames]

LGTM!

llvm/lib/ExecutionEngine/Orc/Layer.cpp

for (auto &G : M.global_values()) {
           SymbolFlags[EmuTLST] = Flags;
         }
         continue;
       }
 
       // Otherwise we just need a normal linker mangling.
       auto MangledName = Mangle(G.getName());
       SymbolFlags[MangledName] = JITSymbolFlags::fromGlobalValue(G);
+      if (G.getComdat() &&
+          G.getComdat()->getSelectionKind() != Comdat::NoDeduplicate)
+        SymbolFlags[MangledName] |= JITSymbolFlags::Weak;
       SymbolToDefinition[MangledName] = &G;
     }
 
     // If we need an init symbol for this module then create one.
     if (!getStaticInitGVs(M).empty()) {
       size_t Counter = 0;
 
       do {

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

for (auto &Sym : COFFObj->symbols()) {
       if (!Sec)
         return Sec.takeError();
       if (*Sec == COFFObj->section_end())
         continue;
       auto &COFFSec = *COFFObj->getCOFFSection(**Sec);
       if (COFFSec.Characteristics & COFF::IMAGE_SCN_LNK_COMDAT)
         I->second.setFlags(I->second.getFlags() | JITSymbolFlags::Weak);
     }
+
+    // Handle any aliases.
+    for (auto &Sym : COFFObj->symbols()) {
+      uint32_t SymFlags = cantFail(Sym.getFlags());
+      if (SymFlags & object::BasicSymbolRef::SF_Undefined)
+        continue;
+      auto Name = Sym.getName();
+      if (!Name)
+        return Name.takeError();
+      auto I = Resolved.find(*Name);
+
+      // Skip already-resolved symbols, and symbols that we're not responsible
+      // for.
+      if (I != Resolved.end() || !R.getSymbols().count(ES.intern(*Name)))
+        continue;
+
+      // Skip anything other than weak externals.
+      auto COFFSym = COFFObj->getCOFFSymbol(Sym);
+      if (!COFFSym.isWeakExternal())
+        continue;
+      auto *WeakExternal = COFFSym.getAux<object::coff_aux_weak_external>();
+      if (WeakExternal->Characteristics != COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS)
+        continue;
+
+      // We found an alias. Reuse the resolution of the alias target for the
+      // alias itself.
+      Expected<object::COFFSymbolRef> TargetSymbol =
+          COFFObj->getSymbol(WeakExternal->TagIndex);
+      if (!TargetSymbol)
+        return TargetSymbol.takeError();
+      Expected<StringRef> TargetName = COFFObj->getSymbolName(*TargetSymbol);
+      if (!TargetName)
+        return TargetName.takeError();
+      auto J = Resolved.find(*TargetName);
+      if (J == Resolved.end())
+        return make_error<StringError>("Could alias target " + *TargetName +
+                                           " not resolved",
+                                       inconvertibleErrorCode());
+      Resolved[*Name] = J->second;
+    }
   }
 
   for (auto &KV : Resolved) {
     // Scan the symbols and add them to the Symbols map for resolution.
 
     // We never claim internal symbols.
     if (InternalSymbols.count(KV.first))
       continue;

llvm/test/ExecutionEngine/OrcLazy/Inputs/comdat-functions.ll

+$baz = comdat any
+
+define i32 @baz() comdat {
+entry:
+  ret i32 0
+}

llvm/test/ExecutionEngine/OrcLazy/comdat-functions.ll

+; REQUIRES: system-windows
+; RUN: lli -jit-kind=orc-lazy -extra-module %p/Inputs/comdat-functions.ll %s
+; Check if crashing comdat any functions are not causing duplicate symbol error.
+
+$baz = comdat any
+
+define i32 @baz() comdat {
+entry:
+  ret i32 0
+}
+
+define i32 @main(i32 %argc, i8** %argv) {
+entry:
+  %call = tail call i32 @baz()
+  ret i32 %call
+}