[COFF] Use COFF stubs for extern_weak functions

[rnk]

Summary

A COFF stub indirects the reference to a symbol through memory. A
.refptr.$sym global variable pointer is created to refer to $sym.
Typically mingw uses these for external global variable declarations,
but we can use them for weak function declarations as well.

Updates the dso_local classification to add a special case for
extern_weak symbols on COFF in both clang and LLVM.

Fixes PR37598

[rnk]

• fix some tests

[mstorsjo]

LGTM, it's nice if this mechanism comes in handy in other cases than the one it was originally made for.

[smeenai]

LGTM, neat!

llvm/test/CodeGen/X86/extern_weak.ll

20–21

I'm not parsing this too well (it's not quite clear what the relation between L_foo$non_lazy_ptr and _foo is, but I'm assuming $non_lazy_ptr is some Darwin thing that gets synthesized by the .weak_reference _foo), but I think you're just enhancing the Darwin test rather than changing that codegen in any way?

[mstorsjo]

Ideally it'd be nice to have this consistent on arm and aarch64 as well, but it's not a blocker (it's not something I'm running into so far).

[rnk]

Thanks! I'll see about AArch64. It would be nice for this use of __attribute__((weak)) declarations to work there as well.

llvm/test/CodeGen/X86/extern_weak.ll

20–21

Yes, it's basically the same thing as a COFF stub or a GOT entry: a global pointer that points to _foo.

clang/lib/CodeGen/CodeGenModule.cpp

static bool shouldAssumeDSOLocal(const CodeGenModule &CGM,
   if (TT.isWindowsGNUEnvironment()) {
     // In MinGW, variables without DLLImport can still be automatically
     // imported from a DLL by the linker; don't mark variables that
     // potentially could come from another DLL as DSO local.
     if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
         !GV->isThreadLocal())
       return false;
   }
+
+  // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
+  // remain unresolved in the link, they can be resolved to zero, which is
+  // outside the current DSO.
+  if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
+    return false;
+
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmware builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   // FIXME: even thread local variables?
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 

clang/test/CodeGen/dso-local-executable.c

 // RUN: %clang_cc1 -triple x86_64-pc-win32 -emit-llvm %s -o - | FileCheck -allow-deprecated-dag-overlap --check-prefix=COFF %s
 // COFF-DAG: @bar = external dso_local global i32
-// COFF-DAG: @weak_bar = extern_weak dso_local global i32
+// COFF-DAG: @weak_bar = extern_weak global i32
 // COFF-DAG: declare dso_local void @foo()
 // COFF-DAG: @baz = dso_local global i32 42
 // COFF-DAG: define dso_local i32* @zed()
 // COFF-DAG: @thread_var = external dso_local thread_local global i32
 // COFF-DAG: @local_thread_var = dso_local thread_local global i32 42
 // COFF-DAG: @import_var = external dllimport global i32
 // COFF-DAG: declare dllimport void @import_func()
 

llvm/lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
   // end up automatically imported by the linker. To make this feasible,
   // don't assume the variables to be DSO local unless we actually know
   // that for sure. This only has to be done for variables; for functions
   // the linker can insert thunks for calling functions from another DLL.
   if (TT.isWindowsGNUEnvironment() && GV && GV->isDeclarationForLinker() &&
       isa<GlobalVariable>(GV))
     return false;
 
+  // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
+  // remain unresolved in the link, they can be resolved to zero, which is
+  // outside the current DSO.
+  if (TT.isOSBinFormatCOFF() && GV && GV->hasExternalWeakLinkage())
+    return false;
+
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmware builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 
   // Most PIC code sequences that assume that a symbol is local cannot

llvm/lib/Target/X86/X86FastISel.cpp

bool X86FastISel::fastLowerCall(CallLoweringInfo &CLI) {
   } else {
     // Direct call.
     assert(GV && "Not a direct call");
     // See if we need any target-specific flags on the GV operand.
     unsigned char OpFlags = Subtarget->classifyGlobalFunctionReference(GV);
 
     // This will be a direct call, or an indirect call through memory for
     // NonLazyBind calls or dllimport calls.
-    bool NeedLoad =
-        OpFlags == X86II::MO_DLLIMPORT || OpFlags == X86II::MO_GOTPCREL;
+    bool NeedLoad = OpFlags == X86II::MO_DLLIMPORT ||
+                    OpFlags == X86II::MO_GOTPCREL ||
+                    OpFlags == X86II::MO_COFFSTUB;
     unsigned CallOpc = NeedLoad
                            ? (Is64Bit ? X86::CALL64m : X86::CALL32m)
                            : (Is64Bit ? X86::CALL64pcrel32 : X86::CALLpcrel32);
 
     MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(CallOpc));
     if (NeedLoad)
       MIB.addReg(Is64Bit ? X86::RIP : 0).addImm(1).addReg(0);
     if (Symbol)

llvm/lib/Target/X86/X86ISelLowering.cpp

if (DAG.getTarget().getCodeModel() == CodeModel::Large) {
     // non-JIT mode.
     const GlobalValue *GV = G->getGlobal();
     if (!GV->hasDLLImportStorageClass()) {
       unsigned char OpFlags = Subtarget.classifyGlobalFunctionReference(GV);
 
       Callee = DAG.getTargetGlobalAddress(
           GV, dl, getPointerTy(DAG.getDataLayout()), G->getOffset(), OpFlags);
 
-      if (OpFlags == X86II::MO_GOTPCREL) {
+      if (OpFlags == X86II::MO_GOTPCREL || OpFlags == X86II::MO_COFFSTUB) {
         // Add a wrapper.
-        Callee = DAG.getNode(X86ISD::WrapperRIP, dl,
+        Callee = DAG.getNode(getGlobalWrapperKind(), dl,
                              getPointerTy(DAG.getDataLayout()), Callee);
         // Add extra indirection
         Callee = DAG.getLoad(
             getPointerTy(DAG.getDataLayout()), dl, DAG.getEntryNode(), Callee,
             MachinePointerInfo::getGOT(DAG.getMachineFunction()));
       }
     }
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee)) {
     const Module *Mod = DAG.getMachineFunction().getFunction().getParent();
     unsigned char OpFlags =
         Subtarget.classifyGlobalFunctionReference(nullptr, *Mod);
 
     Callee = DAG.getTargetExternalSymbol(
         S->getSymbol(), getPointerTy(DAG.getDataLayout()), OpFlags);
 
-    if (OpFlags == X86II::MO_GOTPCREL) {
-      Callee = DAG.getNode(X86ISD::WrapperRIP, dl,
+    if (OpFlags == X86II::MO_GOTPCREL || OpFlags == X86II::MO_COFFSTUB) {
+      Callee = DAG.getNode(getGlobalWrapperKind(), dl,
                            getPointerTy(DAG.getDataLayout()), Callee);
       Callee = DAG.getLoad(
           getPointerTy(DAG.getDataLayout()), dl, DAG.getEntryNode(), Callee,
           MachinePointerInfo::getGOT(DAG.getMachineFunction()));
     }
   } else if (Subtarget.isTarget64BitILP32() &&
              Callee->getValueType(0) == MVT::i32) {
     // Zero-extend the 32-bit Callee address into a 64-bit according to x32 ABI
     Callee = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Callee);

llvm/lib/Target/X86/X86Subtarget.cpp

 }
 
 unsigned char
 X86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
                                               const Module &M) const {
   if (TM.shouldAssumeDSOLocal(M, GV))
     return X86II::MO_NO_FLAG;
 
+  // Functions on COFF can be non-DSO local for two reasons:
+  // - They are marked dllimport
+  // - They are extern_weak, and a stub is needed
   if (isTargetCOFF()) {
-    assert(GV->hasDLLImportStorageClass() &&
-           "shouldAssumeDSOLocal gave inconsistent answer");
+    if (GV->hasDLLImportStorageClass())
       return X86II::MO_DLLIMPORT;
+    return X86II::MO_COFFSTUB;
   }
 
   const Function *F = dyn_cast_or_null<Function>(GV);
 
   if (isTargetELF()) {
     if (is64Bit() && F && (CallingConv::X86_RegCall == F->getCallingConv()))
       // According to psABI, PLT stub clobbers XMM8-XMM15.
       // In Regcall calling convention those registers are used for passing

llvm/test/CodeGen/X86/extern_weak.ll

-; RUN: llc < %s -mtriple=i686-apple-darwin | grep weak_reference | count 2
+; RUN: llc < %s -mtriple=i686-apple-darwin | FileCheck %s --check-prefix=DARWIN
+; RUN: llc < %s -mtriple=i686-windows-msvc | FileCheck %s --check-prefix=WIN32
+; RUN: llc < %s -mtriple=x86_64-windows-msvc | FileCheck %s --check-prefix=WIN64
 
-@Y = global i32 (i8*)* @X               ; <i32 (i8*)**> [#uses=0]
-
-declare extern_weak i32 @X(i8*)
+declare extern_weak void @foo(...)
 
 define void @bar() {
-        tail call void (...) @foo( )
-        ret void
+entry:
+  br i1 icmp ne (void (...)* @foo, void (...)* null), label %if.then, label %if.end
+
+if.then:
+
+if.end:
+  ret void
 }
 
-declare extern_weak void @foo(...)
+; DARWIN-LABEL: _bar:
+; DARWIN: cmpl $0, L_foo$non_lazy_ptr
+; DARWIN: jmp _foo ## TAILCALL
+
+; WIN32-LABEL: _bar:
+; WIN32: cmpl $0, .refptr._foo
+; WIN32: jmpl *.refptr._foo
+
+; WIN64-LABEL: bar:
+; WIN64: cmpq $0, .refptr.foo(%rip)
+; WIN64: jmpq *.refptr.foo
+
+
+declare extern_weak i32 @X(i8*)
+
+@Y = global i32 (i8*)* @X               ; <i32 (i8*)**> [#uses=0]
+
+; DARWIN-LABEL: _Y:
+; DARWIN: .long _X
+
+; WIN32-LABEL: _Y:
+; WIN32: .long _X
+
+; WIN64-LABEL: Y:
+; WIN64: .quad X
+
+
+; DARWIN: .weak_reference _foo
+; DARWIN: .weak_reference _X
+
+; WIN32:         .section        .rdata$.refptr._foo,"dr",discard,.refptr._foo
+; WIN32:         .globl  .refptr._foo
+; WIN32: .refptr._foo:
+; WIN32:         .long   _foo
+
+; WIN32: .weak _foo
+; WIN32: .weak _X
+
+; WIN64:         .section        .rdata$.refptr.foo,"dr",discard,.refptr.foo
+; WIN64:         .globl  .refptr.foo
+; WIN64: .refptr.foo:
+; WIN64:         .quad   foo
+
+; WIN64: .weak foo
+; WIN64: .weak X