Merge branch 'master' into stdarch_arm_crc32

Author: ssukanmi

Diff for: .github/workflows/main.yml

@@ -15,7 +15,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust
-      run: rustup update nightly && rustup default nightly
+      run: rustup update nightly --no-self-update && rustup default nightly
     - run: ci/style.sh
 
   docs:
@@ -25,7 +25,7 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust
-      run: rustup update nightly && rustup default nightly
+      run: rustup update nightly --no-self-update && rustup default nightly
     - run: ci/dox.sh
       env:
         CI: 1
@@ -45,18 +45,22 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust
-      run: rustup update nightly && rustup default nightly
+      run: rustup update nightly --no-self-update && rustup default nightly
     - run: cargo test --manifest-path crates/stdarch-verify/Cargo.toml
 
   env_override:
     name: Env Override
     needs: [style]
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
     steps:
     - uses: actions/checkout@v4
     - name: Install Rust
-      run: rustup update nightly && rustup default nightly
+      run: rustup update nightly --no-self-update && rustup default nightly
     - run: RUST_STD_DETECT_UNSTABLE=avx cargo test --features=std_detect_env_override --manifest-path crates/std_detect/Cargo.toml env_override_no_avx
+      shell: bash
 
   test:
     needs: [style]

Diff for: crates/core_arch/src/powerpc/altivec.rs

@@ -408,6 +408,66 @@ impl_neg! { f32x4 : 0f32 }
 mod sealed {
     use super::*;
 
+    #[unstable(feature = "stdarch_powerpc", issue = "111145")]
+    pub trait VectorInsert {
+        type S;
+        unsafe fn vec_insert<const IDX: u32>(self, s: Self::S) -> Self;
+    }
+
+    const fn idx_in_vec<T, const IDX: u32>() -> u32 {
+        IDX & (16 / crate::mem::size_of::<T>() as u32)
+    }
+
+    macro_rules! impl_vec_insert {
+        ($ty:ident) => {
+            #[unstable(feature = "stdarch_powerpc", issue = "111145")]
+            impl VectorInsert for t_t_l!($ty) {
+                type S = $ty;
+                #[inline]
+                #[target_feature(enable = "altivec")]
+                unsafe fn vec_insert<const IDX: u32>(self, s: Self::S) -> Self {
+                    simd_insert(self, const { idx_in_vec::<Self::S, IDX>() }, s)
+                }
+            }
+        };
+    }
+
+    impl_vec_insert! { i8 }
+    impl_vec_insert! { u8 }
+    impl_vec_insert! { i16 }
+    impl_vec_insert! { u16 }
+    impl_vec_insert! { i32 }
+    impl_vec_insert! { u32 }
+    impl_vec_insert! { f32 }
+
+    #[unstable(feature = "stdarch_powerpc", issue = "111145")]
+    pub trait VectorExtract {
+        type S;
+        unsafe fn vec_extract<const IDX: u32>(self) -> Self::S;
+    }
+
+    macro_rules! impl_vec_extract {
+        ($ty:ident) => {
+            #[unstable(feature = "stdarch_powerpc", issue = "111145")]
+            impl VectorExtract for t_t_l!($ty) {
+                type S = $ty;
+                #[inline]
+                #[target_feature(enable = "altivec")]
+                unsafe fn vec_extract<const IDX: u32>(self) -> Self::S {
+                    simd_extract(self, const { idx_in_vec::<Self::S, IDX>() })
+                }
+            }
+        };
+    }
+
+    impl_vec_extract! { i8 }
+    impl_vec_extract! { u8 }
+    impl_vec_extract! { i16 }
+    impl_vec_extract! { u16 }
+    impl_vec_extract! { i32 }
+    impl_vec_extract! { u32 }
+    impl_vec_extract! { f32 }
+
     macro_rules! impl_vec_cmp {
         ([$Trait:ident $m:ident] ($b:ident, $h:ident, $w:ident)) => {
             impl_vec_cmp! { [$Trait $m] ($b, $b, $h, $h, $w, $w) }
@@ -3219,6 +3279,44 @@ mod sealed {
     }
 }
 
+/// Vector Insert
+///
+/// ## Purpose
+/// Returns a copy of vector b with element c replaced by the value of a.
+///
+/// ## Result value
+/// r contains a copy of vector b with element c replaced by the value of a.
+/// This function uses modular arithmetic on c to determine the element number.
+/// For example, if c is out of range, the compiler uses c modulo the number of
+/// elements in the vector to determine the element position.
+#[inline]
+#[target_feature(enable = "altivec")]
+#[unstable(feature = "stdarch_powerpc", issue = "111145")]
+pub unsafe fn vec_insert<T, const IDX: u32>(a: T, b: <T as sealed::VectorInsert>::S) -> T
+where
+    T: sealed::VectorInsert,
+{
+    a.vec_insert::<IDX>(b)
+}
+
+/// Vector Extract
+///
+/// ## Purpose
+/// Returns the value of the bth element of vector a.
+///
+/// ## Result value
+/// The value of each element of r is the element of a at position b modulo the number of
+/// elements of a.
+#[inline]
+#[target_feature(enable = "altivec")]
+#[unstable(feature = "stdarch_powerpc", issue = "111145")]
+pub unsafe fn vec_extract<T, const IDX: u32>(a: T) -> <T as sealed::VectorExtract>::S
+where
+    T: sealed::VectorExtract,
+{
+    a.vec_extract::<IDX>()
+}
+
 /// Vector Merge Low
 #[inline]
 #[target_feature(enable = "altivec")]

Diff for: crates/std_detect/src/detect/cache.rs

@@ -118,17 +118,42 @@ impl Cache {
 
 cfg_if::cfg_if! {
     if #[cfg(feature = "std_detect_env_override")] {
+        #[inline]
+        fn disable_features(disable: &[u8], value: &mut Initializer) {
+            if let Ok(disable) = core::str::from_utf8(disable) {
+                for v in disable.split(" ") {
+                    let _ = super::Feature::from_str(v).map(|v| value.unset(v as u32));
+                }
+            }
+        }
+
         #[inline]
         fn initialize(mut value: Initializer) -> Initializer {
-            let env = unsafe {
-                libc::getenv(b"RUST_STD_DETECT_UNSTABLE\0".as_ptr() as *const libc::c_char)
-            };
-            if !env.is_null() {
-                let len = unsafe { libc::strlen(env) };
-                let env = unsafe { core::slice::from_raw_parts(env as *const u8, len) };
-                if let Ok(disable) = core::str::from_utf8(env) {
-                    for v in disable.split(" ") {
-                        let _ = super::Feature::from_str(v).map(|v| value.unset(v as u32));
+            const RUST_STD_DETECT_UNSTABLE: &[u8] = b"RUST_STD_DETECT_UNSTABLE\0";
+            cfg_if::cfg_if! {
+                if #[cfg(windows)] {
+                    use alloc::vec;
+                    #[link(name = "kernel32")]
+                    extern "system" {
+                        fn GetEnvironmentVariableA(name: *const u8, buffer: *mut u8, size: u32) -> u32;
+                    }
+                    let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr(), core::ptr::null_mut(), 0) };
+                    if len > 0 {
+                        // +1 to include the null terminator.
+                        let mut env = vec![0; len as usize + 1];
+                        let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr(), env.as_mut_ptr(), len + 1) };
+                        if len > 0 {
+                            disable_features(&env[..len as usize], &mut value);
+                        }
+                    }
+                } else {
+                    let env = unsafe {
+                        libc::getenv(RUST_STD_DETECT_UNSTABLE.as_ptr() as *const libc::c_char)
+                    };
+                    if !env.is_null() {
+                        let len = unsafe { libc::strlen(env) };
+                        let env = unsafe { core::slice::from_raw_parts(env as *const u8, len) };
+                        disable_features(env, &mut value);
                     }
                 }
             }