Vpopcnt for x64

build.rs

@@ -191,7 +191,6 @@ fn x64_should_panic(testsuite: &str, testname: &str, strategy: &str) -> bool {
     }
 
     match (testsuite, testname) {
-        ("simd", "simd_i8x16_arith2") => return true, // Unsupported feature: proposed simd operator I8x16Popcnt
         ("simd", "simd_conversions") => return true, // unknown operator or unexpected token: tests/spec_testsuite/proposals/simd/simd_conversions.wast:724:6
         ("simd", "simd_i16x8_extadd_pairwise_i8x16") => return true,
         ("simd", "simd_i16x8_extmul_i8x16") => return true,

cranelift/codegen/meta/src/shared/instructions.rs

@@ -3314,6 +3314,9 @@ pub(crate) fn define(
         .operands_out(vec![a]),
     );
 
+    let x = &Operand::new("x", Int);
+    let a = &Operand::new("a", Int);
+
     ig.push(
         Inst::new(
             "popcnt",

cranelift/codegen/src/isa/x64/lower.rs

@@ -2708,6 +2708,8 @@ fn lower_insn_to_regs<C: LowerCtx<I = Inst>>(
         }
 
         Opcode::Popcnt => {
+            let ty_tmp = ty.unwrap();
+            if !ty_tmp.is_vector() {
                 let (ext_spec, ty) = match ctx.input_ty(insn, 0) {
                     types::I8 | types::I16 => (Some(ExtSpec::ZeroExtendTo32), types::I32),
                     a if a == types::I32 || a == types::I64 || a == types::I128 => (None, a),
@@ -3076,6 +3078,83 @@ fn lower_insn_to_regs<C: LowerCtx<I = Inst>>(
                         final_dst.regs()[1],
                     ));
                 }
+            } else {
+                // For SIMD 4.4 we use Mula's algroithm (https://arxiv.org/pdf/1611.07612.pdf)
+                //
+                //__m128i count_bytes ( __m128i v) {
+                //    __m128i lookup = _mm_setr_epi8(0 ,1 ,1 ,2 ,1 ,2 ,2 ,3 ,1 ,2 ,2 ,3 ,2 ,3 ,3 ,4) ;
+                //    __m128i low_mask = _mm_set1_epi8 (0 x0f ) ;
+                //    __m128i lo = _mm_and_si128 (v, low_mask ) ;
+                //    __m128i hi = _mm_and_si128 (_mm_srli_epi16 (v, 4) , low_mask ) ;
+                //    __m128i cnt1 = _mm_shuffle_epi8 (lookup , lo) ;
+                //    __m128i cnt2 = _mm_shuffle_epi8 (lookup , hi) ;
+                //    return _mm_add_epi8 (cnt1 , cnt2 ) ;
+                //}
+                //
+                // Details of the above algorithm can be found in the reference noted above, but the basics
+                // are to create a lookup table that pre populates the popcnt values for each number [0,15].
+                // The algorithm uses shifts to isolate 4 bit sections of the vector, pshufb as part of the
+                // lookup process, and adds together the results.
+
+                // Get input vector and destination
+                let ty = ty.unwrap();
+                let lhs = put_input_in_reg(ctx, inputs[0]);
+                let dst = get_output_reg(ctx, outputs[0]).only_reg().unwrap();
+
+                // __m128i lookup = _mm_setr_epi8(0 ,1 ,1 ,2 ,1 ,2 ,2 ,3 ,1 ,2 ,2 ,3 ,2 ,3 ,3 ,4);
+                static POPCOUNT_4BIT: [u8; 16] = [
+                    0x00, 0x01, 0x01, 0x02, 0x01, 0x02, 0x02, 0x03, 0x01, 0x02, 0x02, 0x03, 0x02,
+                    0x03, 0x03, 0x04,
+                ];
+                let lookup = ctx.use_constant(VCodeConstantData::WellKnown(&POPCOUNT_4BIT));
+
+                // Create a mask for lower 4bits of each subword.
+                static LOW_MASK: [u8; 16] = [0x0F; 16];
+                let low_mask_const = ctx.use_constant(VCodeConstantData::WellKnown(&LOW_MASK));
+                let low_mask = ctx.alloc_tmp(types::I8X16).only_reg().unwrap();
+                ctx.emit(Inst::xmm_load_const(low_mask_const, low_mask, ty));
+
+                // __m128i lo = _mm_and_si128 (v, low_mask );
+                let lo = ctx.alloc_tmp(types::I8X16).only_reg().unwrap();
+                ctx.emit(Inst::gen_move(lo, low_mask.to_reg(), types::I8X16));
+                ctx.emit(Inst::xmm_rm_r(SseOpcode::Pand, RegMem::reg(lhs), lo));
+
+                // __m128i hi = _mm_and_si128 (_mm_srli_epi16 (v, 4) , low_mask ) ;
+                ctx.emit(Inst::gen_move(dst, lhs, ty));
+                ctx.emit(Inst::xmm_rmi_reg(SseOpcode::Psrlw, RegMemImm::imm(4), dst));
+                let tmp = ctx.alloc_tmp(types::I8X16).only_reg().unwrap();
+                ctx.emit(Inst::gen_move(tmp, low_mask.to_reg(), types::I8X16));
+                ctx.emit(Inst::xmm_rm_r(
+                    SseOpcode::Pand,
+                    RegMem::reg(dst.to_reg()),
+                    tmp,
+                ));
+
+                // __m128i cnt1 = _mm_shuffle_epi8 (lookup , lo) ;
+                let tmp2 = ctx.alloc_tmp(types::I8X16).only_reg().unwrap();
+                ctx.emit(Inst::xmm_load_const(lookup, tmp2, ty));
+                ctx.emit(Inst::gen_move(dst, tmp2.to_reg(), types::I8X16));
+
+                ctx.emit(Inst::xmm_rm_r(
+                    SseOpcode::Pshufb,
+                    RegMem::reg(lo.to_reg()),
+                    dst,
+                ));
+
+                // __m128i cnt2 = _mm_shuffle_epi8 (lookup , hi) ;
+                ctx.emit(Inst::xmm_rm_r(
+                    SseOpcode::Pshufb,
+                    RegMem::reg(tmp.to_reg()),
+                    tmp2,
+                ));
+
+                // return _mm_add_epi8 (cnt1 , cnt2 ) ;
+                ctx.emit(Inst::xmm_rm_r(
+                    SseOpcode::Paddb,
+                    RegMem::reg(tmp2.to_reg()),
+                    dst,
+                ));
+            }
         }
 
         Opcode::Bitrev => {

cranelift/wasm/src/code_translator.rs

@@ -1859,6 +1859,10 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
             let (a, b) = pop2_with_bitcast(state, I16X8, builder);
             state.push1(builder.ins().widening_pairwise_dot_product_s(a, b));
         }
+        Operator::I8x16Popcnt => {
+            let arg = pop1_with_bitcast(state, type_of(op), builder);
+            state.push1(builder.ins().popcnt(arg));
+        }
         Operator::I64x2ExtendLowI32x4S
         | Operator::I64x2ExtendHighI32x4S
         | Operator::I64x2ExtendLowI32x4U
@@ -1884,8 +1888,7 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
         | Operator::F64x2PromoteLowF32x4
         | Operator::F64x2ConvertLowI32x4U
         | Operator::I32x4TruncSatF64x2SZero
-        | Operator::I32x4TruncSatF64x2UZero
+        | Operator::I32x4TruncSatF64x2UZero => {
-        | Operator::I8x16Popcnt => {
             return Err(wasm_unsupported!("proposed simd operator {:?}", op));
         }
         Operator::ReturnCall { .. } | Operator::ReturnCallIndirect { .. } => {
@@ -2590,7 +2593,8 @@ fn type_of(operator: &Operator) -> Type {
         | Operator::I8x16MaxS
         | Operator::I8x16MaxU
         | Operator::I8x16RoundingAverageU
-        | Operator::I8x16Bitmask => I8X16,
+        | Operator::I8x16Bitmask
+        | Operator::I8x16Popcnt => I8X16,
 
         Operator::I16x8Splat
         | Operator::V128Load16Splat { .. }