add codegen methods for setting tailcall kind

Author: xacrimon

compiler/rustc_codegen_gcc/src/builder.rs

@@ -1755,6 +1755,13 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         // FIXME(bjorn3): implement
     }
 
+    fn set_tail_call(&mut self, _call_inst: RValue<'gcc>) {
+        // Explicitly fail when this method is called
+        bug!(
+            "Guaranteed tail calls with the 'become' keyword are not implemented in the GCC backend"
+        );
+    }
+
     fn set_span(&mut self, _span: Span) {}
 
     fn from_immediate(&mut self, val: Self::Value) -> Self::Value {

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1371,6 +1371,11 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let cold_inline = llvm::AttributeKind::Cold.create_attr(self.llcx);
         attributes::apply_to_callsite(llret, llvm::AttributePlace::Function, &[cold_inline]);
     }
+
+    fn set_tail_call(&mut self, call_inst: &'ll Value) {
+        // Use musttail for guaranteed tail call optimization required by 'become'
+        llvm::LLVMRustSetTailCallKind(call_inst, llvm::TailCallKind::MustTail);
+    }
 }
 
 impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> {

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -97,6 +97,17 @@ pub(crate) enum ModuleFlagMergeBehavior {
 
 // Consts for the LLVM CallConv type, pre-cast to usize.
 
+/// LLVM TailCallKind for musttail support
+#[derive(Copy, Clone, PartialEq, Debug)]
+#[repr(C)]
+#[allow(dead_code)]
+pub(crate) enum TailCallKind {
+    None = 0,
+    Tail = 1,
+    MustTail = 2,
+    NoTail = 3,
+}
+
 /// LLVM CallingConv::ID. Should we wrap this?
 ///
 /// See <https://github.com/llvm/llvm-project/blob/main/llvm/include/llvm/IR/CallingConv.h>
@@ -1181,6 +1192,7 @@ unsafe extern "C" {
     pub(crate) safe fn LLVMIsGlobalConstant(GlobalVar: &Value) -> Bool;
     pub(crate) safe fn LLVMSetGlobalConstant(GlobalVar: &Value, IsConstant: Bool);
     pub(crate) safe fn LLVMSetTailCall(CallInst: &Value, IsTailCall: Bool);
+    pub(crate) safe fn LLVMRustSetTailCallKind(CallInst: &Value, Kind: TailCallKind);
 
     // Operations on attributes
     pub(crate) fn LLVMCreateStringAttribute(

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -342,6 +342,99 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
 
 /// Codegen implementations for some terminator variants.
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
+    #[allow(dead_code)]
+    fn codegen_tail_call_terminator(
+        &mut self,
+        bx: &mut Bx,
+        func: &mir::Operand<'tcx>,
+        args: &[Spanned<mir::Operand<'tcx>>],
+        fn_span: Span,
+    ) {
+        // We don't need source_info as we already have fn_span for diagnostics
+        let func = self.codegen_operand(bx, func);
+        let fn_ty = func.layout.ty;
+
+        // Create the callee. This is a fn ptr or zero-sized and hence a kind of scalar.
+        let (fn_ptr, fn_abi, instance) = match *fn_ty.kind() {
+            ty::FnDef(def_id, substs) => {
+                let instance = ty::Instance::expect_resolve(
+                    bx.tcx(),
+                    bx.typing_env(),
+                    def_id,
+                    substs,
+                    fn_span,
+                );
+                let fn_ptr = bx.get_fn_addr(instance);
+                let fn_abi = bx.fn_abi_of_instance(instance, ty::List::empty());
+                (fn_ptr, fn_abi, Some(instance))
+            }
+            ty::FnPtr(..) => {
+                let sig = fn_ty.fn_sig(bx.tcx());
+                let extra_args = bx.tcx().mk_type_list(&[]);
+                let fn_ptr = func.immediate();
+                let fn_abi = bx.fn_abi_of_fn_ptr(sig, extra_args);
+                (fn_ptr, fn_abi, None)
+            }
+            _ => bug!("{} is not callable", func.layout.ty),
+        };
+
+        let mut llargs = Vec::with_capacity(args.len());
+        let mut lifetime_ends_after_call = Vec::new();
+
+        // Process arguments
+        for arg in args {
+            let op = self.codegen_operand(bx, &arg.node);
+            let arg_idx = llargs.len();
+
+            if arg_idx < fn_abi.args.len() {
+                self.codegen_argument(
+                    bx,
+                    op,
+                    &mut llargs,
+                    &fn_abi.args[arg_idx],
+                    &mut lifetime_ends_after_call,
+                );
+            } else {
+                // This can happen in case of C-variadic functions
+                let is_immediate = match op.val {
+                    Immediate(_) => true,
+                    _ => false,
+                };
+
+                if is_immediate {
+                    llargs.push(op.immediate());
+                } else {
+                    let temp = PlaceRef::alloca(bx, op.layout);
+                    op.val.store(bx, temp);
+                    llargs.push(bx.load(
+                        bx.backend_type(op.layout),
+                        temp.val.llval,
+                        temp.val.align,
+                    ));
+                }
+            }
+        }
+
+        // Call the function
+        let fn_ty = bx.fn_decl_backend_type(fn_abi);
+        let fn_attrs = if let Some(instance) = instance
+            && bx.tcx().def_kind(instance.def_id()).has_codegen_attrs()
+        {
+            Some(bx.tcx().codegen_fn_attrs(instance.def_id()))
+        } else {
+            None
+        };
+
+        // Perform the actual function call
+        let llret = bx.call(fn_ty, fn_attrs, Some(fn_abi), fn_ptr, &llargs, None, instance);
+
+        // Mark as tail call - this is the critical part
+        bx.set_tail_call(llret);
+
+        // Return the result - musttail requires ret immediately after the call
+        bx.ret(llret);
+    }
+
     /// Generates code for a `Resume` terminator.
     fn codegen_resume_terminator(&mut self, helper: TerminatorCodegenHelper<'tcx>, bx: &mut Bx) {
         if let Some(funclet) = helper.funclet(self) {

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -595,6 +595,8 @@ pub trait BuilderMethods<'a, 'tcx>:
         funclet: Option<&Self::Funclet>,
         instance: Option<Instance<'tcx>>,
     ) -> Self::Value;
+
+    fn set_tail_call(&mut self, call_inst: Self::Value);
     fn zext(&mut self, val: Self::Value, dest_ty: Self::Type) -> Self::Value;
 
     fn apply_attrs_to_cleanup_callsite(&mut self, llret: Self::Value);