From nobody Fri May 17 21:27:24 2024 X-Original-To: dev-commits-ports-all@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4Vh0RK2G6Xz5K72J; Fri, 17 May 2024 21:27:25 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R3" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4Vh0RK0hjtz4Mjc; Fri, 17 May 2024 21:27:25 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1715981245; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=M+GOrOX+0jF5f9vMBPHCXxvKu6h1nKMa3kV7OQ9t7fI=; b=i5QLPLN8/xSo7SZwtWetXJY16hWC5Beni+ju3Gbuoeapdb+dLPgOBEIw/DvxqOeLzW23CC KgIGVErWN+0zfLQxO8jGilfc9zjnKLx8DCT9quDASTmf09MWVsZnplFh4pVwoumEHI3lQM uvjet7VKRcF36H4uVVsXWRd3Uc/CRag2tyHM7iGnBUzR4yTJvmk34fRS3QodTfnULhxJDv oyue0uFgNCJBp34aqAI9K1tsuoHoqHH3rls4GzFZzEvcpZ6iQKnjhV1I8Msc6WRkoae3kB KqBmxcLUfEHUzL11DdZtj/FAK2HqswsWrzuyw8aZikdiBrAu3Tio6V1lSpOEJQ== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1715981245; a=rsa-sha256; cv=none; b=sD/U3omF4f2+2G/+fqNk1wAz/QqEyNQDX7bFbOqIqlaevl4e7VNGZgMLCD+CvlvKxG8GPo 9rPwY45PdtYUYFghO8iBMBo4m1xYb+bI0zX+m9g5lvU0vwY+Nu95+TlntwlzqEFkU1k4Mf 8zJIQqcoRY2gY8SMZnnjQOQGzhmrFQ5PCkSY+l5ceHRTE+8pq8YSZcfK0nwitKjkg/+UBx aKOI+Yq4jo3/af/DUdG2auTR7fVGOWQzPo8oER/WXzKQWx0CXNESGuYE39GxiJQiagxX7b lX42ueIjEYSzfvGShOSnz/bnRzhKyhpIo2t1pysbBbU1DbgmcVwFrPcUAYo5XQ== ARC-Authentication-Results: i=1; mx1.freebsd.org; none ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1715981245; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=M+GOrOX+0jF5f9vMBPHCXxvKu6h1nKMa3kV7OQ9t7fI=; b=rgU+aYYgMbPLqsP2QpaeM8C8k1zvTEkuuUzd33DSP3aZUKPibEutP0+ezNTRyCksUDLz+2 w0Zt7ESHrZwWgKZuAI0zaz9vP1vjlZ7cak3FkxzUOpU8nOtcN0lkE1TbiGbNKH0DCpOlBp bWn6hszCDYN58SqrPMT2vsW6X4556/sFJJtZ+31XOU5SP0rTa5hyKWAXJ9d0/H8Hm9ErzG XOHWtnxhNQxKHqPCzDR6U2vvOnzODNdQCXdOwJQ9pX5DZFLTZTutv2cKnfuuQ8/g/mHnTd 0ds2RKqwhqAeiVrvvy2YyhiNdlHnzpXWRbTMD2XX6fMgRCSiTwUMxp5sfljGxA== Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4Vh0RK0JhQzyYg; Fri, 17 May 2024 21:27:25 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.17.1/8.17.1) with ESMTP id 44HLROqs093025; Fri, 17 May 2024 21:27:24 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.17.1/8.17.1/Submit) id 44HLROWm093022; Fri, 17 May 2024 21:27:24 GMT (envelope-from git) Date: Fri, 17 May 2024 21:27:24 GMT Message-Id: <202405172127.44HLROWm093022@gitrepo.freebsd.org> To: ports-committers@FreeBSD.org, dev-commits-ports-all@FreeBSD.org, dev-commits-ports-main@FreeBSD.org From: Jan Beich Subject: git: 145551c111f7 - main - games/veloren-weekly: Add missing rust 1.78.0 fix after b352c01459d9 List-Id: Commit messages for all branches of the ports repository List-Archive: https://lists.freebsd.org/archives/dev-commits-ports-all List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-ports-all@freebsd.org Sender: owner-dev-commits-ports-all@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: jbeich X-Git-Repository: ports X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: 145551c111f728458eb486bfa04afb8c68841f52 Auto-Submitted: auto-generated The branch main has been updated by jbeich: URL: https://cgit.FreeBSD.org/ports/commit/?id=145551c111f728458eb486bfa04afb8c68841f52 commit 145551c111f728458eb486bfa04afb8c68841f52 Author: Mikael Urankar AuthorDate: 2024-05-16 11:45:54 +0000 Commit: Jan Beich CommitDate: 2024-05-17 21:25:26 +0000 games/veloren-weekly: Add missing rust 1.78.0 fix after b352c01459d9 PR: 278938 Reported by: pkg-fallout --- games/veloren-weekly/files/patch-rust-1.78.0-vek | 416 +++++++++++++++++++++++ 1 file changed, 416 insertions(+) diff --git a/games/veloren-weekly/files/patch-rust-1.78.0-vek b/games/veloren-weekly/files/patch-rust-1.78.0-vek new file mode 100644 index 000000000000..3aecbf1b819c --- /dev/null +++ b/games/veloren-weekly/files/patch-rust-1.78.0-vek @@ -0,0 +1,416 @@ +https://github.com/yoanlcq/vek/commit/23a8a82e01135973f681182590ed0c7927d5f594 + +error[E0044]: foreign items may not have type parameters + --> cargo-crates/vek-0.16.1/src/simd_llvm.rs:15:5 + | +15 | pub fn simd_eq(x: T, y: T) -> U; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ can't have type parameters + | + = help: replace the type parameters with concrete types like `u32` + +--- cargo-crates/vek-0.16.1/src/lib.rs.orig 1970-01-01 00:00:00 UTC ++++ cargo-crates/vek-0.16.1/src/lib.rs +@@ -37,7 +37,7 @@ + #![cfg_attr(all(nightly, feature = "clippy"), plugin(clippy))] + //#![cfg_attr(all(nightly, feature="repr_simd" ), feature(cfg_target_feature))] + #![cfg_attr(all(nightly, feature = "repr_simd"), feature(repr_simd, simd_ffi))] +-#![cfg_attr(all(nightly, feature = "platform_intrinsics"), feature(platform_intrinsics))] ++#![cfg_attr(all(nightly, feature = "platform_intrinsics"), feature(portable_simd, core_intrinsics))] + //#![cfg_attr(feature="repr_simd", allow(improper_ctypes)] + //#![cfg_attr(feature="repr_simd", feature(link_llvm_intrinsics)] + #![cfg_attr(all(nightly, test), feature(test))] +@@ -72,10 +72,6 @@ pub extern crate approx; + #[macro_use] + pub extern crate approx; + +-#[cfg(feature = "platform_intrinsics")] +-mod simd_llvm; +-// ^ Please do not make this module public; we don't want people to use it, because it could change as the SIMD infrastructure evolves. +- + pub mod ops; + pub use crate::ops::*; + pub mod vec; +@@ -92,5 +88,3 @@ pub use crate::geom::*; + pub use crate::bezier::*; + pub mod geom; + pub use crate::geom::*; +-pub mod simd_traits; +-pub use crate::simd_traits::*; +--- cargo-crates/vek-0.16.1/src/simd_llvm.rs 1970-01-01 00:00:00 UTC ++++ /dev/null +@@ -1,96 +0,0 @@ +-// !!! NOTE !!! +-// +-// Downloaded from https://raw.githubusercontent.com/rust-lang/stdarch/master/crates/core_arch/src/simd_llvm.rs +-// +-// The relevant RFC is https://github.com/rust-lang/rfcs/blob/master/text/1199-simd-infrastructure.md +-// +- +-//! LLVM's simd platform intrinsics +-//! +-//! TODO: should use `link_llvm_intrinsic` instead: issue #112 +- +-#[allow(dead_code)] +-extern "platform-intrinsic" { +- //pub fn simd_select_bitmask +- pub fn simd_eq(x: T, y: T) -> U; +- pub fn simd_ne(x: T, y: T) -> U; +- pub fn simd_lt(x: T, y: T) -> U; +- pub fn simd_le(x: T, y: T) -> U; +- pub fn simd_gt(x: T, y: T) -> U; +- pub fn simd_ge(x: T, y: T) -> U; +- +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle2(x: T, y: T, idx: [u32; 2]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle4(x: T, y: T, idx: [u32; 4]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle8(x: T, y: T, idx: [u32; 8]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle16(x: T, y: T, idx: [u32; 16]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle32(x: T, y: T, idx: [u32; 32]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle64(x: T, y: T, idx: [u32; 64]) -> U; +- // #[rustc_args_required_const(2)] +- // pub fn simd_shuffle128(x: T, y: T, idx: [u32; 128]) -> U; +- +- // #[rustc_const_unstable(feature = "const_simd_insert", issue = "none")] +- // pub fn simd_insert(x: T, idx: u32, val: U) -> T; +- // #[rustc_const_unstable(feature = "const_simd_extract", issue = "none")] +- // pub fn simd_extract(x: T, idx: u32) -> U; +- //pub fn simd_select +- pub fn simd_bitmask(x: T) -> U; +- +- pub fn simd_cast(x: T) -> U; +- +- pub fn simd_add(x: T, y: T) -> T; +- pub fn simd_sub(x: T, y: T) -> T; +- pub fn simd_mul(x: T, y: T) -> T; +- pub fn simd_div(x: T, y: T) -> T; +- pub fn simd_shl(x: T, y: T) -> T; +- pub fn simd_shr(x: T, y: T) -> T; +- pub fn simd_and(x: T, y: T) -> T; +- pub fn simd_or(x: T, y: T) -> T; +- pub fn simd_xor(x: T, y: T) -> T; +- +- pub fn simd_saturating_add(x: T, y: T) -> T; +- pub fn simd_saturating_sub(x: T, y: T) -> T; +- +- pub fn simd_gather(values: T, pointers: U, mask: V) -> T; +- pub fn simd_scatter(values: T, pointers: U, mask: V); +- +- pub fn simd_reduce_add_unordered(x: T) -> U; +- pub fn simd_reduce_mul_unordered(x: T) -> U; +- pub fn simd_reduce_add_ordered(x: T, acc: U) -> U; +- pub fn simd_reduce_mul_ordered(x: T, acc: U) -> U; +- pub fn simd_reduce_min(x: T) -> U; +- pub fn simd_reduce_max(x: T) -> U; +- pub fn simd_reduce_min_nanless(x: T) -> U; +- pub fn simd_reduce_max_nanless(x: T) -> U; +- pub fn simd_reduce_and(x: T) -> U; +- pub fn simd_reduce_or(x: T) -> U; +- pub fn simd_reduce_xor(x: T) -> U; +- pub fn simd_reduce_all(x: T) -> bool; +- pub fn simd_reduce_any(x: T) -> bool; +- +- pub fn simd_select(m: M, a: T, b: T) -> T; +- pub fn simd_select_bitmask(m: M, a: T, b: T) -> T; +- +- pub fn simd_fmin(a: T, b: T) -> T; +- pub fn simd_fmax(a: T, b: T) -> T; +- +- pub fn simd_fsqrt(a: T) -> T; +- pub fn simd_fsin(a: T) -> T; +- pub fn simd_fcos(a: T) -> T; +- pub fn simd_fabs(a: T) -> T; +- pub fn simd_floor(a: T) -> T; +- pub fn simd_ceil(a: T) -> T; +- pub fn simd_fexp(a: T) -> T; +- pub fn simd_fexp2(a: T) -> T; +- pub fn simd_flog10(a: T) -> T; +- pub fn simd_flog2(a: T) -> T; +- pub fn simd_flog(a: T) -> T; +- //pub fn simd_fpowi +- //pub fn simd_fpow +- pub fn simd_fma(a: T, b: T, c: T) -> T; +-} +--- cargo-crates/vek-0.16.1/src/simd_traits.rs 1970-01-01 00:00:00 UTC ++++ /dev/null +@@ -1,57 +0,0 @@ +-//! SIMD traits; they are useful when the features "repr_simd" and "platform_intrinsics" are enabled. +- +-use std::num::Wrapping; +-use num_traits; +- +-/// This trait should be implemented by scalar types, vectors of which are supported by SIMD intrinsics. +-/// For instance, i16 and f32 can implement this trait, as well as `#[repr(transparent)]` wrappers of these, but not hand-built numeric types. +-pub trait SimdElement { +- /// The corresponding mask type for this element type: this is usually the unsigned integer type with the same size. +- type SimdMaskType: SimdMask; +-} +- +-/// Implemented by unsigned integer types that can represent the result of SIMD comparison elements: semantically, these are booleans, but in their representation, zero is false and any other value is true. +-/// Typically, SIMD comparison of two vectors will yield a vector of mask elements, on which you can call `reduce_and()` or `reduce_or()`. +-pub trait SimdMask: num_traits::sign::Unsigned + num_traits::bounds::Bounded + num_traits::cast::FromPrimitive { +- /// Used for fallback code. +- #[inline] +- fn from_bool(b: bool) -> Self { +- Self::from_u8(b as _).unwrap() +- } +-} +- +-macro_rules! impl_simd_mask { +- ($T:ty) => { +- impl SimdMask for $T {} +- } +-} +- +-macro_rules! impl_simd_element { +- ($T:ty, $M:ty) => { +- impl SimdElement for $T { +- type SimdMaskType = $M; +- } +- } +-} +- +-impl_simd_mask!{u8} +-impl_simd_mask!{u16} +-impl_simd_mask!{u32} +-impl_simd_mask!{u64} +- +-impl SimdMask for Wrapping where Wrapping: num_traits::sign::Unsigned {} +- +-impl_simd_element!{i8, u8} +-impl_simd_element!{i16, u16} +-impl_simd_element!{i32, u32} +-impl_simd_element!{i64, u64} +-impl_simd_element!{u8, u8} +-impl_simd_element!{u16, u16} +-impl_simd_element!{u32, u32} +-impl_simd_element!{u64, u64} +-impl_simd_element!{f32, u32} +-impl_simd_element!{f64, u64} +- +-impl SimdElement for Wrapping { +- type SimdMaskType = T::SimdMaskType; // Don't propagate the Wrapping<>, masks are only intended for reduction to booleans; it doesn't make sense to perform arithmetic on them. +-} +\ No newline at end of file +--- cargo-crates/vek-0.16.1/src/vec.rs.orig 1970-01-01 00:00:00 UTC ++++ cargo-crates/vek-0.16.1/src/vec.rs +@@ -14,14 +14,12 @@ use std::num::Wrapping; + use std::ops::*; + use std::slice::{self, /*SliceIndex*/}; // NOTE: Will want to use SliceIndex once it's stabilized + use std::num::Wrapping; ++#[cfg(feature = "platform_intrinsics")] ++use std::simd::SimdElement; + use num_traits::{Zero, One, NumCast, AsPrimitive, Signed, real::Real}; + use approx::{AbsDiffEq, RelativeEq, UlpsEq}; + use crate::ops::*; +-use crate::simd_traits::{SimdElement, SimdMask}; + +-#[cfg(feature = "platform_intrinsics")] +-use crate::simd_llvm; +- + #[cfg(feature = "bytemuck")] + use crate::bytemuck; + +@@ -87,13 +85,24 @@ macro_rules! vec_impl_cmp { + }} + } + $(#[$attrs])* ++ #[cfg(feature = "platform_intrinsics")] + #[inline] +- pub fn $cmp_simd(self, rhs: Self) -> $Vec where T: $Bounds + SimdElement { ++ pub fn $cmp_simd(self, rhs: Self) -> $Vec ++ where ++ T: $Bounds + SimdElement, ++ ::Mask: num_traits::cast::FromPrimitive { + choose!{$c_or_simd { +- c => $Vec::new($(T::SimdMaskType::from_bool(self.$get $op rhs.$get)),+), +- simd_llvm => unsafe { simd_llvm::$simd_cmp(self, rhs) }, ++ c => $Vec::new($(::from_u8((self.$get $op rhs.$get) as _).unwrap()),+), ++ simd_llvm => unsafe { std::intrinsics::simd::$simd_cmp(self, rhs) }, + }} + } ++ ++ $(#[$attrs])* ++ #[cfg(not(feature = "platform_intrinsics"))] ++ #[inline] ++ pub fn $cmp_simd(self, rhs: Self) -> $Vec where T: $Bounds { ++ self.$cmp(&rhs) ++ } + } + } + +@@ -167,7 +176,7 @@ macro_rules! vec_impl_binop { + let rhs = rhs.into(); + choose!{$c_or_simd { + c => $Vec::new($(self.$get.$op(rhs.$get)),+), +- simd_llvm => unsafe { simd_llvm::$simd_op(self, rhs) }, ++ simd_llvm => unsafe { std::intrinsics::simd::$simd_op(self, rhs) }, + }} + } + } +@@ -273,7 +282,7 @@ macro_rules! vec_impl_reduce_bool_ops_for_primitive { + pub fn reduce_and(self) -> bool { + choose!{$c_or_simd { + c => reduce_binop!(&&, $(!self.$get.is_zero()),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_all(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_all(self) }, + }} + } + /// Returns the result of logical OR (`||`) on all elements of this vector. +@@ -288,7 +297,7 @@ macro_rules! vec_impl_reduce_bool_ops_for_primitive { + pub fn reduce_or(self) -> bool { + choose!{$c_or_simd { + c => reduce_binop!(||, $(!self.$get.is_zero()),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_any(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_any(self) }, + }} + } + } +@@ -668,7 +677,7 @@ macro_rules! vec_impl_vec { + pub fn as_(self) -> $Vec where T: AsPrimitive, D: 'static + Copy { + choose!{$c_or_simd { + c => $Vec::new($(self.$get.as_()),+), +- simd_llvm => unsafe { simd_llvm::simd_cast(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_cast(self) }, + }} + } + /// Returns a memberwise-converted copy of this vector, using `NumCast`. +@@ -712,7 +721,7 @@ macro_rules! vec_impl_vec { + let add = add.into(); + choose!{$c_or_simd { + c => $Vec::new($(self.$get.mul_add(mul.$get, add.$get)),+), +- simd_llvm => unsafe { simd_llvm::simd_fma(self, mul, add) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_fma(self, mul, add) }, + }} + } + +@@ -803,7 +812,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_min(self) -> T where T: Ord { + choose!{$c_or_simd { + c => reduce_fn!(cmp::min, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_min(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_min(self) }, + }} + } + /// Returns the element which has the highest value in this vector, using total +@@ -817,7 +826,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_max(self) -> T where T: Ord { + choose!{$c_or_simd { + c => reduce_fn!(cmp::max, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_max(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_max(self) }, + }} + } + +@@ -832,7 +841,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_partial_min(self) -> T where T: PartialOrd { + choose!{$c_or_simd { + c => reduce_fn!(partial_min, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_min(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_min(self) }, + }} + } + /// Returns the element which has the highest value in this vector, using partial +@@ -846,7 +855,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_partial_max(self) -> T where T: PartialOrd { + choose!{$c_or_simd { + c => reduce_fn!(partial_max, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_max(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_max(self) }, + }} + } + +@@ -862,7 +871,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_bitand(self) -> T where T: BitAnd { + choose!{$c_or_simd { + c => reduce_binop!(&, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_and(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_and(self) }, + }} + } + +@@ -877,7 +886,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_bitor(self) -> T where T: BitOr { + choose!{$c_or_simd { + c => reduce_binop!(|, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_or(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_or(self) }, + }} + } + +@@ -892,7 +901,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_bitxor(self) -> T where T: BitXor { + choose!{$c_or_simd { + c => reduce_binop!(^, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_xor(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_xor(self) }, + }} + } + +@@ -912,7 +921,7 @@ macro_rules! vec_impl_vec { + pub fn product(self) -> T where T: Mul { + choose!{$c_or_simd { + c => reduce_binop!(*, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_mul_unordered(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_mul_unordered(self) }, + }} + } + /// Returns the sum of each of this vector's elements. +@@ -925,7 +934,7 @@ macro_rules! vec_impl_vec { + pub fn sum(self) -> T where T: Add { + choose!{$c_or_simd { + c => reduce_binop!(+, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_add_unordered(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_add_unordered(self) }, + }} + } + /// Returns the average of this vector's elements. +@@ -980,7 +989,7 @@ macro_rules! vec_impl_vec { + pub fn sqrt(self) -> Self where T: Real { + choose!{$c_or_simd { + c => Self::new($(self.$get.sqrt()),+), +- simd_llvm => unsafe { simd_llvm::simd_fsqrt(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_fsqrt(self) }, + }} + } + +@@ -1022,7 +1031,7 @@ macro_rules! vec_impl_vec { + pub fn ceil(self) -> Self where T: Real { + choose!{$c_or_simd { + c => Self::new($(self.$get.ceil()),+), +- simd_llvm => unsafe { simd_llvm::simd_ceil(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_ceil(self) }, + }} + } + /// Returns a new vector which elements are rounded down to the nearest lower integer. +@@ -1036,7 +1045,7 @@ macro_rules! vec_impl_vec { + pub fn floor(self) -> Self where T: Real { + choose!{$c_or_simd { + c => Self::new($(self.$get.floor()),+), +- simd_llvm => unsafe { simd_llvm::simd_floor(self) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_floor(self) }, + }} + } + /// Returns a new vector which elements are rounded to the nearest integer. +@@ -1645,7 +1654,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_and(self) -> bool { + choose!{$c_or_simd { + c => reduce_binop!(&&, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_all(self.into_native_simd_integer_vector()) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_all(self.into_native_simd_integer_vector()) }, + }} + } + /// Returns the result of logical OR (`||`) on all elements of this vector. +@@ -1659,7 +1668,7 @@ macro_rules! vec_impl_vec { + pub fn reduce_or(self) -> bool { + choose!{$c_or_simd { + c => reduce_binop!(||, $(self.$get),+), +- simd_llvm => unsafe { simd_llvm::simd_reduce_any(self.into_native_simd_integer_vector()) }, ++ simd_llvm => unsafe { std::intrinsics::simd::simd_reduce_any(self.into_native_simd_integer_vector()) }, + }} + } + /// Reduces this vector using total inequality.