diff --git a/tests/ui/c-variadic/same-program-multiple-abis-arm.rs b/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
index 1445bbb47bbd..fbc5573c5d76 100644
--- a/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
+++ b/tests/ui/c-variadic/same-program-multiple-abis-arm.rs
@@ -2,6 +2,7 @@
 //@ only-arm
 //@ ignore-thumb (this test uses arm assembly)
 //@ only-eabihf (the assembly below requires float hardware support)
+#![feature(c_variadic, c_variadic_naked_functions)]
 
 // Check that multiple c-variadic calling conventions can be used in the same program.
 //
@@ -9,14 +10,6 @@
 // argument list, so C programs that use multiple c-variadic calling conventions are unlikely
 // to come up. Here we validate that our codegen backends do in fact generate correct code.
 
-extern "C" {
-    fn variadic_c(_: f64, _: ...) -> f64;
-}
-
-extern "aapcs" {
-    fn variadic_aapcs(_: f64, _: ...) -> f64;
-}
-
 fn main() {
     unsafe {
         assert_eq!(variadic_c(1.0, 2.0, 3.0), 1.0 + 2.0 + 3.0);
@@ -51,10 +44,11 @@ fn main() {
 //
 // > This section applies only to non-variadic functions. For a variadic function the base standard
 // > is always used both for argument passing and result return.
-core::arch::global_asm!(
-    r#"
-{variadic_c}:
-{variadic_aapcs}:
+
+#[unsafe(naked)]
+unsafe extern "aapcs" fn variadic_aapcs(_: f64, _: ...) -> f64 {
+    core::arch::naked_asm!(
+        r#"
         sub     sp, sp, #12
         stmib   sp, {{r2, r3}}
         vmov    d0, r0, r1
@@ -71,6 +65,10 @@ fn main() {
         add     sp, sp, #12
         bx      lr
     "#,
-    variadic_c = sym variadic_c,
-    variadic_aapcs = sym variadic_aapcs,
-);
+    )
+}
+
+#[unsafe(naked)]
+unsafe extern "C" fn variadic_c(_: f64, _: ...) -> f64 {
+    core::arch::naked_asm!("b {}", sym variadic_aapcs)
+}
diff --git a/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs b/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
index aff8ab613c43..b54b63289f34 100644
--- a/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
+++ b/tests/ui/c-variadic/same-program-multiple-abis-x86_64.rs
@@ -1,5 +1,6 @@
 //@ run-pass
 //@ only-x86_64
+#![feature(c_variadic, c_variadic_naked_functions)]
 
 // Check that multiple c-variadic calling conventions can be used in the same program.
 //
@@ -7,14 +8,6 @@
 // argument list, so C programs that use multiple c-variadic calling conventions are unlikely
 // to come up. Here we validate that our codegen backends do in fact generate correct code.
 
-extern "sysv64" {
-    fn variadic_sysv64(_: u32, _: ...) -> u32;
-}
-
-extern "win64" {
-    fn variadic_win64(_: u32, _: ...) -> u32;
-}
-
 fn main() {
     unsafe {
         assert_eq!(variadic_win64(1, 2, 3), 1 + 2 + 3);
@@ -37,9 +30,11 @@ fn main() {
 //     a + b + c
 // }
 // ```
-core::arch::global_asm!(
-    r#"
-{variadic_sysv64}:
+
+#[unsafe(naked)]
+unsafe extern "sysv64" fn variadic_sysv64(_: u32, _: ...) -> u32 {
+    core::arch::naked_asm!(
+        r#"
         sub     rsp, 88
         test    al, al
         je      .LBB0_7
@@ -93,8 +88,14 @@ fn main() {
         add     eax, dword ptr [rcx]
         add     rsp, 88
         ret
+    "#,
+    )
+}
 
-{variadic_win64}:
+#[unsafe(naked)]
+unsafe extern "win64" fn variadic_win64(_: u32, _: ...) -> u32 {
+    core::arch::naked_asm!(
+        r#"
         push    rax
         mov     qword ptr [rsp + 40], r9
         mov     qword ptr [rsp + 24], rdx
@@ -106,6 +107,5 @@ fn main() {
         pop     rcx
         ret
     "#,
-    variadic_win64 = sym variadic_win64,
-    variadic_sysv64 = sym variadic_sysv64,
-);
+    )
+}