Lift the same-signature restriction for extern "tail"

Author: folkertdev

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1317,7 +1317,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     }
                     LocalRef::Operand(arg) => {
                         let Ref(place_value) = arg.val else {
-                            bug!("only `Ref` should use `PassMode::Indirect`");
+                            bug!(
+                                "only `Ref` should use `PassMode::Indirect`, but got {:?}",
+                                arg.val
+                            );
                         };
                         bx.typed_place_copy(place_value, tmp.val, fn_abi.args[i].layout);
                         op.val = arg.val;

compiler/rustc_hir_typeck/src/check.rs

@@ -90,7 +90,7 @@ pub(super) fn check_fn<'a, 'tcx>(
         }
 
         // Check that argument is Sized.
-        if !params_can_be_unsized {
+        if !params_can_be_unsized || fn_sig.abi() == rustc_abi::ExternAbi::RustTail {
             fcx.require_type_is_sized(
                 param_ty,
                 param.ty_span,

compiler/rustc_mir_build/src/check_tail_calls.rs

@@ -131,7 +131,8 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
         let callee_sig =
             self.tcx.normalize_erasing_late_bound_regions(self.typing_env, ty.fn_sig(self.tcx));
 
-        if caller_sig.abi() != callee_sig.abi() {
+        if caller_sig.abi() != callee_sig.abi() && !matches!(callee_sig.abi(), ExternAbi::RustTail)
+        {
             self.report_abi_mismatch(expr.span, caller_sig.abi(), callee_sig.abi());
         }
 
@@ -147,7 +148,9 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
         // ```
         // we should think what is the expected behavior here.
         // (we should probably just accept this by revealing opaques?)
-        if caller_sig.inputs_and_output != callee_sig.inputs_and_output {
+        if caller_sig.inputs_and_output != callee_sig.inputs_and_output
+            && !matches!(callee_sig.abi(), ExternAbi::RustTail)
+        {
             let caller_ty = self.tcx.type_of(self.caller_def_id).skip_binder();
 
             self.report_signature_mismatch(
@@ -189,6 +192,12 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
         if callee_sig.c_variadic() {
             self.report_c_variadic_callee(expr.span);
         }
+
+        for &arg_ty in callee_sig.inputs() {
+            if !arg_ty.is_sized(self.tcx, self.typing_env) {
+                self.report_unsized_argument(expr.span, arg_ty);
+            }
+        }
     }
 
     /// Returns true if the caller function needs a location argument
@@ -417,6 +426,17 @@ impl<'tcx> TailCallCkVisitor<'_, 'tcx> {
 
         self.found_errors = Err(err);
     }
+
+    fn report_unsized_argument(&mut self, sp: Span, arg_ty: Ty<'tcx>) {
+        let err = self
+            .tcx
+            .dcx()
+            .struct_span_err(sp, format!("unsized arguments cannot be used in a tail call"))
+            .with_note(format!("unsized argument of type `{arg_ty}`"))
+            .emit();
+
+        self.found_errors = Err(err);
+    }
 }
 
 impl<'a, 'tcx> Visitor<'a, 'tcx> for TailCallCkVisitor<'a, 'tcx> {

compiler/rustc_target/src/callconv/mod.rs

@@ -828,6 +828,10 @@ impl<'a, Ty> FnAbi<'a, Ty> {
                         };
                         arg.cast_to_with_attrs(Reg { kind: RegKind::Integer, size }, attr.into());
                     }
+
+                    if self.conv == CanonAbi::RustTail && arg.layout.is_sized() {
+                        arg.pass_by_stack_offset(None);
+                    }
                 }
 
                 BackendRepr::SimdVector { .. } => {

compiler/rustc_ty_utils/src/abi.rs

@@ -458,8 +458,10 @@ fn fn_abi_sanity_check<'tcx>(
                 // omitted entirely in the calling convention.
                 assert!(arg.is_ignore());
             }
-            if let PassMode::Indirect { on_stack, .. } = arg.mode {
-                assert!(!on_stack, "rust abi shouldn't use on_stack");
+            if let PassMode::Indirect { on_stack, .. } = arg.mode
+                && spec_abi != ExternAbi::RustTail
+            {
+                assert!(!on_stack, "rustic abi {spec_abi:?} shouldn't use on_stack");
             }
         } else if arg.layout.pass_indirectly_in_non_rustic_abis(cx) {
             assert_matches!(

tests/ui/explicit-tail-calls/no-unsized-arguments.rs

@@ -0,0 +1,56 @@
+//@ check-fail
+//@ min-llvm-version: 22
+//
+//@ revisions: x86 x86_64 aarch64
+//
+//@ [x86] only-x86
+//@ [x86_64] only-x86_64
+//@ [aarch64] only-aarch64
+#![feature(explicit_tail_calls, rust_tail_cc, unsized_fn_params)]
+#![allow(incomplete_features, internal_features)]
+#![crate_type = "lib"]
+
+mod vanilla {
+    fn unsized_argument(x: [u8]) -> u8 {
+        x[0]
+    }
+
+    pub fn caller(_: [u8]) -> u8 {
+        let b: Box<[u8]> = Box::new([1, 2, 3]);
+
+        // Non-tail call.
+        let _ = unsized_argument(*b);
+
+        become unsized_argument(*b);
+        //~^ ERROR unsized arguments cannot be used in a tail call
+    }
+}
+
+mod tailcc {
+    // `extern "tail"` is special because we also can't unsized parameters in standard definitions
+    // and calls.
+    extern "tail" fn unsized_argument(x: [u8]) -> u8 {
+        //~^ ERROR the size for values of type `[u8]` cannot be known at compilation time
+        x[0]
+    }
+
+    pub fn extern_rust_caller() -> u8 {
+        let b: Box<[u8]> = Box::new([1, 2, 3]);
+
+        // Non-tail call.
+        let _ = unsized_argument(*b);
+
+        become unsized_argument(*b);
+        //~^ ERROR unsized arguments cannot be used in a tail call
+    }
+
+    pub extern "tail" fn extern_tail_caller() -> u8 {
+        let b: Box<[u8]> = Box::new([1, 2, 3]);
+
+        // Vanilla call.
+        let _ = unsized_argument(*b);
+
+        become unsized_argument(*b);
+        //~^ ERROR unsized arguments cannot be used in a tail call
+    }
+}

tests/ui/explicit-tail-calls/no-unsized-arguments.x86_64.stderr

@@ -0,0 +1,39 @@
+error[E0277]: the size for values of type `[u8]` cannot be known at compilation time
+  --> $DIR/no-unsized-arguments.rs:32:42
+   |
+LL |     extern "tail" fn unsized_argument(x: [u8]) -> u8 {
+   |                                          ^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `Sized` is not implemented for `[u8]`
+help: function arguments must have a statically known size, borrowed slices always have a known size
+   |
+LL |     extern "tail" fn unsized_argument(x: &[u8]) -> u8 {
+   |                                          +
+
+error: unsized arguments cannot be used in a tail call
+  --> $DIR/no-unsized-arguments.rs:24:9
+   |
+LL |         become unsized_argument(*b);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: unsized argument of type `[u8]`
+
+error: unsized arguments cannot be used in a tail call
+  --> $DIR/no-unsized-arguments.rs:43:9
+   |
+LL |         become unsized_argument(*b);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: unsized argument of type `[u8]`
+
+error: unsized arguments cannot be used in a tail call
+  --> $DIR/no-unsized-arguments.rs:53:9
+   |
+LL |         become unsized_argument(*b);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: unsized argument of type `[u8]`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.

tests/ui/explicit-tail-calls/tailcc-no-signature-restriction.rs

@@ -0,0 +1,58 @@
+//@ run-pass
+//@ min-llvm-version: 22
+//@ revisions: x86 x86_64 aarch64
+//
+//@ [x86] only-x86
+//@ [x86_64] only-x86_64
+//@ [aarch64] only-aarch64
+#![feature(explicit_tail_calls, rust_tail_cc)]
+
+mod add {
+    pub fn extern_rust_caller() -> u64 {
+        become add(1, 2);
+    }
+
+    pub extern "tail" fn extern_tail_caller() -> u64 {
+        become add(1, 2);
+    }
+
+    #[inline(never)]
+    extern "tail" fn add(a: u64, b: u64) -> u64 {
+        a.wrapping_add(b)
+    }
+}
+
+mod pass_struct {
+    #[derive(Clone, Copy)]
+    pub struct Large {
+        pub a: u64,
+        pub b: u64,
+        pub c: u64,
+        pub d: u64,
+    }
+
+    pub fn extern_rust_caller(a: u64, d: u64) -> u64 {
+        let large = Large { a, b: 0xBBBB_BBBB_BBBB_BBBB, c: 0xCCCC_CCCC_CCCC_CCCC, d };
+        become add(large);
+    }
+
+    pub extern "tail" fn extern_tail_caller(a: u64, d: u64) -> u64 {
+        let large = Large { a, b: 0xBBBB_BBBB_BBBB_BBBB, c: 0xCCCC_CCCC_CCCC_CCCC, d };
+        become add(large);
+    }
+
+    #[inline(never)]
+    extern "tail" fn add(large: Large) -> u64 {
+        let _ = large.b;
+        let _ = large.c;
+        large.a.wrapping_add(large.d)
+    }
+}
+
+fn main() {
+    assert_eq!(add::extern_rust_caller(), 3);
+    assert_eq!(add::extern_tail_caller(), 3);
+
+    assert_eq!(pass_struct::extern_rust_caller(5, 6), 5 + 6);
+    assert_eq!(pass_struct::extern_tail_caller(5, 6), 5 + 6);
+}