Emit naked functions as LLVM IR with inline asm instead of module asm

This fixes issue #4294 where LTO linking fails with "symbol already defined"
errors for naked template functions. The root cause was that module-level
assembly from multiple compilation units gets concatenated during LTO before
COMDAT deduplication can occur.

The fix emits naked functions as proper LLVM IR functions with:
- The 'naked' attribute (suppresses prologue/epilogue generation)
- LinkOnceODRLinkage for template instantiations
- COMDAT groups for proper symbol deduplication during LTO
- Inline asm containing the function body
- OptimizeNone and NoInline attributes to prevent LLVM from cloning
  the function during optimization passes (which would duplicate labels)

Labels in the inline asm use printLabelName() for consistency with
label references generated by the asm parser, ensuring labels are
properly quoted to match the format used in jump instructions.

🤖 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

@@ -16,6 +16,7 @@
 #include "dmd/template.h"
 #include "gen/dvalue.h"
 #include "gen/funcgenstate.h"
+#include "gen/functions.h"
 #include "gen/irstate.h"
 #include "gen/llvm.h"
 #include "gen/llvmhelpers.h"
@@ -24,6 +25,7 @@
 #include "ir/irfunction.h"
 #include "llvm/IR/InlineAsm.h"
 #include <cassert>
+#include <sstream>
 
 using namespace dmd;
 
@@ -128,9 +130,11 @@ class ToNakedIRVisitor : public Visitor {
                            stmt->loc.toChars());
     LOG_SCOPE;
 
+    // Use printLabelName to match how label references are generated in asm-x86.h.
+    // This ensures label definitions match the quoted format used in jump instructions.
     printLabelName(irs->nakedAsm, mangleExact(irs->func()->decl),
                    stmt->ident->toChars());
-    irs->nakedAsm << ":";
+    irs->nakedAsm << ":\n";
 
     if (stmt->statement) {
       stmt->statement->accept(this);
@@ -144,108 +148,114 @@ void DtoDefineNakedFunction(FuncDeclaration *fd) {
   IF_LOG Logger::println("DtoDefineNakedFunction(%s)", mangleExact(fd));
   LOG_SCOPE;
 
-  // we need to do special processing on the body, since we only want
-  // to allow actual inline asm blocks to reach the final asm output
+  const char *mangle = mangleExact(fd);
+  const auto &triple = *global.params.targetTriple;
 
+  // Clear the nakedAsm stream and collect the function body
   std::ostringstream &asmstr = gIR->nakedAsm;
+  asmstr.str("");
 
-  // build function header
-
-  // FIXME: could we perhaps use llvm asmwriter to give us these details ?
+  // Use the visitor to collect asm statements into nakedAsm
+  ToNakedIRVisitor visitor(gIR);
+  fd->fbody->accept(&visitor);
 
-  const char *mangle = mangleExact(fd);
-  std::string fullmangle; // buffer only
+  if (global.errors) {
+    fatal();
+  }
 
-  const auto &triple = *global.params.targetTriple;
-  bool const isWin = triple.isOSWindows();
-  bool const isDarwin = triple.isOSDarwin();
-
-  // osx is different
-  // also mangling has an extra underscore prefixed
-  if (isDarwin) {
-    fullmangle += '_';
-    fullmangle += mangle;
-    mangle = fullmangle.c_str();
-
-    asmstr << "\t.section\t__TEXT,__text,regular,pure_instructions"
-           << std::endl;
-    asmstr << "\t.globl\t" << mangle << std::endl;
-    if (fd->isInstantiated()) {
-      asmstr << "\t.weak_definition\t" << mangle << std::endl;
+  // Get the collected asm string and escape $ characters for LLVM inline asm.
+  // In LLVM inline asm, $N refers to operand N, so literal $ must be escaped as $$.
+  std::string asmBody;
+  {
+    std::string raw = asmstr.str();
+    asmBody.reserve(raw.size() * 2);  // Worst case: all $ characters
+    for (char c : raw) {
+      if (c == '$') {
+        asmBody += "$$";
+      } else {
+        asmBody += c;
+      }
     }
-    asmstr << "\t.p2align\t4, 0x90" << std::endl;
-    asmstr << mangle << ":" << std::endl;
   }
-  // Windows is different
-  else if (isWin) {
-    // mangled names starting with '?' (MSVC++ symbols) apparently need quoting
-    if (mangle[0] == '?') {
-      fullmangle += '"';
-      fullmangle += mangle;
-      fullmangle += '"';
-      mangle = fullmangle.c_str();
-    } else if (triple.isArch32Bit()) {
-      // prepend extra underscore for Windows x86
-      fullmangle += '_';
-      fullmangle += mangle;
-      mangle = fullmangle.c_str();
-    }
+  asmstr.str("");  // Clear for potential reuse
 
-    asmstr << "\t.def\t" << mangle << ";" << std::endl;
-    // hard code these two numbers for now since gas ignores .scl and llvm
-    // is defaulting to .type 32 for everything I have seen
-    asmstr << "\t.scl\t2;" << std::endl;
-    asmstr << "\t.type\t32;" << std::endl;
-    asmstr << "\t.endef" << std::endl;
+  // Get or create the LLVM function
+  llvm::Module &module = gIR->module;
+  llvm::Function *func = module.getFunction(mangle);
 
+  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()) {
-      asmstr << "\t.section\t.text,\"xr\",discard," << mangle << std::endl;
-    } else {
-      asmstr << "\t.text" << std::endl;
-    }
-    asmstr << "\t.globl\t" << mangle << std::endl;
-    asmstr << "\t.p2align\t4, 0x90" << std::endl;
-    asmstr << mangle << ":" << std::endl;
-  } else {
-    if (fd->isInstantiated()) {
-      asmstr << "\t.section\t.text." << mangle << ",\"axG\",@progbits,"
-             << mangle << ",comdat" << std::endl;
-      asmstr << "\t.weak\t" << mangle << std::endl;
+      linkage = llvm::GlobalValue::LinkOnceODRLinkage;
     } else {
-      asmstr << "\t.text" << std::endl;
-      asmstr << "\t.globl\t" << mangle << std::endl;
+      linkage = llvm::GlobalValue::ExternalLinkage;
     }
-    asmstr << "\t.p2align\t4, 0x90" << std::endl;
-    asmstr << "\t.type\t" << mangle << ",@function" << std::endl;
-    asmstr << mangle << ":" << std::endl;
+
+    func = llvm::Function::Create(funcType, linkage, mangle, &module);
+  } 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).
+    // Don't add another body.
+    return;
+  } else if (func->hasFnAttribute(llvm::Attribute::Naked)) {
+    // Function already has naked attribute - it was already processed
+    return;
   }
 
-  // emit body
-  ToNakedIRVisitor v(gIR);
-  fd->fbody->accept(&v);
+  // Set naked attribute - this tells LLVM not to generate prologue/epilogue
+  func->addFnAttr(llvm::Attribute::Naked);
 
-  // We could have generated new errors in toNakedIR(), but we are in codegen
-  // already so we have to abort here.
-  if (global.errors) {
-    fatal();
-  }
+  // Prevent optimizations that might clone or modify the function.
+  // The inline asm contains labels that would conflict if duplicated.
+  func->addFnAttr(llvm::Attribute::OptimizeNone);
+  func->addFnAttr(llvm::Attribute::NoInline);
 
-  // emit size after body
-  // llvm does this on linux, but not on osx or Win
-  if (!(isWin || isDarwin)) {
-    asmstr << "\t.size\t" << mangle << ", .-" << mangle << std::endl
-           << std::endl;
+  // For template instantiations, set up COMDAT for deduplication
+  if (fd->isInstantiated()) {
+    func->setComdat(module.getOrInsertComdat(mangle));
   }
 
-  gIR->module.appendModuleInlineAsm(asmstr.str());
-  asmstr.str("");
+  // Set other common attributes
+  func->addFnAttr(llvm::Attribute::NoUnwind);
+
+  // Create entry basic block
+  llvm::BasicBlock *entryBB =
+      llvm::BasicBlock::Create(gIR->context(), "entry", func);
 
+  // Save current insert point and switch to new function
+  llvm::IRBuilderBase::InsertPoint savedIP = gIR->ir->saveIP();
+  gIR->ir->SetInsertPoint(entryBB);
+
+  // Create inline asm - the entire function body is a single asm block
+  // No constraints needed since naked functions handle everything in asm
+  llvm::FunctionType *asmFuncType =
+      llvm::FunctionType::get(llvm::Type::getVoidTy(gIR->context()), false);
+
+  llvm::InlineAsm *inlineAsm = llvm::InlineAsm::get(
+      asmFuncType,
+      asmBody,
+      "",      // No constraints
+      true,    // Has side effects
+      false,   // Not align stack
+      llvm::InlineAsm::AD_ATT  // AT&T syntax
+  );
+
+  gIR->ir->CreateCall(inlineAsm);
+
+  // Naked functions don't return normally through LLVM IR
+  gIR->ir->CreateUnreachable();
+
+  // Restore insert point
+  gIR->ir->restoreIP(savedIP);
+
+  // Handle DLL export on Windows
   if (global.params.dllexport ||
-      (global.params.targetTriple->isOSWindows() && fd->isExport())) {
-    // Embed a linker switch telling the MS linker to export the naked function.
-    // This mimics the effect of the dllexport attribute for regular functions.
-    const auto linkerSwitch = std::string("/EXPORT:") + mangle;
-    gIR->addLinkerOption(llvm::StringRef(linkerSwitch));
+      (triple.isOSWindows() && fd->isExport())) {
+    func->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
   }
 }
 
@@ -436,7 +446,7 @@ DValue *DtoInlineAsmExpr(Loc loc, FuncDeclaration *fd,
   LLSmallVector<LLValue *, 8> operands;
   LLSmallVector<LLType *, 8> indirectTypes;
   operands.reserve(n);
-    
+
   Type *returnType = fd->type->nextOf();
   const size_t cisize = constraintInfo.size();
   const size_t minRequired = n + (returnType->ty == TY::Tvoid ? 0 : 1);

tests/codegen/naked_asm_corner_cases.d

@@ -0,0 +1,110 @@
+// Tests corner cases for naked functions with DMD-style inline asm.
+//
+// This tests:
+// 1. Stack manipulation (push/pop)
+// 2. Forward and backward jumps
+// 3. Nested labels
+// 4. Naked function calling convention
+
+// REQUIRES: target_X86
+
+// RUN: %ldc -mtriple=x86_64-linux-gnu -O0 -output-s -of=%t.s %s
+// RUN: FileCheck %s --check-prefix=ASM < %t.s
+
+// RUN: %ldc -mtriple=x86_64-linux-gnu -O0 -run %s
+
+module naked_asm_corner_cases;
+
+// Test 1: Stack manipulation with push/pop
+// ASM-LABEL: stackManipulation:
+// ASM-NOT: pushq %rbp
+// ASM-NOT: movq %rsp, %rbp
+// ASM: pushq %rbx
+// ASM: movl $42, %eax
+// ASM: movl %eax, %ebx
+// ASM: movl %ebx, %eax
+// ASM: popq %rbx
+// ASM: retq
+extern(C) int stackManipulation() {
+    asm { naked; }
+    asm {
+        push RBX;           // Save callee-saved register
+        mov EAX, 42;
+        mov EBX, EAX;       // Use the saved register
+        mov EAX, EBX;
+        pop RBX;            // Restore
+        ret;
+    }
+}
+
+// Test 2: Forward jump (jump to label defined later)
+// ASM-LABEL: forwardJump:
+// ASM: jmp .LforwardJump_skip
+// ASM: .LforwardJump_skip:
+// ASM: retq
+extern(C) int forwardJump() {
+    asm { naked; }
+    asm {
+        mov EAX, 1;
+        jmp skip;           // Forward jump
+        mov EAX, 0;         // Should be skipped
+    skip:
+        ret;
+    }
+}
+
+// Test 3: Backward jump (loop)
+// ASM-LABEL: backwardJump:
+// ASM: .LbackwardJump_again:
+// ASM: incl %eax
+// ASM: cmpl $5, %eax
+// ASM: jl .LbackwardJump_again
+extern(C) int backwardJump() {
+    asm { naked; }
+    asm {
+        xor EAX, EAX;
+    again:
+        inc EAX;
+        cmp EAX, 5;
+        jl again;           // Backward jump
+        ret;
+    }
+}
+
+// Test 4: Multiple control flow paths
+// ASM-LABEL: multiPath:
+// ASM: .LmultiPath_path1:
+// ASM: .LmultiPath_path2:
+// ASM: .LmultiPath_done:
+extern(C) int multiPath(int x) {
+    asm { naked; }
+    version(D_InlineAsm_X86_64) asm {
+        // x is in EDI on SysV ABI
+        test EDI, EDI;
+        jz path1;
+        jmp path2;
+    path1:
+        mov EAX, 10;
+        jmp done;
+    path2:
+        mov EAX, 20;
+    done:
+        ret;
+    }
+}
+
+// Test 5: Runtime verification
+void main() {
+    // Verify stack manipulation works
+    assert(stackManipulation() == 42, "stackManipulation failed");
+
+    // Verify forward jump works
+    assert(forwardJump() == 1, "forwardJump failed");
+
+    // Verify backward jump (loop) works
+    assert(backwardJump() == 5, "backwardJump failed");
+
+    // Verify multi-path control flow
+    assert(multiPath(0) == 10, "multiPath(0) failed");
+    assert(multiPath(1) == 20, "multiPath(1) failed");
+}