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,17 @@ 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);
+    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 +204,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,58 @@
+// Tests that naked template functions are correctly handled when building DLLs
+// on Windows. Verifies that:
+// 1. Naked template functions can be exported from DLLs
+// 2. Other modules can link against and use them
+//
+// This tests the fix for naked function code generation that ensures proper
+// symbol mangling and linkage on Windows targets.
+//
+// See: https://github.com/ldc-developers/ldc/issues/4294
+
+// REQUIRES: target_X86
+
+// RUN: split-file %s %t
+
+// Compile for Windows x86_64 target using lld-link
+// RUN: %ldc -mtriple=x86_64-windows-msvc -betterC -c %t/naked_template.d -of=%t/naked_template.obj
+// RUN: %ldc -mtriple=x86_64-windows-msvc -betterC -c %t/naked_user.d -I%t -of=%t/naked_user.obj
+
+// Create DLL from template module - exports both callFromTemplate and the naked template
+// RUN: lld-link /dll /noentry %t/naked_template.obj /out:%t/lib.dll /implib:%t/lib.lib
+
+// Link user module against the DLL
+// RUN: lld-link /dll /noentry /export:callFromUser %t/naked_user.obj %t/lib.lib /out:%t/user.dll
+
+//--- naked_template.d
+module naked_template;
+
+// Exported naked template function - the export attribute ensures it gets
+// dllexport and can be linked from other DLLs
+export uint nakedTemplateFunc(char op)() pure @safe @nogc {
+    asm pure nothrow @nogc @trusted {
+        naked;
+        xor EAX, EAX;
+    }
+    static if (op == '+')
+        asm pure nothrow @nogc @trusted { inc EAX; }
+    else
+        asm pure nothrow @nogc @trusted { dec EAX; }
+    asm pure nothrow @nogc @trusted {
+        ret;
+    }
+}
+
+// Pre-instantiate with export
+alias nakedPlus = nakedTemplateFunc!('+');
+
+extern(C) export uint callFromTemplate() {
+    return nakedPlus();
+}
+
+//--- naked_user.d
+module naked_user;
+import naked_template;
+
+// Use the exported template from the DLL
+extern(C) export uint callFromUser() {
+    return nakedPlus();
+}