Fix tests for removal of extern "unadjusted" outside of LLVM intrinsics

Author: bjorn3

tests/codegen-llvm/const-vector.rs

@@ -9,6 +9,7 @@
 #![crate_type = "lib"]
 #![feature(abi_unadjusted)]
 #![feature(const_trait_impl)]
+#![feature(link_llvm_intrinsics)]
 #![feature(repr_simd)]
 #![feature(rustc_attrs)]
 #![feature(simd_ffi)]
@@ -25,19 +26,22 @@ use minisimd::{PackedSimd as Simd, f32x2, i8x2};
 // that they are called with a const vector
 
 extern "unadjusted" {
-    fn test_i8x2(a: i8x2);
-    fn test_i8x2_two_args(a: i8x2, b: i8x2);
-    fn test_i8x2_mixed_args(a: i8x2, c: i32, b: i8x2);
-    fn test_i8x2_arr(a: i8x2);
-    fn test_f32x2(a: f32x2);
-    fn test_f32x2_arr(a: f32x2);
-    fn test_simd(a: Simd<i32, 4>);
-    fn test_simd_unaligned(a: Simd<i32, 3>);
+    #[link_name = "llvm.vector.reduce.add.v2i8"]
+    fn test_i8x2(a: i8x2) -> i8;
+    #[link_name = "llvm.vector.partial.reduce.add.v2i8.v2i8.v2i8"]
+    fn test_i8x2_two_args(a: i8x2, b: i8x2) -> i8x2;
+    #[link_name = "llvm.vector.insert.v2i8.v2i8"]
+    fn test_i8x2_mixed_args(a: i8x2, b: i8x2, c: usize) -> i8x2;
+    #[link_name = "llvm.vector.reduce.fadd.v2f32"]
+    fn test_f32x2(a: f32, b: f32x2) -> f32;
+    #[link_name = "llvm.vector.reduce.add.v3i32"]
+    fn test_simd_unaligned(a: Simd<i32, 3>) -> i32;
 }
 
 // Ensure the packed variant of the simd struct does not become a const vector
 // if the size is not a power of 2
-// CHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
+// FIXME this should use <3 x i32> instead of a struct containing an array
+// // COMMENTEDCHECK: %"minisimd::PackedSimd<i32, 3>" = type { [3 x i32] }
 
 #[cfg_attr(target_family = "wasm", target_feature(enable = "simd128"))]
 #[cfg_attr(target_arch = "arm", target_feature(enable = "neon"))]
@@ -46,35 +50,27 @@ extern "unadjusted" {
 #[cfg_attr(target_arch = "riscv64", target_feature(enable = "v"))]
 pub fn do_call() {
     unsafe {
-        // CHECK: call void @test_i8x2(<2 x i8> <i8 32, i8 64>
+        // CHECK: call i8 @llvm.vector.reduce.add.v2i8(<2 x i8> <i8 32, i8 64>
         test_i8x2(const { i8x2::from_array([32, 64]) });
 
-        // CHECK: call void @test_i8x2_two_args(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>
+        // CHECK: call <2 x i8> @llvm.vector.partial.reduce.add.v2i8.v2i8.v2i8(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>
         test_i8x2_two_args(
             const { i8x2::from_array([32, 64]) },
             const { i8x2::from_array([8, 16]) },
         );
 
-        // CHECK: call void @test_i8x2_mixed_args(<2 x i8> <i8 32, i8 64>, i32 43, <2 x i8> <i8 8, i8 16>
+        // CHECK: call <2 x i8> @llvm.vector.insert.v2i8.v2i8(<2 x i8> <i8 32, i8 64>, <2 x i8> <i8 8, i8 16>, i64 0
         test_i8x2_mixed_args(
             const { i8x2::from_array([32, 64]) },
-            43,
             const { i8x2::from_array([8, 16]) },
+            0,
         );
 
-        // CHECK: call void @test_i8x2_arr(<2 x i8> <i8 32, i8 64>
-        test_i8x2_arr(const { i8x2::from_array([32, 64]) });
+        // CHECK: call float @llvm.vector.reduce.fadd.v2f32(float 0.000000e+00, <2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
+        test_f32x2(0.0, const { f32x2::from_array([0.32, 0.64]) });
 
-        // CHECK: call void @test_f32x2(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2(const { f32x2::from_array([0.32, 0.64]) });
-
-        // CHECK: void @test_f32x2_arr(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
-        test_f32x2_arr(const { f32x2::from_array([0.32, 0.64]) });
-
-        // CHECK: call void @test_simd(<4 x i32> <i32 2, i32 4, i32 6, i32 8>
-        test_simd(const { Simd::<i32, 4>([2, 4, 6, 8]) });
-
-        // CHECK: call void @test_simd_unaligned(%"minisimd::PackedSimd<i32, 3>" %1
-        test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
+        // FIXME this should use <3 x i32> instead of a struct containing an array
+        // // COMMENTEDCHECK: call i32 @llvm.vector.reduce.add.v3i32(%"minisimd::PackedSimd<i32, 3>"
+        // test_simd_unaligned(const { Simd::<i32, 3>([2, 4, 6]) });
     }
 }

tests/codegen-llvm/simd/unpadded-simd.rs

@@ -1,19 +1,14 @@
 // Make sure that no 0-sized padding is inserted in structs and that
 // structs are represented as expected by Neon intrinsics in LLVM.
 // See #87254.
+//@ only-aarch64
 
 #![crate_type = "lib"]
-#![feature(repr_simd, abi_unadjusted)]
 
-#[derive(Copy, Clone)]
-#[repr(simd)]
-pub struct int16x4_t(pub [i16; 4]);
+use std::arch::aarch64::{int16x4x2_t, vld1_s16_x2};
 
-#[derive(Copy, Clone)]
-pub struct int16x4x2_t(pub int16x4_t, pub int16x4_t);
-
-// CHECK: %int16x4x2_t = type { <4 x i16>, <4 x i16> }
 #[no_mangle]
-extern "unadjusted" fn takes_int16x4x2_t(t: int16x4x2_t) -> int16x4x2_t {
-    t
+unsafe extern "C" fn returns_int16x4x2_t(a: *const i16) -> int16x4x2_t {
+    // CHECK: call { <4 x i16>, <4 x i16> } @llvm.aarch64.neon.ld1x2.v4i16.p0
+    vld1_s16_x2(a)
 }