Remove `cupid` dependency and `env-override-no-avx` CI run

1 files changed, 2 insertions, 59 deletions

diff --git a/library/stdarch/crates/std_detect/src/detect/cache.rs b/library/stdarch/crates/std_detect/src/detect/cache.rs
index 83bcedea612..67a8b1ea091 100644
--- a/library/stdarch/crates/std_detect/src/detect/cache.rs
+++ b/library/stdarch/crates/std_detect/src/detect/cache.rs
@@ -121,65 +121,12 @@ 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 {
-            use core::ffi::CStr;
-            const RUST_STD_DETECT_UNSTABLE: &CStr = c"RUST_STD_DETECT_UNSTABLE";
-            cfg_if::cfg_if! {
-                if #[cfg(windows)] {
-                    use alloc::vec;
-                    #[link(name = "kernel32")]
-                    unsafe extern "system" {
-                        fn GetEnvironmentVariableA(name: *const u8, buffer: *mut u8, size: u32) -> u32;
-                    }
-                    let len = unsafe { GetEnvironmentVariableA(RUST_STD_DETECT_UNSTABLE.as_ptr().cast::<u8>(), 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().cast::<u8>(), 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())
-                    };
-                    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);
-                    }
-                }
-            }
-            do_initialize(value);
-            value
-        }
-    } else {
-        #[inline]
-        fn initialize(value: Initializer) -> Initializer {
-            do_initialize(value);
-            value
-        }
-    }
-}
-
 #[inline]
-fn do_initialize(value: Initializer) {
+fn initialize(value: Initializer) -> Initializer {
     CACHE[0].initialize((value.0) as usize & Cache::MASK);
     CACHE[1].initialize((value.0 >> Cache::CAPACITY) as usize & Cache::MASK);
     CACHE[2].initialize((value.0 >> (2 * Cache::CAPACITY)) as usize & Cache::MASK);
+    value
 }
 
 // We only have to detect features once, and it's fairly costly, so hint to LLVM
@@ -204,10 +151,6 @@ fn detect_and_initialize() -> Initializer {
 ///
 /// It uses the `Feature` variant to index into this variable as a bitset. If
 /// the bit is set, the feature is enabled, and otherwise it is disabled.
-///
-/// If the feature `std_detect_env_override` is enabled looks for the env
-/// variable `RUST_STD_DETECT_UNSTABLE` and uses its content to disable
-/// Features that would had been otherwise detected.
 #[inline]
 pub(crate) fn test(bit: u32) -> bool {
     let (relative_bit, idx) = if bit < Cache::CAPACITY {