cg_llvm: sve_undef intrinsic

Intrinsic definitions previously used `transmute_unchecked(())` to
generate a poison value for `svundef*` intrinsics, but it's better to be
explicit and have a builtin intrinsic for this than do it via a cast.

Author: davidtwco

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -1,5 +1,6 @@
 use std::cmp::Ordering;
 use std::ffi::c_uint;
+use std::ops::Deref as _;
 use std::ptr;
 
 use rustc_abi::{
@@ -674,6 +675,12 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 )
             }
 
+            sym::sve_undef => {
+                let vec_ty = self.layout_of(fn_args.type_at(0));
+                assert!(vec_ty.deref().is_scalable_vector());
+                self.const_poison(self.backend_type(vec_ty))
+            }
+
             _ if name.as_str().starts_with("simd_") => {
                 // Unpack non-power-of-2 #[repr(packed, simd)] arguments.
                 // This gives them the expected layout of a regular #[repr(simd)] vector.

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -116,6 +116,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 | sym::assert_zero_valid
                 | sym::assert_mem_uninitialized_valid
                 | sym::assert_inhabited
+                | sym::sve_undef
                 | sym::ub_checks
                 | sym::contract_checks
                 | sym::atomic_fence

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -783,6 +783,7 @@ pub(crate) fn check_intrinsic_type(
         sym::sve_tuple_create4 => (2, 0, vec![param(0), param(0), param(0), param(0)], param(1)),
         sym::sve_tuple_get => (2, 1, vec![param(0)], param(1)),
         sym::sve_tuple_set => (2, 1, vec![param(0), param(1)], param(0)),
+        sym::sve_undef => (1, 0, vec![], param(0)),
 
         sym::atomic_cxchg | sym::atomic_cxchgweak => (
             1,

compiler/rustc_span/src/symbol.rs

@@ -1974,6 +1974,7 @@ symbols! {
         sve_tuple_create4,
         sve_tuple_get,
         sve_tuple_set,
+        sve_undef,
         sym,
         sync,
         synthetic,

library/core/src/intrinsics/scalable.rs

@@ -2,6 +2,15 @@
 //!
 //! In this module, a "vector" is any `#[rustc_scalable_vector]`-annotated type.
 
+/// Return an uninitialised vector.
+///
+/// `SVec` must be a scalable vector or scalable vector tuple.
+#[cfg(target_arch = "aarch64")]
+#[rustc_intrinsic]
+#[rustc_nounwind]
+#[target_feature(enable = "sve")]
+pub unsafe fn sve_undef<SVec>() -> SVec;
+
 /// Create a tuple of two vectors.
 ///
 /// `SVecTup` must be a scalable vector tuple (`#[rustc_scalable_vector]`) and `SVec` must be a

tests/codegen-llvm/scalable-vectors/sve-undef.rs

@@ -0,0 +1,80 @@
+//@ compile-flags: -Copt-level=0
+//@ only-aarch64
+#![allow(incomplete_features, internal_features, improper_ctypes, private_interfaces, unused)]
+#![crate_type = "bin"]
+#![feature(
+    core_intrinsics,
+    simd_ffi,
+    rustc_attrs,
+    target_feature_inline_always,
+    abi_unadjusted,
+    link_llvm_intrinsics
+)]
+
+use std::arch::aarch64::int8x16_t;
+use std::mem::transmute;
+
+// Test that the use of the `sve_undef` intrinsic produces the expected LLVM IR that will not
+// segfault at runtime.
+
+#[rustc_scalable_vector(16)]
+#[allow(non_camel_case_types)]
+struct svint8_t(i8);
+
+#[inline(always)]
+#[target_feature(enable = "sve")]
+pub unsafe fn svundef_s8() -> svint8_t {
+    std::intrinsics::scalable::sve_undef()
+}
+
+// CHECK: ; sve_undef::test_ffr
+// CHECK: %[[L1:[_.i0-9]+]] = alloca <vscale x 16 x i8>, align 16
+// CHECK: %{{.*}} = alloca [16 x i8], align 1
+// CHECK: store <vscale x 16 x i8> poison, ptr %[[L1]], align 16
+// CHECK: %[[L2:[_.i0-9]+]] = load <vscale x 16 x i8>, ptr %[[L1]], align 16
+// CHECK: %{{.*}} = call <vscale x 16 x i8> @llvm.vector.insert.nxv16i8.v16i8(<vscale x 16 x i8> %[[L2]], <16 x i8> %{{.*}}, i64 0)
+
+#[inline(always)]
+#[target_feature(enable = "sve")]
+pub fn svdupq_n_s8(
+    x0: i8,
+    x1: i8,
+    x2: i8,
+    x3: i8,
+    x4: i8,
+    x5: i8,
+    x6: i8,
+    x7: i8,
+    x8: i8,
+    x9: i8,
+    x10: i8,
+    x11: i8,
+    x12: i8,
+    x13: i8,
+    x14: i8,
+    x15: i8,
+) -> svint8_t {
+    unsafe extern "unadjusted" {
+        #[cfg_attr(
+            target_arch = "aarch64",
+            link_name = "llvm.experimental.vector.insert.nxv16i8.v16i8"
+        )]
+        fn _svdupq_n_s8(op0: svint8_t, op1: int8x16_t, idx: i64) -> svint8_t;
+    }
+    unsafe {
+        _svdupq_n_s8(
+            svundef_s8(),
+            transmute([x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]),
+            0,
+        )
+    }
+}
+
+#[target_feature(enable = "sve")]
+unsafe fn test_ffr() {
+    svdupq_n_s8(1i8, 0i8, 1i8, 0i8, 1i8, 0i8, 1i8, 0i8, 1i8, 0i8, 1i8, 0i8, 1i8, 0i8, 1i8, 0i8);
+}
+
+fn main() {
+    unsafe { test_ffr() }
+}