implement the *_dyn intrinsics in LLVM

Author: folkertdev

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -1422,6 +1422,33 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
 
         return Ok(bx.shuffle_vector(args[0].immediate(), args[1].immediate(), indices));
     }
+    if name == sym::simd_shuffle_dyn {
+        // Make sure this is actually a SIMD vector.
+        let idx_ty = args[2].layout.ty;
+        let n: u64 = if idx_ty.is_simd()
+            && matches!(idx_ty.simd_size_and_type(bx.cx.tcx).1.kind(), ty::Uint(ty::UintTy::U32))
+        {
+            idx_ty.simd_size_and_type(bx.cx.tcx).0
+        } else {
+            return_error!(InvalidMonomorphization::SimdShuffle { span, name, ty: idx_ty })
+        };
+
+        let (out_len, out_ty) = require_simd!(ret_ty, SimdReturn);
+        require!(
+            out_len == n,
+            InvalidMonomorphization::ReturnLength { span, name, in_len: n, ret_ty, out_len }
+        );
+        require!(
+            in_elem == out_ty,
+            InvalidMonomorphization::ReturnElement { span, name, in_elem, in_ty, ret_ty, out_ty }
+        );
+
+        return Ok(bx.shuffle_vector(
+            args[0].immediate(),
+            args[1].immediate(),
+            args[2].immediate(),
+        ));
+    }
 
     if name == sym::simd_insert {
         require!(
@@ -1451,6 +1478,23 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
             bx.const_i32(idx as i32),
         ));
     }
+    if name == sym::simd_insert_dyn {
+        require!(
+            in_elem == arg_tys[2],
+            InvalidMonomorphization::InsertedType {
+                span,
+                name,
+                in_elem,
+                in_ty,
+                out_ty: arg_tys[2]
+            }
+        );
+        return Ok(bx.insert_element(
+            args[0].immediate(),
+            args[2].immediate(),
+            args[1].immediate(),
+        ));
+    }
     if name == sym::simd_extract {
         require!(
             ret_ty == in_elem,
@@ -1469,6 +1513,13 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         }
         return Ok(bx.extract_element(args[0].immediate(), bx.const_i32(idx as i32)));
     }
+    if name == sym::simd_extract_dyn {
+        require!(
+            ret_ty == in_elem,
+            InvalidMonomorphization::ReturnType { span, name, in_elem, in_ty, ret_ty }
+        );
+        return Ok(bx.extract_element(args[0].immediate(), args[1].immediate()));
+    }
 
     if name == sym::simd_select {
         let m_elem_ty = in_elem;

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -682,8 +682,12 @@ pub fn check_intrinsic_type(
             sym::simd_masked_load => (3, 0, vec![param(0), param(1), param(2)], param(2)),
             sym::simd_masked_store => (3, 0, vec![param(0), param(1), param(2)], tcx.types.unit),
             sym::simd_scatter => (3, 0, vec![param(0), param(1), param(2)], tcx.types.unit),
-            sym::simd_insert => (2, 0, vec![param(0), tcx.types.u32, param(1)], param(0)),
-            sym::simd_extract => (2, 0, vec![param(0), tcx.types.u32], param(1)),
+            sym::simd_insert | sym::simd_insert_dyn => {
+                (2, 0, vec![param(0), tcx.types.u32, param(1)], param(0))
+            }
+            sym::simd_extract | sym::simd_extract_dyn => {
+                (2, 0, vec![param(0), tcx.types.u32], param(1))
+            }
             sym::simd_cast
             | sym::simd_as
             | sym::simd_cast_ptr
@@ -704,7 +708,9 @@ pub fn check_intrinsic_type(
             | sym::simd_reduce_xor
             | sym::simd_reduce_min
             | sym::simd_reduce_max => (2, 0, vec![param(0)], param(1)),
-            sym::simd_shuffle => (3, 0, vec![param(0), param(0), param(1)], param(2)),
+            sym::simd_shuffle | sym::simd_shuffle_dyn => {
+                (3, 0, vec![param(0), param(0), param(1)], param(2))
+            }
             sym::simd_shuffle_generic => (2, 1, vec![param(0), param(0)], param(1)),
 
             other => {

library/core/src/intrinsics/simd.rs

@@ -28,6 +28,7 @@ pub unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T {
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
+#[cfg(not(bootstrap))]
 pub unsafe fn simd_insert_dyn<T, U>(_x: T, _idx: u32, _val: U) -> T {
     unreachable!()
 }
@@ -58,6 +59,7 @@ pub unsafe fn simd_extract<T, U>(_x: T, _idx: u32) -> U {
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
+#[cfg(not(bootstrap))]
 pub unsafe fn simd_extract_dyn<T, U>(_x: T, _idx: u32) -> U {
     unreachable!()
 }
@@ -388,6 +390,7 @@ pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V {
 #[rustc_intrinsic]
 #[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
+#[cfg(not(bootstrap))]
 pub unsafe fn simd_shuffle_dyn<T, U, V>(_x: T, _y: T, _idx: U) -> V {
     unreachable!()
 }