Implement guaranteed tail calls with the become keyword in the LLVM backend

Author: semtexzv

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1419,6 +1419,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) {
+        // LLVMSetTailCall is marked as safe in the FFI definition
+        llvm::LLVMSetTailCall(call_inst, llvm::True);
+    }
 }
 
 impl<'ll> StaticBuilderMethods for Builder<'_, 'll, '_> {

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -342,6 +342,90 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
 
 /// Codegen implementations for some terminator variants.
 impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
+    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());
+
+        // 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]);
+            } 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
+        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) {
@@ -1430,12 +1514,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 fn_span,
                 mergeable_succ(),
             ),
-            mir::TerminatorKind::TailCall { .. } => {
-                // FIXME(explicit_tail_calls): implement tail calls in ssa backend
-                span_bug!(
-                    terminator.source_info.span,
-                    "`TailCall` terminator is not yet supported by `rustc_codegen_ssa`"
-                )
+            mir::TerminatorKind::TailCall { ref func, ref args, fn_span } => {
+                self.codegen_tail_call_terminator(bx, func, args, fn_span);
+                MergingSucc::False
             }
             mir::TerminatorKind::CoroutineDrop | mir::TerminatorKind::Yield { .. } => {
                 bug!("coroutine ops in codegen")

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -555,6 +555,10 @@ pub trait BuilderMethods<'a, 'tcx>:
         funclet: Option<&Self::Funclet>,
         instance: Option<Instance<'tcx>>,
     ) -> Self::Value;
+
+    /// Mark a call instruction as a tail call (guaranteed tail call optimization)
+    /// Used for implementing the `become` expression
+    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);

tests/run-make/tail-call-llvm-ir/Makefile

@@ -0,0 +1,26 @@
+# This test verifies that the `become` keyword generates tail call instructions in LLVM IR
+
+# Use the Rust compiler from the build directory
+RUSTC ?= ../../../build/aarch64-apple-darwin/stage1/bin/rustc
+
+all: verify-tail-call
+
+verify-tail-call:
+	# Create test file with debuginfo to ensure function names are preserved
+	$(RUSTC) tail-call-test.rs --emit=llvm-ir -g -C opt-level=0
+	
+	# Check that `become` generates 'tail call' instructions for with_tail function
+	grep -q "tail call.*@_ZN14tail_call_test9with_tail" tail-call-test.ll || (echo "ERROR: 'tail call' instruction not found for with_tail"; exit 1)
+	
+	# Check that regular recursive calls don't use tail call optimization by default
+	grep -q "@_ZN14tail_call_test7no_tail" tail-call-test.ll || (echo "ERROR: no_tail function not found"; exit 1)
+	! grep -q "tail call.*@_ZN14tail_call_test7no_tail" tail-call-test.ll || (echo "ERROR: Regular function call incorrectly marked as tail call"; exit 1)
+	
+	# Check mutual recursion with 'become'
+	grep -q "tail call.*@_ZN14tail_call_test14even_with_tail" tail-call-test.ll || (echo "ERROR: 'tail call' instruction not found for even_with_tail"; exit 1)
+	grep -q "tail call.*@_ZN14tail_call_test13odd_with_tail" tail-call-test.ll || (echo "ERROR: 'tail call' instruction not found for odd_with_tail"; exit 1)
+	
+	# The test passes only if all checks above confirm that:
+	# 1. Functions using 'become' generate LLVM tail call instructions
+	# 2. Regular recursive functions don't generate tail call instructions
+	@echo "LLVM IR verification successful: 'become' correctly generates 'tail call' instructions"

tests/run-make/tail-call-llvm-ir/tail-call-test.ll

@@ -0,0 +1,65 @@
+#![feature(explicit_tail_calls)]
+
+// A recursive function that uses explicit tail calls with 'become'
+// This should generate LLVM IR with "tail call" instructions
+pub fn with_tail(n: u32) -> u32 {
+    if n == 0 { 0 } else { become with_tail(n - 1) }
+}
+
+// A similar recursive function but without 'become'
+// This should NOT generate tail call instructions by default
+pub fn no_tail(n: u32) -> u32 {
+    if n == 0 { 0 } else { no_tail(n - 1) }
+}
+
+// Mutual recursion with 'become'
+// Both functions should generate tail call instructions
+pub fn even_with_tail(n: u32) -> bool {
+    match n {
+        0 => true,
+        _ => become odd_with_tail(n - 1),
+    }
+}
+
+pub fn odd_with_tail(n: u32) -> bool {
+    match n {
+        0 => false,
+        _ => become even_with_tail(n - 1),
+    }
+}
+
+// For comparison: mutual recursion without 'become'
+// These should NOT generate tail call instructions
+pub fn even_no_tail(n: u32) -> bool {
+    match n {
+        0 => true,
+        _ => odd_no_tail(n - 1),
+    }
+}
+
+pub fn odd_no_tail(n: u32) -> bool {
+    match n {
+        0 => false,
+        _ => even_no_tail(n - 1),
+    }
+}
+
+fn main() {
+    // Actually use all the functions to ensure they're not optimized away
+    let with_tail_result = with_tail(5);
+    let no_tail_result = no_tail(5);
+    let even_with_tail_result = even_with_tail(10);
+    let odd_with_tail_result = odd_with_tail(10);
+    let even_no_tail_result = even_no_tail(10);
+    let odd_no_tail_result = odd_no_tail(10);
+
+    println!(
+        "Results: {} {} {} {} {} {}",
+        with_tail_result,
+        no_tail_result,
+        even_with_tail_result,
+        odd_with_tail_result,
+        even_no_tail_result,
+        odd_no_tail_result
+    );
+}

tests/run-make/tail-call-llvm-ir/tail-call-test.rs

@@ -0,0 +1,4 @@
+# Simple Makefile for Rust tests
+
+# Default rustc to use
+RUSTC ?= ../../../build/aarch64-apple-darwin/stage1/bin/rustc

tests/run-make/tail-call-llvm-ir/tools.mk

@@ -0,0 +1,35 @@
+//@ compile-flags: -O
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+// A deep recursive function that uses explicit tail calls
+// This will cause stack overflow without tail call optimization
+fn deep_recursion(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        _ => become deep_recursion(n - 1)
+    }
+}
+
+// A deep recursive function without explicit tail calls
+// This will overflow the stack for large values
+fn deep_recursion_no_tail(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        _ => deep_recursion_no_tail(n - 1)
+    }
+}
+
+fn main() {
+    // Verify correctness for small values
+    assert_eq!(deep_recursion(10), 0);
+    assert_eq!(deep_recursion_no_tail(10), 0);
+    
+    // This will succeed only if tail call optimization is working
+    // It would overflow the stack otherwise
+    println!("Starting deep recursion with 50,000 calls");
+    let result = deep_recursion(50_000);
+    assert_eq!(result, 0);
+    println!("Successfully completed 50,000 recursive calls with tail call optimization");
+}

tests/ui/explicit-tail-calls/llvm-ir-tail-call.rs

@@ -0,0 +1,63 @@
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+// This is a classic example of mutual recursion:
+// even(n) calls odd(n-1), and odd(n) calls even(n-1)
+// Without tail calls, this would quickly overflow the stack for large inputs
+
+// Check if a number is even using mutual recursion
+fn is_even(n: u64) -> bool {
+    match n {
+        0 => true,
+        _ => become is_odd(n - 1)
+    }
+}
+
+// Check if a number is odd using mutual recursion
+fn is_odd(n: u64) -> bool {
+    match n {
+        0 => false,
+        _ => become is_even(n - 1)
+    }
+}
+
+// Versions without tail calls for comparison
+fn is_even_no_tail(n: u64) -> bool {
+    match n {
+        0 => true,
+        _ => is_odd_no_tail(n - 1)
+    }
+}
+
+fn is_odd_no_tail(n: u64) -> bool {
+    match n {
+        0 => false,
+        _ => is_even_no_tail(n - 1)
+    }
+}
+
+fn main() {
+    // Verify correctness for small values
+    assert_eq!(is_even(0), true);
+    assert_eq!(is_odd(0), false);
+    assert_eq!(is_even(1), false);
+    assert_eq!(is_odd(1), true);
+    assert_eq!(is_even(10), true);
+    assert_eq!(is_odd(10), false);
+    
+    // Test with an extremely large number that would definitely overflow the stack
+    // without tail call optimization - each call creates 2 stack frames (alternating between functions)
+    // so 100,000 would create 200,000 stack frames total
+    assert_eq!(is_even(100_000), true);
+    assert_eq!(is_odd(100_000), false);
+    assert_eq!(is_even(100_001), false);
+    assert_eq!(is_odd(100_001), true);
+    
+    println!("Deep mutual recursion test passed with 100,000 alternating recursive calls!");
+    
+    // Verify non-tail versions work for small values
+    assert_eq!(is_even_no_tail(10), true);
+    assert_eq!(is_odd_no_tail(10), false);
+    // But would overflow for large values (not tested to avoid crashing)
+}

tests/ui/explicit-tail-calls/mutual-recursion.rs

@@ -0,0 +1,38 @@
+//@ run-pass
+#![expect(incomplete_features)]
+#![feature(explicit_tail_calls)]
+
+// A function that causes deep recursion - counts down from n to 0
+// Without tail calls, this would overflow the stack for large n values
+fn countdown(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        _ => become countdown(n - 1)
+    }
+}
+
+// Same function but without tail call optimization
+fn countdown_no_tail(n: u32) -> u32 {
+    match n {
+        0 => 0,
+        _ => countdown_no_tail(n - 1)
+    }
+}
+
+// This test is specifically designed to verify tail call optimization
+// We use an extremely large recursion depth (500,000) that would 
+// absolutely overflow the stack without tail call optimization
+fn main() {
+    // Small test to verify correctness
+    assert_eq!(countdown(10), 0);
+    
+    // Regular recursion would overflow here (500,000 stack frames)
+    // Only works if tail call optimization is actually happening
+    let result = countdown(500_000);
+    assert_eq!(result, 0);
+    println!("Successfully completed 500,000 recursive calls with tail call optimization");
+    
+    // We can't test the non-tail version with a large number as it would crash,
+    // but we can verify it works for small values
+    assert_eq!(countdown_no_tail(10), 0);
+}