Merge pull request #5041 from CyberShadow/naked-llvm-ir-refactor

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

Author: kinke

CHANGELOG.md

@@ -3,6 +3,7 @@
 #### Big news
 - Support for [LLVM 22](https://releases.llvm.org/22.1.0/docs/ReleaseNotes.html). The prebuilt packages use v22.1.2. (#5097, #5102)
 - Minimum LLVM version raised to 18. (#5094)
+- DMD-style inline assembly: `asm { naked; }` is now much less of a special case wrt. codegen - such naked functions are now emitted as if `asm { naked; }` was replaced with the `@naked` function UDA. IR-wise, they are not emitted as module-level asm blobs anymore, but regular IR functions. This should lift a few former `asm { naked; }`-specific restrictions and fixed at least one LTO issue. (#5041)
 - Predefined version `LDC_LLVM_*` now only contains the LLVM major version, i.e., former `version (LDC_LLVM_1801)` with LLVM v18.1 is now `version (LDC_LLVM_18)`. Use `ldc.intrinsics.LLVM_version` for backwards compatibility if really needed. (#5109)
 
 #### Platform support

dmd/declaration.h

@@ -581,6 +581,9 @@ class FuncDeclaration : public Declaration
     VarDeclaration *v_argptr;           // '_argptr' variable
     VarDeclarations *parameters;        // Array of VarDeclaration's for parameters
     DsymbolTable *labtab;               // statement label symbol table
+#if IN_LLVM
+    Identifiers *asmLabels;             // identifiers of labels defined in DMD-style inline assembly
+#endif
     Dsymbol *overnext;                  // next in overload list
     FuncDeclaration *overnext0;         // next in overload list (only used during IFTI)
     Loc endloc;                         // location of closing curly bracket

dmd/func.d

@@ -256,6 +256,10 @@ version (IN_LLVM)
     VarDeclaration v_argptr;            /// '_argptr' variable
     VarDeclarations* parameters;        /// Array of VarDeclaration's for parameters
     DsymbolTable labtab;                /// statement label symbol table
+version (IN_LLVM)
+{
+    Identifiers* asmLabels;             /// identifiers of labels defined in DMD-style inline assembly
+}
     Dsymbol overnext;                   /// next in overload list
     FuncDeclaration overnext0;          /// next in overload list (only used during IFTI)
     Loc endloc;                         /// location of closing curly bracket

dmd/statementsem.d

@@ -3695,6 +3695,13 @@ version (IN_LLVM)
                 if (auto ls = s.isLabelStatement())
                 {
                     sc.func.searchLabel(ls.ident, ls.loc);
+
+version (IN_LLVM)
+{
+                    if (!sc.func.asmLabels)
+                        sc.func.asmLabels = new Identifiers();
+                    sc.func.asmLabels.push(ls.ident);
+}
                 }
             }
         }

gen/asm-x86.h

@@ -2340,57 +2340,15 @@ struct AsmProcessor {
                   AsmCode *asmcode, AsmArgMode mode = Mode_Input) {
     using namespace dmd;
 
-    if (sc->func->isNaked()) {
-      switch (type) {
-      case Arg_Integer:
-        if (e->type->isUnsigned()) {
-          insnTemplate << "$" << e->toUInteger();
-        } else {
+    if (type == Arg_Integer) {
+      if (e->type->isUnsigned()) {
+        insnTemplate << "$$" << e->toUInteger();
+      } else {
 #ifndef ASM_X86_64
-          insnTemplate << "$" << static_cast<sinteger_t>(e->toInteger());
+        insnTemplate << "$$" << static_cast<sinteger_t>(e->toInteger());
 #else
-          insnTemplate << "$" << e->toInteger();
+        insnTemplate << "$$" << e->toInteger();
 #endif
-        }
-        break;
-
-      case Arg_Pointer:
-        error(stmt->loc, "unsupported pointer reference to `%s` in naked asm",
-                    e->toChars());
-        break;
-
-      case Arg_Memory:
-        // Peel off one layer of explicitly taking the address, if present.
-        if (auto ae = e->isAddrExp()) {
-          e = ae->e1;
-        }
-
-        if (auto v = e->isVarExp()) {
-          if (VarDeclaration *vd = v->var->isVarDeclaration()) {
-            if (!vd->isDataseg()) {
-              error(stmt->loc, "only global variables can be referenced by "
-                          "identifier in naked asm");
-              break;
-            }
-
-            // print out the mangle
-            if (prependExtraUnderscore(vd->resolvedLinkage())) {
-              insnTemplate << "_";
-            }
-            OutBuffer buf;
-            mangleToBuffer(vd, buf);
-            insnTemplate << buf.peekChars();
-            getIrGlobal(vd, true)->nakedUse = true;
-            break;
-          }
-        }
-        error(stmt->loc, "unsupported memory reference to `%s` in naked asm",
-                    e->toChars());
-        break;
-
-      default:
-        llvm_unreachable("Unsupported argument in asm.");
-        break;
       }
     } else {
       insnTemplate << fmt << "<<" << (mode == Mode_Input ? "in" : "out")
@@ -2401,13 +2359,6 @@ struct AsmProcessor {
   void addOperand2(const char *fmtpre, const char *fmtpost, AsmArgType type,
                    Expression *e, AsmCode *asmcode,
                    AsmArgMode mode = Mode_Input) {
-    if (sc->func->isNaked()) {
-      // taken from above
-      error(stmt->loc, "only global variables can be referenced by identifier in "
-                  "naked asm");
-      return;
-    }
-
     insnTemplate << fmtpre << "<<" << (mode == Mode_Input ? "in" : "out")
                  << ">>" << fmtpost;
     asmcode->args.push_back(AsmArg(type, e, mode));
@@ -3078,11 +3029,9 @@ struct AsmProcessor {
               // If we subtract 8 from our const-displacement, then we can use the `H` modifier to ensure
               // that we always end up with a valid syntax for a memory operand with an offset.
               // So, we do just that when we have const-displacement in play.
-              // (Only for non-naked asm, as this isn't an issue for naked asm.)
               //
               // See also: https://lists.llvm.org/pipermail/llvm-dev/2017-August/116244.html
-              const auto forceLeadingDisplacement = hasConstDisplacement && !sc->func->isNaked();
-              if (forceLeadingDisplacement) {
+              if (hasConstDisplacement) {
                 // Subtract 8 from our const-displacement, and prepare to add the 8 from the `H` modifier.
                 insnTemplate << "-8+";
               }
@@ -3092,14 +3041,11 @@ struct AsmProcessor {
                 use_star = false;
               }
 
-              if (!sc->func->isNaked()) // no addrexp in naked asm please :)
-              {
-                Type *tt = pointerTo(e->type);
-                e = createAddrExp(Loc(), e);
-                e->type = tt;
-              }
+              Type *tt = pointerTo(e->type);
+              e = createAddrExp(Loc(), e);
+              e->type = tt;
 
-              if (forceLeadingDisplacement) {
+              if (hasConstDisplacement) {
                 // We have a const-displacement in play, so we add the `H` modifier, as described earlier.
                 insnTemplate << "${" << "<<" << (mode == Mode_Input ? "in" : "out")
                              << asmcode->args.size() << ">>" << ":H}";

gen/asmstmt.cpp

@@ -532,9 +532,14 @@ void CompoundAsmStatement_toIR(CompoundAsmStatement *stmt, IRState *p) {
       }
       Identifier *const ident = targetLabel->ident;
 
-      // if internal, no special handling is necessary, skip
-      if (llvm::any_of(asmblock->internalLabels,
-                       [ident](Identifier *i) { return i->equals(ident); })) {
+      // if the label is defined in inline asm, we can jump to it directly
+      if (fd->isNaked() // in naked DMD-style inline-asm functions, all D labels
+                        // become assembly labels too (and the extra forwarding
+                        // code would mess with the stack due to an i32 alloca)
+          || (fd->asmLabels &&
+              llvm::any_of(*fd->asmLabels, [ident](Identifier *i) {
+                return i->equals(ident);
+              }))) {
         continue;
       }
 
@@ -784,21 +789,3 @@ void CompoundAsmStatement_toIR(CompoundAsmStatement *stmt, IRState *p) {
     p->ir->SetInsertPoint(bb);
   }
 }
-
-//////////////////////////////////////////////////////////////////////////////
-
-void AsmStatement_toNakedIR(InlineAsmStatement *stmt, IRState *irs) {
-  IF_LOG Logger::println("InlineAsmStatement::toNakedIR(): %s",
-                         stmt->loc.toChars());
-  LOG_SCOPE;
-
-  // is there code?
-  if (!stmt->asmcode) {
-    return;
-  }
-  AsmCode *code = static_cast<AsmCode *>(stmt->asmcode);
-
-  // build asm stmt
-  replace_func_name(irs, code->insnTemplate);
-  irs->nakedAsm << "\t" << code->insnTemplate << std::endl;
-}

gen/functions.cpp

@@ -773,10 +773,8 @@ static LinkageWithCOMDAT lowerFuncLinkage(FuncDeclaration *fdecl) {
     return LinkageWithCOMDAT(LLGlobalValue::ExternalLinkage, false);
   }
 
-  // A body-less declaration always needs to be marked as external in LLVM
-  // (also e.g. naked template functions which would otherwise be weak_odr,
-  // but where the definition is in module-level inline asm).
-  if (!fdecl->fbody || fdecl->isNaked()) {
+  // A body-less declaration always needs to be marked as external in LLVM.
+  if (!fdecl->fbody) {
     return LinkageWithCOMDAT(LLGlobalValue::ExternalLinkage, false);
   }
 
@@ -1119,12 +1117,6 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
     gIR->funcGenStates.pop_back();
   };
 
-  // if this function is naked, we take over right away! no standard processing!
-  if (fd->isNaked()) {
-    DtoDefineNakedFunction(fd);
-    return;
-  }
-
   SCOPE_EXIT {
     if (irFunc->isDynamicCompiled()) {
       defineDynamicCompiledFunction(gIR, irFunc);
@@ -1208,31 +1200,26 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
   gIR->ir->setFastMathFlags(irFunc->FMF);
   gIR->DBuilder.EmitFuncStart(fd);
 
-  // @naked: emit body and return, no prologue/epilogue
-  if (func->hasFnAttribute(llvm::Attribute::Naked)) {
-    Statement_toIR(fd->fbody, gIR);
-    const bool wasDummy = eraseDummyAfterReturnBB(gIR->scopebb());
-    if (!wasDummy && !gIR->scopereturned()) {
-      // this is what clang does to prevent LLVM complaining about
-      // non-terminated function
-      gIR->ir->CreateUnreachable();
-    }
-    return;
+  if (fd->isNaked()) { // DMD-style `asm { naked; }`
+    func->addFnAttr(llvm::Attribute::Naked);
   }
 
+  // @naked: emit body and return, no prologue/epilogue
+  const bool isNaked = func->hasFnAttribute(llvm::Attribute::Naked);
+
   // create temporary allocas block
   funcGen.allocasBlock =
       llvm::BasicBlock::Create(gIR->context(), "allocas", func);
 
   emitInstrumentationFnEnter(fd);
 
   if (global.params.trace && fd->emitInstrumentation && !fd->isCMain() &&
-      !fd->isNaked()) {
+      !isNaked) {
     emitDMDStyleFunctionTrace(*gIR, fd, funcGen);
   }
 
   // give the 'this' parameter (an lvalue) storage and debug info
-  if (irFty.arg_this) {
+  if (!isNaked && irFty.arg_this) {
     LLValue *thisvar = irFunc->thisArg;
     assert(thisvar);
 
@@ -1254,7 +1241,7 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
   }
 
   // define all explicit parameters
-  if (fd->parameters)
+  if (!isNaked && fd->parameters)
     defineParameters(irFty, *fd->parameters);
 
   // Initialize PGO state for this function
@@ -1320,7 +1307,10 @@ void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally) {
 
     // pass the previous block into this block
     gIR->DBuilder.EmitStopPoint(fd->endloc);
-    if (func->getReturnType() == LLType::getVoidTy(gIR->context())) {
+
+    if (isNaked) {
+      gIR->ir->CreateUnreachable();
+    } else if (func->getReturnType() == LLType::getVoidTy(gIR->context())) {
       gIR->ir->CreateRetVoid();
     } else if (isAnyMainFunction(fd)) {
       gIR->ir->CreateRet(LLConstant::getNullValue(func->getReturnType()));

gen/functions.h

@@ -40,7 +40,6 @@ void DtoResolveFunction(FuncDeclaration *fdecl);
 void DtoDeclareFunction(FuncDeclaration *fdecl);
 void DtoDefineFunction(FuncDeclaration *fd, bool linkageAvailableExternally = false);
 
-void DtoDefineNakedFunction(FuncDeclaration *fd);
 void emitABIReturnAsmStmt(IRAsmBlock *asmblock, Loc loc,
                           FuncDeclaration *fdecl);
 

gen/irstate.h

@@ -94,9 +94,6 @@ struct IRAsmBlock {
   std::set<std::string> clobs;
   size_t outputcount;
 
-  // stores the labels within the asm block
-  std::vector<Identifier *> internalLabels;
-
   CompoundAsmStatement *asmBlock;
   LLType *retty;
   unsigned retn;
@@ -220,7 +217,6 @@ struct IRState {
 
   // for inline asm
   IRAsmBlock *asmBlock = nullptr;
-  std::ostringstream nakedAsm;
 
   // Globals to pin in the llvm.used array to make sure they are not
   // eliminated.