Add pragma(musttail)

Author: MrSmith33

dmd/expression.d

@@ -3022,6 +3022,10 @@ extern (C++) final class CallExp : UnaExp
     bool inDebugStatement;  /// true if this was in a debug statement
     bool ignoreAttributes;  /// don't enforce attributes (e.g. call @gc function in @nogc code)
     bool isUfcsRewrite;     /// the first argument was pushed in here by a UFCS rewrite
+    version (IN_LLVM) {
+        bool isMustTail;    // If marked with pragma(musttail)
+    }
+
     VarDeclaration vthis2;  // container for multi-context
     Expression loweredFrom; // set if this is the result of a lowering
 

dmd/expression.h

@@ -845,6 +845,10 @@ class CallExp final : public UnaExp
     d_bool inDebugStatement;      // true if this was in a debug statement
     d_bool ignoreAttributes;      // don't enforce attributes (e.g. call @gc function in @nogc code)
     d_bool isUfcsRewrite;       // the first argument was pushed in here by a UFCS rewrite
+#if IN_LLVM
+    d_bool isMustTail;            // If marked with pragma(musttail)
+#endif
+
     VarDeclaration *vthis2;     // container for multi-context
     Expression* loweredFrom;    // set if this is the result of a lowering
 

dmd/id.d

@@ -564,6 +564,7 @@ immutable Msgtable[] msgtable =
     { "LDC_global_crt_dtor" },
     { "LDC_extern_weak" },
     { "LDC_profile_instr" },
+    { "musttail" },
 
     // IN_LLVM: LDC-specific traits
     { "targetCPU" },

dmd/id.h

@@ -76,6 +76,7 @@ struct Id
     static Identifier *LDC_inline_ir;
     static Identifier *LDC_extern_weak;
     static Identifier *LDC_profile_instr;
+    static Identifier *musttail;
     static Identifier *dcReflect;
     static Identifier *opencl;
     static Identifier *criticalenter;

dmd/pragmasem.d

@@ -398,6 +398,14 @@ bool pragmaStmtSemantic(PragmaStatement ps, Scope* sc)
         if (!pragmaMangleSemantic(ps.loc, sc, ps.args, decls.length ? &decls : null))
             return false;
     }
+    else if (ps.ident == Id.musttail)
+    {
+        version (IN_LLVM)
+        {
+            if (!pragmaMustTailSemantic(ps))
+                return false;
+        }
+    }
     else if (!global.params.ignoreUnsupportedPragmas)
     {
         error(ps.loc, "unrecognized `pragma(%s)`", ps.ident.toChars());
@@ -777,3 +785,36 @@ private bool pragmaMangleSemantic(Loc loc, Scope* sc, Expressions* args, Dsymbol
     }
     return true;
 }
+
+version (IN_LLVM)
+private bool pragmaMustTailSemantic(PragmaStatement ps)
+{
+    if (!ps._body)
+    {
+        error(ps.loc, "`pragma(musttail)` must be attached to a return statement");
+        return false;
+    }
+
+    auto rs = ps._body.isReturnStatement();
+    if (!rs)
+    {
+        error(ps.loc, "`pragma(musttail)` must be attached to a return statement");
+        return false;
+    }
+
+    if (!rs.exp)
+    {
+        error(ps.loc, "`pragma(musttail)` must be attached to a return statement returning result of a function call");
+        return false;
+    }
+
+    auto ce = rs.exp.isCallExp();
+    if (!ce)
+    {
+        error(ps.loc, "`pragma(musttail)` must be attached to a return statement returning result of a function call");
+        return false;
+    }
+
+    ce.isMustTail = true;
+    return true;
+}

gen/dpragma.d

@@ -44,7 +44,8 @@ extern (C++) enum LDCPragma : int {
   LLVMbitop_bts,
   LLVMbitop_vld,
   LLVMbitop_vst,
-  LLVMextern_weak
+  LLVMextern_weak,
+  LLVMmusttail,
 };
 
 extern (C++) LDCPragma DtoGetPragma(Scope* sc, PragmaDeclaration decl, ref const(char)* arg1str);

gen/llvmhelpers.h

@@ -205,7 +205,8 @@ bool DtoLowerMagicIntrinsic(IRState *p, FuncDeclaration *fndecl, CallExp *e,
 
 ///
 DValue *DtoCallFunction(Loc loc, Type *resulttype, DValue *fnval,
-                        Expressions *arguments, LLValue *sretPointer = nullptr, bool directcall = false);
+                        Expressions *arguments, LLValue *sretPointer = nullptr,
+                        bool directcall = false, bool isMustTail = false);
 
 Type *stripModifiers(Type *type, bool transitive = false);
 

gen/pragma.cpp

@@ -337,6 +337,15 @@ LDCPragma DtoGetPragma(Scope *sc, PragmaDeclaration *decl,
     return LLVMprofile_instr;
   }
 
+  // pragma(musttail)
+  if (ident == Id::musttail) {
+    if (args && args->length > 0) {
+      pragmaError("takes no parameters");
+      fatal();
+    }
+    return LLVMmusttail;
+  }
+
   return LLVMnone;
 }
 

gen/pragma.h

@@ -48,7 +48,8 @@ enum LDCPragma {
   LLVMbitop_vld,
   LLVMbitop_vst,
   LLVMextern_weak,
-  LLVMprofile_instr
+  LLVMprofile_instr,
+  LLVMmusttail,
 };
 
 LDCPragma DtoGetPragma(Scope *sc, PragmaDeclaration *decl, const char *&arg1str);

gen/tocall.cpp

@@ -839,7 +839,8 @@ static LLValue *DtoCallableValue(DValue *fn) {
 
 // FIXME: this function is a mess !
 DValue *DtoCallFunction(Loc loc, Type *resulttype, DValue *fnval,
-                        Expressions *arguments, LLValue *sretPointer, bool directcall) {
+                        Expressions *arguments, LLValue *sretPointer,
+                        bool directcall, bool isMustTail) {
   IF_LOG Logger::println("DtoCallFunction()");
   LOG_SCOPE
 
@@ -1060,6 +1061,18 @@ DValue *DtoCallFunction(Loc loc, Type *resulttype, DValue *fnval,
   attrlist = attrlist.addFnAttributes(
       gIR->context(), llvm::AttrBuilder(gIR->context(), attrbuildattribs));
   call->setAttributes(attrlist);
+  if (isMustTail) {
+    if (auto ci = llvm::dyn_cast<llvm::CallInst>(call)) {
+      ci->setTailCallKind(llvm::CallInst::TCK_MustTail);
+    } else {
+      if (!tf->isNothrow()) {
+        error(loc, "cannot perform tail-call - callee must be nothrow");
+      } else {
+        error(loc, "cannot perform tail-call - no code like destructors or scope(exit) should run after the call");
+      }
+      fatal();
+    }
+  }
 
   // Special case for struct constructor calls: For temporaries, using the
   // this pointer value returned from the constructor instead of the alloca