added pclmul

Author: newpavlov

coresimd/src/runtime/x86.rs

@@ -32,6 +32,9 @@ macro_rules! __unstable_detect_feature {
     ("aes", $unstable_detect_feature:path) => {
         $unstable_detect_feature(
             $crate::__vendor_runtime::__Feature::aes{})  };
+    ("pclmul", $unstable_detect_feature:path) => {
+        $unstable_detect_feature(
+            $crate::__vendor_runtime::__Feature::pclmul{})  };
     ("tsc", $unstable_detect_feature:path) => {
         $unstable_detect_feature(
             $crate::__vendor_runtime::__Feature::tsc{})  };
@@ -176,6 +179,8 @@ macro_rules! __unstable_detect_feature {
 pub enum __Feature {
     /// AES (Advanced Encryption Standard New Instructions AES-NI)
     aes,
+    /// CLMUL (Carry-less Multiplication)
+    pclmul,
     /// TSC (Time Stamp Counter)
     tsc,
     /// MMX
@@ -351,6 +356,7 @@ pub fn detect_features() -> cache::Initializer {
         enable(proc_info_ecx, 20, __Feature::sse4_2);
         enable(proc_info_ecx, 23, __Feature::popcnt);
         enable(proc_info_ecx, 25, __Feature::aes);
+        enable(proc_info_ecx, 1, __Feature::pclmul);
         enable(proc_info_edx, 4, __Feature::tsc);
         enable(proc_info_edx, 23, __Feature::mmx);
         enable(proc_info_edx, 24, __Feature::fxsr);
@@ -463,6 +469,7 @@ mod tests {
     #[test]
     fn dump() {
         println!("aes: {:?}", cfg_feature_enabled!("aes"));
+        println!("pclmul: {:?}", cfg_feature_enabled!("pclmul"));
         println!("tsc: {:?}", cfg_feature_enabled!("tsc"));
         println!("sse: {:?}", cfg_feature_enabled!("sse"));
         println!("sse2: {:?}", cfg_feature_enabled!("sse2"));
@@ -504,6 +511,7 @@ mod tests {
     fn compare_with_cupid() {
         let information = cupid::master().unwrap();
         assert_eq!(cfg_feature_enabled!("aes"), information.aesni());
+        assert_eq!(cfg_feature_enabled!("pclmul"), information.pclmulqdq());
         assert_eq!(cfg_feature_enabled!("tsc"), information.tsc());
         assert_eq!(cfg_feature_enabled!("sse"), information.sse());
         assert_eq!(cfg_feature_enabled!("sse2"), information.sse2());

coresimd/src/x86/i686/clmul.rs

@@ -0,0 +1,58 @@
+use x86::__m128i;
+
+#[cfg(test)]
+use stdsimd_test::assert_instr;
+
+#[allow(improper_ctypes)]
+extern "C" {
+    #[link_name = "llvm.x86.pclmulqdq"]
+    fn pclmulqdq(a: __m128i, round_key: __m128i, imm8: u8) -> __m128i;
+}
+
+/// Perform a carry-less multiplication of two 64-bit polynomials over the
+/// finite field GF(2^k).
+///
+/// The immediate byte is used for determining which halves of `a` and `b`
+/// should be used. Immediate bits other than 0 and 4 are ignored.
+#[inline]
+#[target_feature(enable = "pclmul")]
+#[cfg_attr(test, assert_instr(pclmulqdq, imm8 = 0))]
+pub unsafe fn _mm_clmulepi64_si128(a: __m128i, b: __m128i, imm8: u8) -> __m128i {
+    macro_rules! call {
+        ($imm8:expr) => (pclmulqdq(a, b, $imm8))
+    }
+    constify_imm8!(imm8, call)
+}
+
+
+#[cfg(test)]
+mod tests {
+    // The constants in the tests below are just bit patterns. They should not
+    // be interpreted as integers; signedness does not make sense for them, but
+    // __m128i happens to be defined in terms of signed integers.
+    #![allow(overflowing_literals)]
+
+    use stdsimd_test::simd_test;
+
+    use x86::*;
+
+    #[simd_test = "pclmul"]
+    unsafe fn test_mm_clmulepi64_si128() {
+        // Constants taken from https://software.intel.com/sites/default/files/managed/72/cc/clmul-wp-rev-2.02-2014-04-20.pdf
+        let a = _mm_set_epi64x(0x7b5b546573745665, 0x63746f725d53475d);
+        let b = _mm_set_epi64x(0x4869285368617929, 0x5b477565726f6e5d);
+        let r00 = _mm_set_epi64x(0x1d4d84c85c3440c0, 0x929633d5d36f0451);
+        let r01 = _mm_set_epi64x(0x1bd17c8d556ab5a1, 0x7fa540ac2a281315);
+        let r10 = _mm_set_epi64x(0x1a2bf6db3a30862f, 0xbabf262df4b7d5c9);
+        let r11 = _mm_set_epi64x(0x1d1e1f2c592e7c45, 0xd66ee03e410fd4ed);
+
+        assert_eq_m128i(_mm_clmulepi64_si128(a, b, 0x00), r00);
+        assert_eq_m128i(_mm_clmulepi64_si128(a, b, 0x10), r01);
+        assert_eq_m128i(_mm_clmulepi64_si128(a, b, 0x01), r10);
+        assert_eq_m128i(_mm_clmulepi64_si128(a, b, 0x11), r11);
+
+        let a0 = _mm_set_epi64x(0x0000000000000000, 0x8000000000000000);
+        let r = _mm_set_epi64x(0x4000000000000000, 0x0000000000000000);
+        assert_eq_m128i(_mm_clmulepi64_si128(a0, a0, 0x00), r);
+    }
+}

coresimd/src/x86/i686/mod.rs

@@ -3,6 +3,9 @@
 mod aes;
 pub use self::aes::*;
 
+mod clmul;
+pub use self::clmul::*;
+
 mod mmx;
 pub use self::mmx::*;