Merge branch 'moar-avx512f-cmp' into avx-512-cmp

Author: Daniel Smith

crates/core_arch/src/mod.rs

@@ -57,6 +57,13 @@ pub mod arch {
 
     /// Platform-specific intrinsics for the `wasm32` platform.
     ///
+
+    /// # Availability
+    ///
+    /// Note that intrinsics gated by `target_feature = "atomics"` or `target_feature = "simd128"`
+    /// are only available **when the standard library itself is compiled with the the respective
+    /// target feature**. This version of the standard library is not obtainable via `rustup`,
+    /// but rather will require the standard library to be compiled from source.
     /// See the [module documentation](../index.html) for more details.
     #[cfg(any(target_arch = "wasm32", dox))]
     #[doc(cfg(target_arch = "wasm32"))]

crates/core_arch/src/x86/avx2.rs

@@ -3743,9 +3743,9 @@ pub unsafe fn _mm256_xor_si256(a: __m256i, b: __m256i) -> __m256i {
 // This intrinsic has no corresponding instruction.
 #[rustc_args_required_const(1)]
 #[stable(feature = "simd_x86", since = "1.27.0")]
-pub unsafe fn _mm256_extract_epi8(a: __m256i, imm8: i32) -> i8 {
+pub unsafe fn _mm256_extract_epi8(a: __m256i, imm8: i32) -> i32 {
     let imm8 = (imm8 & 31) as u32;
-    simd_extract(a.as_i8x32(), imm8)
+    simd_extract::<_, u8>(a.as_u8x32(), imm8) as i32
 }
 
 /// Extracts a 16-bit integer from `a`, selected with `imm8`. Returns a 32-bit
@@ -3759,9 +3759,9 @@ pub unsafe fn _mm256_extract_epi8(a: __m256i, imm8: i32) -> i8 {
 // This intrinsic has no corresponding instruction.
 #[rustc_args_required_const(1)]
 #[stable(feature = "simd_x86", since = "1.27.0")]
-pub unsafe fn _mm256_extract_epi16(a: __m256i, imm8: i32) -> i16 {
+pub unsafe fn _mm256_extract_epi16(a: __m256i, imm8: i32) -> i32 {
     let imm8 = (imm8 & 15) as u32;
-    simd_extract(a.as_i16x16(), imm8)
+    simd_extract::<_, u16>(a.as_u16x16(), imm8) as i32
 }
 
 /// Extracts a 32-bit integer from `a`, selected with `imm8`.
@@ -6115,7 +6115,7 @@ mod tests {
         );
         let r1 = _mm256_extract_epi8(a, 0);
         let r2 = _mm256_extract_epi8(a, 35);
-        assert_eq!(r1, -1);
+        assert_eq!(r1, 0xFF);
         assert_eq!(r2, 3);
     }
 
@@ -6128,7 +6128,7 @@ mod tests {
         );
         let r1 = _mm256_extract_epi16(a, 0);
         let r2 = _mm256_extract_epi16(a, 19);
-        assert_eq!(r1, -1);
+        assert_eq!(r1, 0xFFFF);
         assert_eq!(r2, 3);
     }
 

crates/core_arch/src/x86/sse2.rs

@@ -1375,7 +1375,7 @@ pub unsafe fn _mm_packus_epi16(a: __m128i, b: __m128i) -> __m128i {
 #[rustc_args_required_const(1)]
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub unsafe fn _mm_extract_epi16(a: __m128i, imm8: i32) -> i32 {
-    simd_extract::<_, i16>(a.as_i16x8(), (imm8 & 7) as u32) as i32
+    simd_extract::<_, u16>(a.as_u16x8(), (imm8 & 7) as u32) as i32
 }
 
 /// Returns a new vector where the `imm8` element of `a` is replaced with `i`.
@@ -4132,7 +4132,7 @@ mod tests {
         let a = _mm_setr_epi16(-1, 1, 2, 3, 4, 5, 6, 7);
         let r1 = _mm_extract_epi16(a, 0);
         let r2 = _mm_extract_epi16(a, 11);
-        assert_eq!(r1, -1);
+        assert_eq!(r1, 0xFFFF);
         assert_eq!(r2, 3);
     }
 

crates/stdarch-verify/tests/x86-intel.rs

@@ -97,7 +97,8 @@ struct Data {
 
 #[derive(Deserialize)]
 struct Intrinsic {
-    rettype: String,
+    #[serde(rename = "return")]
+    return_: Return,
     name: String,
     #[serde(rename = "CPUID", default)]
     cpuid: Vec<String>,
@@ -113,6 +114,12 @@ struct Parameter {
     type_: String,
 }
 
+#[derive(Deserialize)]
+struct Return {
+    #[serde(rename = "type")]
+    type_: String,
+}
+
 #[derive(Deserialize, Debug)]
 struct Instruction {
     name: String,
@@ -506,12 +513,12 @@ fn matches(rust: &Function, intel: &Intrinsic) -> Result<(), String> {
 
     // Make sure we've got the right return type.
     if let Some(t) = rust.ret {
-        equate(t, &intel.rettype, rust.name, false)?;
-    } else if intel.rettype != "" && intel.rettype != "void" {
+        equate(t, &intel.return_.type_, rust.name, false)?;
+    } else if intel.return_.type_ != "" && intel.return_.type_ != "void" {
         bail!(
             "{} returns `{}` with intel, void in rust",
             rust.name,
-            intel.rettype
+            intel.return_.type_
         )
     }
 
@@ -660,7 +667,7 @@ fn equate(t: &Type, intel: &str, intrinsic: &str, is_const: bool) -> Result<(),
 
         (&Type::MMASK8, "__mmask8") => {}
         (&Type::MMASK16, "__mmask16") => {}
-        (&Type::MM_CMPINT_ENUM, "const _MM_CMPINT_ENUM") => require_const()?,
+        (&Type::MM_CMPINT_ENUM, "_MM_CMPINT_ENUM") => {}
 
         // This is a macro (?) in C which seems to mutate its arguments, but
         // that means that we're taking pointers to arguments in rust