Fix naked function symbol mangling and linkage for Windows

- Use getIRMangledName() instead of mangleExact() to get proper Windows
  calling convention decoration (e.g., \01 prefix for vectorcall)
- Use DtoLinkage() for proper linkage determination for all function types
- Fix linkage for functions already declared by DtoDeclareFunction()
- Remove redundant COMDAT setup code

This fixes undefined symbol errors when using naked template functions
across Windows DLL boundaries. The issue was that DtoDeclareFunction()
creates functions with ExternalLinkage, and DtoDefineNakedFunction()
wasn't correcting the linkage or using the proper IR mangle name.

Add test that cross-compiles for Windows and verifies naked template
functions work correctly with DLL linking.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Dev VM

gen/naked.cpp

@@ -21,6 +21,7 @@
 #include "gen/llvm.h"
 #include "gen/llvmhelpers.h"
 #include "gen/logger.h"
+#include "gen/mangling.h"
 #include "gen/tollvm.h"
 #include "ir/irfunction.h"
 #include "llvm/IR/InlineAsm.h"
@@ -148,27 +149,32 @@ void DtoDefineNakedFunction(FuncDeclaration *fd) {
   IF_LOG Logger::println("DtoDefineNakedFunction(%s)", mangleExact(fd));
   LOG_SCOPE;
 
-  const char *mangle = mangleExact(fd);
   const auto &triple = *global.params.targetTriple;
 
+  // Get the proper IR mangle name (includes Windows calling convention decoration)
+  TypeFunction *tf = fd->type->isTypeFunction();
+  const std::string irMangle = getIRMangledName(fd, tf ? tf->linkage : LINK::d);
+
   // Get or create the LLVM function first, before visiting the body.
   // The visitor may call Declaration_codegen which needs an IR insert point.
   llvm::Module &module = gIR->module;
-  llvm::Function *func = module.getFunction(mangle);
+  llvm::Function *func = module.getFunction(irMangle);
 
   if (!func) {
     // Create function type using the existing infrastructure
     llvm::FunctionType *funcType = DtoFunctionType(fd);
 
-    // Create function with appropriate linkage
-    llvm::GlobalValue::LinkageTypes linkage;
-    if (fd->isInstantiated()) {
-      linkage = llvm::GlobalValue::LinkOnceODRLinkage;
-    } else {
-      linkage = llvm::GlobalValue::ExternalLinkage;
-    }
+    // Get proper linkage using the standard infrastructure.
+    // This correctly handles lambdas (internal linkage), templates (weak_odr),
+    // and other cases.
+    const auto lwc = DtoLinkage(fd);
 
-    func = llvm::Function::Create(funcType, linkage, mangle, &module);
+    func = llvm::Function::Create(funcType, lwc.first, irMangle, &module);
+
+    // Set up COMDAT if needed (for template deduplication on ELF/Windows)
+    if (lwc.second) {
+      func->setComdat(module.getOrInsertComdat(irMangle));
+    }
   } else if (!func->empty()) {
     // Function already has a body - this can happen if the function was
     // already defined (e.g., template instantiation in another module).
@@ -177,6 +183,23 @@ void DtoDefineNakedFunction(FuncDeclaration *fd) {
   } else if (func->hasFnAttribute(llvm::Attribute::Naked)) {
     // Function already has naked attribute - it was already processed
     return;
+  } else {
+    // Function was declared but not yet defined (e.g., by DtoDeclareFunction).
+    // Fix the linkage - DtoDeclareFunction always uses ExternalLinkage,
+    // but naked functions need proper linkage based on their declaration type.
+    const auto lwc = DtoLinkage(fd);
+    // Clear DLL storage class before setting linkage - LLVM requires that
+    // functions with local linkage (internal/private) have DefaultStorageClass.
+    if (lwc.first == llvm::GlobalValue::InternalLinkage ||
+        lwc.first == llvm::GlobalValue::PrivateLinkage) {
+      func->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
+    }
+    func->setLinkage(lwc.first);
+    if (lwc.second) {
+      func->setComdat(module.getOrInsertComdat(irMangle));
+    } else {
+      func->setComdat(nullptr);
+    }
   }
 
   // Set naked attribute - this tells LLVM not to generate prologue/epilogue
@@ -187,11 +210,6 @@ void DtoDefineNakedFunction(FuncDeclaration *fd) {
   func->addFnAttr(llvm::Attribute::OptimizeNone);
   func->addFnAttr(llvm::Attribute::NoInline);
 
-  // For template instantiations, set up COMDAT for deduplication
-  if (fd->isInstantiated()) {
-    func->setComdat(module.getOrInsertComdat(mangle));
-  }
-
   // Set other common attributes
   func->addFnAttr(llvm::Attribute::NoUnwind);
 

tests/linking/naked_lambda_linkage.d

@@ -0,0 +1,41 @@
+// Tests that naked template functions get correct symbol mangling on Windows.
+//
+// The bug: When a naked template function is called, DtoDeclareFunction creates
+// a declaration with the proper IR mangle name (including \01 prefix for
+// vectorcall). Without the fix, DtoDefineNakedFunction would create a definition
+// with a DIFFERENT mangle name (missing the \01 prefix), leaving the declared
+// function undefined.
+//
+// This test verifies that calling and defining a naked template in the same
+// module produces a linkable object file.
+//
+// See: https://github.com/ldc-developers/ldc/issues/4294
+
+// REQUIRES: target_X86
+// REQUIRES: atleast_llvm1600
+// REQUIRES: ld.lld
+
+// Compile for Windows with LTO and link into a DLL.
+// LTO is critical for this test - without LTO, the linker resolves both
+// symbol variants to the same name, masking the bug.
+// RUN: %ldc -mtriple=x86_64-windows-msvc -betterC -flto=full -c %s -of=%t.obj
+// RUN: ld.lld -flavor link /dll /noentry /export:caller %t.obj /out:%t.dll
+
+module naked_lambda_linkage;
+
+// Non-exported naked template function.
+// The call in caller() triggers DtoDeclareFunction first, then the function
+// is defined by DtoDefineNakedFunction. Without the fix, these use different
+// mangle names and the declared symbol remains undefined.
+uint nakedTemplateFunc(int N)() pure @safe @nogc {
+    asm pure nothrow @nogc @trusted {
+        naked;
+        mov EAX, N;
+        ret;
+    }
+}
+
+// This function calls the naked template, triggering the declaration before definition
+extern(C) export uint caller() {
+    return nakedTemplateFunc!42();
+}

tests/lit.site.cfg.in

@@ -214,6 +214,10 @@ if (platform.system() == 'Windows') and os.path.isfile( cdb ):
 if (platform.system() != 'Windows') and lit.util.which('gdb', config.environment['PATH']):
     config.available_features.add('gdb')
 
+# Check whether ld.lld is present (for cross-platform COFF linking tests)
+if lit.util.which('ld.lld', config.environment['PATH']):
+    config.available_features.add('ld.lld')
+
 if 'LD_LIBRARY_PATH' in os.environ:
     libs = []
     for lib_path in [s for s in os.environ['LD_LIBRARY_PATH'].split(':') if s]: