feedback - exclude packed structs and add a test case for this

Author: Jamesbarford

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -636,7 +636,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
 
             mir::Operand::Constant(ref constant) => {
-                if constant.ty().is_simd() {
+                let constant_ty = constant.ty();
+                // Make sure that constant SIMD vectors are passed as immediates.
+                // This is needed for some intrinsics.
+                if constant_ty.is_simd() && !constant_ty.is_packed() {
                     let (llval, ty) = self.immediate_const_vector(bx, constant);
                     OperandRef { val: OperandValue::Immediate(llval), layout: bx.layout_of(ty) }
                 } else {

compiler/rustc_middle/src/ty/sty.rs

@@ -1077,6 +1077,14 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    #[inline]
+    pub fn is_packed(self) -> bool {
+        match self.kind() {
+            Adt(def, _) => def.repr().packed(),
+            _ => false,
+        }
+    }
+
     pub fn sequence_element_type(self, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
         match self.kind() {
             Array(ty, _) | Slice(ty) => *ty,

tests/codegen/const-vector.rs

@@ -1,13 +1,14 @@
 //@ compile-flags: -C no-prepopulate-passes -Copt-level=0
 
-// Ensuring the 2 different ways of creating const vectors works
+// This test checks that constants of SIMD type are passed as immediate vectors.
+// We ensure that both vector representations (struct with fields and struct wrapping array) work.
 #![crate_type = "lib"]
 #![feature(abi_unadjusted)]
-#![allow(non_camel_case_types)]
 #![feature(const_trait_impl)]
 #![feature(repr_simd)]
 #![feature(rustc_attrs)]
 #![feature(simd_ffi)]
+#![allow(non_camel_case_types)]
 
 // Setting up structs that can be used as const vectors
 #[repr(simd)]
@@ -26,6 +27,10 @@ pub struct f32x2(f32, f32);
 #[derive(Clone)]
 pub struct f32x2_arr([f32; 2]);
 
+#[repr(simd, packed)]
+#[derive(Copy, Clone)]
+pub struct Simd<T, const N: usize>([T; N]);
+
 // The following functions are required for the tests to ensure
 // that they are called with a const vector
 
@@ -59,6 +64,20 @@ extern "unadjusted" {
     fn test_f32x2_arr(a: f32x2_arr);
 }
 
+extern "unadjusted" {
+    #[no_mangle]
+    fn test_simd(a: Simd<i32, 4>);
+}
+
+extern "unadjusted" {
+    #[no_mangle]
+    fn test_simd_unaligned(a: Simd<i32, 3>);
+}
+
+// Ensure the packed variant of the simd struct does not become a const vector
+// if the size is not a power of 2
+// CHECK: %"Simd<i32, 3>" = type { [3 x i32] }
+
 pub fn do_call() {
     unsafe {
         // CHECK: call void @test_i8x2(<2 x i8> <i8 32, i8 64>
@@ -78,5 +97,11 @@ pub fn do_call() {
 
         // CHECK: void @test_f32x2_arr(<2 x float> <float 0x3FD47AE140000000, float 0x3FE47AE140000000>
         test_f32x2_arr(const { f32x2_arr([0.32, 0.64]) });
+
+        // CHECK: call void @test_simd(<4 x i32> %4
+        test_simd(Simd::<i32, 4>([2, 4, 6, 8]));
+
+        // CHECK: call void @test_simd_unaligned(%"Simd<i32, 3>" %8
+        test_simd_unaligned(Simd::<i32, 3>([2, 4, 6]));
     }
 }