PCMPEQB, PCMPEQW, PCMPEQD

比较相等的包装数据

stableVMJITAOTinstruction

编码

操作码	指令	Op/En	64 位	兼容/传统	说明
`NP 0F 74 /r1`	`PCMPEQB mm, mm/m64`	A	有效	有效	比较以mm/m64和mm为单位的包装字节,以表示平等.
`66 0F 74 /r`	`PCMPEQB xmm1, xmm2/m128`	A	有效	有效	在 xmm2/m128 和 xmm1 中比较已打包的字节,以表示平等。
`NP 0F 75 /r1`	`PCMPEQW mm, mm/m64`	A	有效	有效	用mm/m64和mm来比较打包的单词,以表示平等.
`66 0F 75 /r`	`PCMPEQW xmm1, xmm2/m128`	A	有效	有效	用 xmm2/m128 和 xmm1 来比较打包的单词,以便平等。
`NP 0F 76 /r1`	`PCMPEQD mm, mm/m64`	A	有效	有效	用mm/m64和mm来比较包装的双字,以表示平等.
`66 0F 76 /r`	`PCMPEQD xmm1, xmm2/m128`	A	有效	有效	在 xmm2/m128 和 xmm1 中比较打包的双字表示平等.
`VEX.128.66.0F.WIG 74 /r`	`VPCMPEQB xmm1, xmm2, xmm3/m128`	B	有效	有效	在 xmm3/m128 和 xmm2 中比较已打包的字节,以表示平等。
`VEX.128.66.0F.WIG 75 /r`	`VPCMPEQW xmm1, xmm2, xmm3/m128`	B	有效	有效	用 xmm3/m128 和 xmm2 来比较打包的单词,以便平等。
`VEX.128.66.0F.WIG 76 /r`	`VPCMPEQD xmm1, xmm2, xmm3/m128`	B	有效	有效	在 xmm3/m128 和 xmm2 中比较打包的双字表示平等.
`VEX.256.66.0F.WIG 74 /r`	`VPCMPEQB ymm1, ymm2, ymm3 /m256`	B	有效	有效	在 ymm3/m256 和 ymm2 中比较已打包的字节,以表示平等。
`VEX.256.66.0F.WIG 75 /r`	`VPCMPEQW ymm1, ymm2, ymm3 /m256`	B	有效	有效	用 ymm3/m256 和 ymm2 来比较打包的单词,以便平等。
`VEX.256.66.0F.WIG 76 /r`	`VPCMPEQD ymm1, ymm2, ymm3 /m256`	B	有效	有效	在 ymm3/m256 和 ymm2 中比较打包的双字表示平等.
`EVEX.128.66.0F.W0 76 /r`	`VPCMPEQD k1 {k2}, xmm2, xmm3/m128/m32bcst`	C	有效	有效	比较int32矢量xmm2 AVX512F)OR和int32矢量xmm3/m128/m32bcst,AVX10.1设置矢量掩码k1,以反映结果中每个元素的零/非零状态,在写掩码下.
`EVEX.256.66.0F.W0 76 /r`	`VPCMPEQD k1 {k2}, ymm2, ymm3/m256/m32bcst`	C	有效	有效	比较int32矢量ymm2 AVX512F)OR和int32矢量ymm3/m256/m32bcst,AVX10.1设置矢量掩码k1,以反映结果中每个元素的零/非零状态,在写掩码下.
`EVEX.512.66.0F.W0 76 /r`	`VPCMPEQD k1 {k2}, zmm2, zmm3/m512/m32bcst`	C	有效	有效	比较OR AVX10.1 zmm2和zmm3/m512/m32bcst中的int32向量,并根据写掩码 k2下的比较结果设定目的地k1.
`EVEX.128.66.0F.WIG 74 /r`	`VPCMPEQB k1 {k2}, xmm2, xmm3 /m128 Opcode/ Instruction`	D	有效	有效	在 xmm3/m128 和 AVX512BW 中比较 OR AVX10.1 xmm2 中包装的字节,并设置向量掩码 k1 以反映结果中每个元素的零/ 非零状态, 在写掩码下. Op/ En 64/32 bit CPUID 特性描述模式支持旗帜
`EVEX.256.66.0F.WIG 74 /r`	`VPCMPEQB k1 {k2}, ymm2, ymm3 /m256`	D	有效	有效	在 ymm3/m256 和 AVX512BW 中比较 OR AVX10.1 ymm2 中包装的字节,以表示平等,并设置矢量掩码 k1 以反映结果中每个元素的零/非零状态,在写掩码下.
`EVEX.512.66.0F.WIG 74 /r`	`VPCMPEQB k1 {k2}, zmm2, zmm3 /m512`	D	有效	有效	在 zmm3/m512 和 OR AVX10.1 zmm2 中比较包装的字节,以表示平等,并在写掩码下设置矢量掩码 k1 以反映结果中每个元素的零/非零状态.
`EVEX.128.66.0F.WIG 75 /r`	`VPCMPEQW k1 {k2}, xmm2, xmm3 /m128`	D	有效	有效	比较xmm3/m128和AVX512BW中的打包单词OR AVX10.1 xmm2平等,设置矢量掩码k1,以反映结果中每个元素的零/非零状态,在写掩码下.
`EVEX.256.66.0F.WIG 75 /r`	`VPCMPEQW k1 {k2}, ymm2, ymm3 /m256`	D	有效	有效	比较ymm3/m256和AVX512BW中的打包单词OR AVX10.1 ymm2平等,设置矢量掩码k1,以反映结果中每个元素的零/非零状态,在写掩码下.
`EVEX.512.66.0F.WIG 75 /r`	`VPCMPEQW k1 {k2}, zmm2, zmm3 /m512`	D	有效	有效	在zmm3/m512和OR AVX10.1 zmm2中比较打包的单词,以表示平等,并在写掩码下设置矢量掩码k1,以反映结果中每个元素的零/非零状态.

操作数编码

每个模式对应上表 Op/En 列的一个取值，说明各操作数按书写顺序分别编码在指令的哪个字段，以及指令对它是读、是写还是两者兼有。

A

modrm.reg lectura y escrituraModRM 字节的 reg 字段（第 5-3 位）
modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

B

modrm.reg escrituraModRM 字节的 reg 字段（第 5-3 位）
vex.vvvv lecturaVEX 前缀的 vvvv 字段（按位取反）
modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

C

modrm.reg escrituraModRM 字节的 reg 字段（第 5-3 位）
evex.vvvv lecturaEVEX 前缀的 vvvv 字段（按位取反）
modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

Tupla: Full

D

modrm.reg escrituraModRM 字节的 reg 字段（第 5-3 位）
evex.vvvv lecturaEVEX 前缀的 vvvv 字段（按位取反）
modrm.rm lecturaModRM 字节的 r/m 字段（第 2-0 位）；当 mod 字段要求时，还包括 SIB 字节和位移

Tupla: Full Mem

实测开销

正在从 arch-data 加载实测数据...

说明

执行 SIMD 在目标操作数(第一个操作数) 和源操作数(第二个操作数) 中,对打包字节,单词或双字的等值进行比较. 如果一对数据元素相等,则目标操作数中的相应数据元素设定为全部1s;否则,设定为全部0s.

(V)PCMPEQB指令比较目的地对应的字节和源操作数; (V)PCMPEQW指令比较目的地对应的单词和源操作数; (V)PCMPEQD指令比较目的地对应的双词和源操作数.

在64位模式中,没有用VEX/EVEX编码,使用REX前缀形式为REX.R允许此指令访问额外的注册(XMM8-XMM15).

遗产 SSE 指令 : 源操作数可以是MMX技术寄存器或64位内存位置. 目标操作数可以是MMX技术登记册.

128位遗产 SSE 版本 : 第二源操作数可以是XMM的寄存器,也可以是128位的内存位置. 第一个来源和目标操作数是XMM登记册. 相应的YMM目的地注册保持不变的位数(MAXVL-1:128).

VEX.128 编码版本 : 第二源操作数可以是XMM的寄存器,也可以是128位的内存位置. 第一个来源和目标操作数是XMM登记册. 对应的YMM注册被清零的位数(MAXVL-1:128).

VEX.256 编码版本 : 第一源操作数是一个YMM登记册. 第二源操作数是一个YMM的寄存器或256位的内存位置. 目标操作数是一个YMM登记册.

EVEX 编码为 VPCMPEQD : 第一源操作数(第二个操作数)是一个ZMM/YMM/XMM登记册. 第二源操作数可以是ZMM/YMM/XMM的寄存器,512/256/128位内存位置或512/256/128位向量从32位内存位置广播. 目标操作数(第一个操作数)是一个根据写掩码 k2更新的面具寄存器.

EVEX编码为VPCMPEQB/W: 第一源操作数(第二个操作数)是一个ZMM/YMM/XMM登记册. 第二源操作数可以是ZMM/YMM/XMM登记器,512/256/128位内存位置. 目标操作数(第一个操作数)是一个根据写掩码 k2更新的面具寄存器.

行动

PCMPEQB (With 64-bit Operands)
    IF DEST[7:0] = SRC[7:0]
          THEN DEST[7:0) := FFH;
          ELSE DEST[7:0] := 0; FI;
    (* Continue comparison of 2nd through 7th bytes in DEST and SRC *)
    IF DEST[63:56] = SRC[63:56]
          THEN DEST[63:56] := FFH;
          ELSE DEST[63:56] := 0; FI;

COMPARE_BYTES_EQUAL (SRC1, SRC2)
    IF SRC1[7:0] = SRC2[7:0]
    THEN DEST[7:0] := FFH;
    ELSE DEST[7:0] := 0; FI;

(* Continue comparison of 2nd through 15th bytes in SRC1 and SRC2 *)
    IF SRC1[127:120] = SRC2[127:120]
    THEN DEST[127:120] := FFH;
    ELSE DEST[127:120] := 0; FI;

COMPARE_WORDS_EQUAL (SRC1, SRC2)
    IF SRC1[15:0] = SRC2[15:0]
    THEN DEST[15:0] := FFFFH;
    ELSE DEST[15:0] := 0; FI;

(* Continue comparison of 2nd through 7th 16-bit words in SRC1 and SRC2 *)
    IF SRC1[127:112] = SRC2[127:112]
    THEN DEST[127:112] := FFFFH;
    ELSE DEST[127:112] := 0; FI;

COMPARE_DWORDS_EQUAL (SRC1, SRC2)
    IF SRC1[31:0] = SRC2[31:0]
    THEN DEST[31:0] := FFFFFFFFH;
    ELSE DEST[31:0] := 0; FI;

(* Continue comparison of 2nd through 3rd 32-bit dwords in SRC1 and SRC2 *)
    IF SRC1[127:96] = SRC2[127:96]
    THEN DEST[127:96] := FFFFFFFFH;
    ELSE DEST[127:96] := 0; FI;

PCMPEQB (With 128-bit Operands)
DEST[127:0] := COMPARE_BYTES_EQUAL(DEST[127:0],SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)


VPCMPEQB (VEX.128 Encoded Version)
DEST[127:0] := COMPARE_BYTES_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[MAXVL-1:128] := 0

VPCMPEQB (VEX.256 Encoded Version)
DEST[127:0] := COMPARE_BYTES_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[255:128] := COMPARE_BYTES_EQUAL(SRC1[255:128],SRC2[255:128])
DEST[MAXVL-1:256] := 0

VPCMPEQB (EVEX Encoded Versions)
(KL, VL) = (16, 128), (32, 256), (64, 512)

FOR j := 0 TO KL-1

i := j * 8

IF k2[j] OR *no writemask*

     THEN

            /* signed comparison */

            CMP := SRC1[i+7:i] == SRC2[i+7:i];

            IF CMP = TRUE

            THEN DEST[j] := 1;

            ELSE DEST[j] := 0; FI;

     ELSE DEST[j] := 0                      ; zeroing-masking onlyFI;

FI;

ENDFOR

DEST[MAX_KL-1:KL] := 0

PCMPEQW (With 64-bit Operands)
    IF DEST[15:0] = SRC[15:0]
          THEN DEST[15:0] := FFFFH;

          ELSE DEST[15:0] := 0; FI;

    (* Continue comparison of 2nd and 3rd words in DEST and SRC *)
    IF DEST[63:48] = SRC[63:48]

          THEN DEST[63:48] := FFFFH;

          ELSE DEST[63:48] := 0; FI;

PCMPEQW (With 128-bit Operands)
DEST[127:0] := COMPARE_WORDS_EQUAL(DEST[127:0],SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

VPCMPEQW (VEX.128 Encoded Version)
DEST[127:0] := COMPARE_WORDS_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[MAXVL-1:128] := 0

VPCMPEQW (VEX.256 Encoded Version)
DEST[127:0] := COMPARE_WORDS_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[255:128] := COMPARE_WORDS_EQUAL(SRC1[255:128],SRC2[255:128])
DEST[MAXVL-1:256] := 0


VPCMPEQW (EVEX Encoded Versions)

(KL, VL) = (8, 128), (16, 256), (32, 512)

FOR j := 0 TO KL-1

i := j * 16

IF k2[j] OR *no writemask*

     THEN

             /* signed comparison */

             CMP := SRC1[i+15:i] == SRC2[i+15:i];

             IF CMP = TRUE

                  THEN DEST[j] := 1;

                  ELSE DEST[j] := 0; FI;

     ELSE DEST[j] := 0                     ; zeroing-masking onlyFI;

FI;

ENDFOR

DEST[MAX_KL-1:KL] := 0

PCMPEQD (With 64-bit Operands)
    IF DEST[31:0] = SRC[31:0]

          THEN DEST[31:0] := FFFFFFFFH;

          ELSE DEST[31:0] := 0; FI;
    IF DEST[63:32] = SRC[63:32]

          THEN DEST[63:32] := FFFFFFFFH;

          ELSE DEST[63:32] := 0; FI;

PCMPEQD (With 128-bit Operands)
DEST[127:0] := COMPARE_DWORDS_EQUAL(DEST[127:0],SRC[127:0])
DEST[MAXVL-1:128] (Unmodified)

VPCMPEQD (VEX.128 Encoded Version)
DEST[127:0] := COMPARE_DWORDS_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[MAXVL-1:128] := 0

VPCMPEQD (VEX.256 Encoded Version)
DEST[127:0] := COMPARE_DWORDS_EQUAL(SRC1[127:0],SRC2[127:0])
DEST[255:128] := COMPARE_DWORDS_EQUAL(SRC1[255:128],SRC2[255:128])
DEST[MAXVL-1:256] := 0

VPCMPEQD (EVEX Encoded Versions)

(KL, VL) = (4, 128), (8, 256), (16, 512)

FOR j := 0 TO KL-1

i := j * 32

IF k2[j] OR *no writemask*

     THEN

             /* signed comparison */

             IF (EVEX.b = 1) AND (SRC2 *is memory*)

                  THEN CMP := SRC1[i+31:i] = SRC2[31:0];

                  ELSE CMP := SRC1[i+31:i] = SRC2[i+31:i];

             FI;

             IF CMP = TRUE

                  THEN DEST[j] := 1;

                  ELSE DEST[j] := 0; FI;

     ELSE DEST[j] := 0                     ; zeroing-masking only

FI;

ENDFOR


DEST[MAX_KL-1:KL] := 0

Intel C/C++ 内在编译器

VPCMPEQB __mmask64 _mm512_cmpeq_epi8_mask(__m512i a, __m512i b);
VPCMPEQB __mmask64 _mm512_mask_cmpeq_epi8_mask(__mmask64 k, __m512i a, __m512i b);
VPCMPEQB __mmask32 _mm256_cmpeq_epi8_mask(__m256i a, __m256i b);
VPCMPEQB __mmask32 _mm256_mask_cmpeq_epi8_mask(__mmask32 k, __m256i a, __m256i b);
VPCMPEQB __mmask16 _mm_cmpeq_epi8_mask(__m128i a, __m128i b);
VPCMPEQB __mmask16 _mm_mask_cmpeq_epi8_mask(__mmask16 k, __m128i a, __m128i b);
VPCMPEQW __mmask32 _mm512_cmpeq_epi16_mask(__m512i a, __m512i b);
VPCMPEQW __mmask32 _mm512_mask_cmpeq_epi16_mask(__mmask32 k, __m512i a, __m512i b);
VPCMPEQW __mmask16 _mm256_cmpeq_epi16_mask(__m256i a, __m256i b);
VPCMPEQW __mmask16 _mm256_mask_cmpeq_epi16_mask(__mmask16 k, __m256i a, __m256i b);
VPCMPEQW __mmask8 _mm_cmpeq_epi16_mask(__m128i a, __m128i b);
VPCMPEQW __mmask8 _mm_mask_cmpeq_epi16_mask(__mmask8 k, __m128i a, __m128i b);
VPCMPEQD __mmask16 _mm512_cmpeq_epi32_mask( __m512i a, __m512i b);
VPCMPEQD __mmask16 _mm512_mask_cmpeq_epi32_mask(__mmask16 k, __m512i a, __m512i b);
VPCMPEQD __mmask8 _mm256_cmpeq_epi32_mask(__m256i a, __m256i b);
VPCMPEQD __mmask8 _mm256_mask_cmpeq_epi32_mask(__mmask8 k, __m256i a, __m256i b);
VPCMPEQD __mmask8 _mm_cmpeq_epi32_mask(__m128i a, __m128i b);
VPCMPEQD __mmask8 _mm_mask_cmpeq_epi32_mask(__mmask8 k, __m128i a, __m128i b);
PCMPEQB __m64 _mm_cmpeq_pi8 (__m64 m1, __m64 m2) PCMPEQW __m64 _mm_cmpeq_pi16 (__m64 m1, __m64 m2) PCMPEQD __m64 _mm_cmpeq_pi32 (__m64 m1, __m64 m2) (V)PCMPEQB __m128i _mm_cmpeq_epi8 ( __m128i a, __m128i b) (V)PCMPEQW __m128i _mm_cmpeq_epi16 ( __m128i a, __m128i b) (V)PCMPEQD __m128i _mm_cmpeq_epi32 ( __m128i a, __m128i b) VPCMPEQB __m256i _mm256_cmpeq_epi8 ( __m256i a, __m256i b) VPCMPEQW __m256i _mm256_cmpeq_epi16 ( __m256i a, __m256i b) VPCMPEQD __m256i _mm256_cmpeq_epi32 ( __m256i a, __m256i b);

受影响的旗帜

None.

SIMD 浮点例外

None.

其他例外

Non-EVEX-encoded discription,参见表2-21"第4类例外条件".

EVEX-encoded VPCMPEQD,参见表2-51"Type E4类例外条件".

EVEX-encoded VPCMPEQB/W,参见表2-51中的例外类型E4.nb,"Type E4类例外条件".

PCMPEQB, PCMPEQW, PCMPEQD

编码

操作数编码

A

B

C

D

实测开销

说明#

行动#

Intel C/C++ 内在编译器#

受影响的旗帜#

SIMD 浮点 例外#

其他例外#

来源

说明

行动

Intel C/C++ 内在编译器

受影响的旗帜

SIMD 浮点例外

其他例外