Instruction
VCMPPS
Compares packed singles with one of 32 predicates chosen by an immediate; the VEX form writes all-ones or zero elements, the EVEX form a mask register.
VCMPPS compares singles element by element under a predicate chosen by bits 4:0 of the immediate. The VEX forms write all ones or zero to each element of a vector, as SSE’s CMPPS does, which reads only bits 2:0; the EVEX forms write one bit per element to a mask register, cleared for the elements the write mask leaves out.
Thirty-two predicates
Bits 2:0 pick one of the eight relations of CMPPS’s table. The two bits AVX added change only what a NaN does:
- Bit 3 inverts the result for unordered inputs and keeps it for ordered ones. Equal (0) becomes equal or unordered (8h), not less (5) becomes greater or equal (0Dh), and unordered (3) and ordered (7) become always false (0Bh) and always true (0Fh).
- Bit 4 inverts whether a quiet NaN raises the invalid-operation exception: equal (0) is quiet and 10h signals, less (1) signals and 11h is quiet. A signaling NaN raises it under every predicate. COMISS explains which C operators should signal.
NaNs on Zen 5
vcmpps ymm12, ymm6, ymm6, 0x4, not equal and quiet, gave all ones for the one quiet NaN of YMM6 and left MXCSR alone.vcmpps k3, zmm1, zmm2, 0x10, equal and signaling, set MXCSR.IE for a quiet NaN.- With IE unmasked,
vcmpps ymm0, ymm13, ymm9, 0xb, always false, raised #XM for a signaling NaN. - A write mask masks the exceptions too:
vcmpps k7{k3}, zmm0, zmm31, 0x1bhad signaling NaNs only in elements K3 leaves out, and finished with IE unmasked and no flag set. With{sae},vcmpps k7, zmm7, zmm12, {sae}, 0xdset nothing for a signaling NaN with every exception unmasked.
In compiled code
In loops over floats, GCC 14 and Clang 23 at -O2 with
-march=x86-64-v3 pick the predicates that baseline code uses with
CMPPS, none above 7. For isless, which C defines as quiet, both
vectorized loops still used signaling predicates: Clang 1, and GCC 5
with the result inverted by VPANDN. With exceptions masked, as by
default, the only trace is MXCSR.IE.
AMD’s latency spreadsheet for Zen 5 gives the VEX forms 2 cycles, and the forms that write a mask register 3, 4 and 6 cycles for XMM, YMM and ZMM sources.
Forms
| Instruction | Encoding | Requires |
|---|---|---|
VCMPPS xmm, xmm, m128, imm8
VCMPPS_XMMdq_XMMdq_MEMdq_IMMb | VEX.128.NP.0F.WIG C2 /r ib | AVX |
VCMPPS xmm, xmm, xmm, imm8
VCMPPS_XMMdq_XMMdq_XMMdq_IMMb | VEX.128.NP.0F.WIG C2 /r ib | AVX |
VCMPPS ymm, ymm, m256, imm8
VCMPPS_YMMqq_YMMqq_MEMqq_IMMb | VEX.256.NP.0F.WIG C2 /r ib | AVX |
VCMPPS ymm, ymm, ymm, imm8
VCMPPS_YMMqq_YMMqq_YMMqq_IMMb | VEX.256.NP.0F.WIG C2 /r ib | AVX |
VCMPPS k {k}, zmm, zmm, imm8, {sae}
VCMPPS_MASKmskw_MASKmskw_ZMMf32_ZMMf32_IMM8_AVX512 | EVEX.512.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F |
VCMPPS k {k}, zmm, m512/m32bcst, imm8
VCMPPS_MASKmskw_MASKmskw_ZMMf32_MEMf32_IMM8_AVX512 | EVEX.512.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F |
VCMPPS k {k}, xmm, xmm, imm8
VCMPPS_MASKmskw_MASKmskw_XMMf32_XMMf32_IMM8_AVX512 | EVEX.128.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F + AVX512VL |
VCMPPS k {k}, xmm, m128/m32bcst, imm8
VCMPPS_MASKmskw_MASKmskw_XMMf32_MEMf32_IMM8_AVX512 | EVEX.128.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F + AVX512VL |
VCMPPS k {k}, ymm, ymm, imm8
VCMPPS_MASKmskw_MASKmskw_YMMf32_YMMf32_IMM8_AVX512 | EVEX.256.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F + AVX512VL |
VCMPPS k {k}, ymm, m256/m32bcst, imm8
VCMPPS_MASKmskw_MASKmskw_YMMf32_MEMf32_IMM8_AVX512 | EVEX.256.NP.0F.W0 C2 /r ib | AVX10.1 or AVX512F + AVX512VL |
Latency and throughput
| Model | xmm, xmm, m128, imm8 | xmm, xmm, xmm, imm8 | ymm, ymm, m256, imm8 | ymm, ymm, ymm, imm8 | k {k}, zmm, zmm, imm8, {sae} | k {k}, zmm, m512/m32bcst, imm8 | k {k}, xmm, xmm, imm8k {k}, ymm, ymm, imm8 | k {k}, xmm, m128/m32bcst, imm8 | k {k}, ymm, m256/m32bcst, imm8 |
|---|---|---|---|---|---|---|---|---|---|
| Sandy Bridge, Haswell | 9 / 1p1 | 3 / 1p1 | 10 / 1p1 | 3 / 1p1 | |||||
| Broadwell | 8 / 1p1 | 3 / 1p1 | 9 / 1p1 | 3 / 1p1 | |||||
| Skylake | 10 / 0.5p01 | 4 / 0.5p01 | 11 / 0.5p01 | 4 / 0.5p01 | |||||
| Skylake-SP, Ice Lake | 10 / 0.5p01 | 4 / 0.5p01 | 11 / 0.5p01 | 4 / 0.5p01 | 4 / 1p5 | 11 / 1p5 | 4 / 1p5 | 10 / 1p5 | 11 / 1p5 |
| Alder Lake | 11 / 0.5p01 | 4 / 0.5p01 | 12 / 0.5p01 | 4 / 0.5p01 | |||||
| Sapphire Rapids | 11 / 0.5p01 | 4 / 0.5p01 | 12 / 0.5p01 | 4 / 0.5p01 | 3 / 1p5 | 3 / 11p5 | 3 / 1p5 | 3 / 11p5 | 3 / 11p5 |
| Lunar Lake | 10 / 2V0 V1 | 4 / 2V0 V1 | 11 / 2.33V0 V1 | 4 / 2V0 V1 | |||||
| Piledriver | 7 / 1.5FPFMA FPU0 | 2 / 1FPFMA FPU0 | 7 / 1.5FPFMA FPU0 | 2 / 1FPFMA FPU0 | |||||
| Zen | 8 / 0.5FPU0 FPU1 | 1 / 0.5FPU0 FPU1 | 8 / 1FPU0 FPU1 | 1 / 1FPU0 FPU1 | |||||
| Zen 2 | 8 / 0.5FPU0 FPU1 | 1 / 0.5FPU0 FPU1 | 8 / 0.5FPU0 FPU1 | 1 / 0.5FPU0 FPU1 | |||||
| Zen 3 | 8 / 0.5FP0 FP1 | 1 / 0.5FP0 FP1 | 8 / 0.5FP0 FP1 | 1 / 0.5FP0 FP1 | |||||
| Zen 4 | 9 / 0.5FP0 FP1 | 2 / 1FP0 FP1 | 9 / 0.5FP0 FP1 | 2 / 0.5FP0 FP1 | 2 / 1FP0 FP1 | 9 / 1FP0 FP1 | 2 / 0.52FP0 FP1 | 9 / 0.5FP0 FP1 | 9 / 0.5FP0 FP1 |
| Jaguar | 7 / 1FPA FPU0 | 2 / 1FPA FPU0 | 7 / 2FPA FPU0 | 2 / 2FPA FPU0 | |||||
- Sapphire Rapids model: the marked memory forms get the register forms' latency, without the load; LLVM's Ice Lake and Skylake-SP models give them 10 or 11 (X86SchedSapphireRapids.td, line 2721).
- Zen 4 model, xmm form: AMD's spreadsheets give latency 3 for Zen 4 and Zen 5 (AMD 57647, row 947; AMD 58455, row 16).
Data flow
Where the elements of the sources go, element 0 on the right; results that depend on a control value are drawn for an example. How to read.
Every single works alike: 4 and 8 singles in the xmm and ymm forms.
Result single i comes from single i of xmm2 and xmm3. Result singles 3 to 0: r3, r2, r1, r0.
Where a bit of the write mask k2 is 0, the result bit is 0. Every single works alike: 4, 8 and 16 singles in the xmm, ymm and zmm forms. With m32bcst, one single from memory stands for every element of the last source.
Bit i of k1 comes from single i of xmm2 and xmm3. Result bits 3 to 0: r3, 0 (bit 2 of k2 is 0), r1, r0.
Operation
What the forms do, in pseudocode that our tests run against results recorded on real processors. How to read.
for i in range(VL // 32):
a = ymm2.f32[i]
b = src3.f32[i]
if fcmp(imm8, a, b):
ymm1.d[i] = -1
else:
ymm1.d[i] = 0
# imm8 & 31: 0 ==, 1 <, 2 <=, 3 unordered, 4 !=, 5 !<, 6 !<=, 7 ordered ...
# ymm1 is zeroed from bit VL upRun on AMD Zen 5 (EPYC 9645): 40 cases.
for i in range(VL // 32):
a = zmm2.f32[i]
b = src3.f32[i]
k1[i] = k2[i] and fcmp(imm8, a, b)
# imm8 & 31: 0 ==, 1 <, 2 <=, 3 unordered, 4 !=, 5 !<, 6 !<=, 7 ordered ...
# m32bcst: src3.f32[i] is the m32 for every i
# {sae}: no exception flags
# the other bits of k1 are clearedRun on AMD Zen 5 (EPYC 9645): 50 cases.
Operands
| Operand | Kind | Action |
|---|---|---|
VCMPPS xmm, xmm, xmm/m128, imm8 VCMPPS ymm, ymm, ymm/m256, imm8 | ||
xmm, ymm | explicit | write |
xmm, ymm | explicit | read |
xmm/m128, ymm/m256 | explicit | read |
imm8 | explicit | read |
VCMPPS k {k}, xmm, xmm/m128/m32bcst, imm8 VCMPPS k {k}, ymm, ymm/m256/m32bcst, imm8 VCMPPS k {k}, zmm, zmm/m512/m32bcst, imm8, {sae} | ||
k | explicit | write (masked) |
{k} | explicit | read (write mask) |
xmm, ymm, zmm | explicit | read |
xmm/m128/m32bcst, ymm/m256/m32bcst, zmm/m512/m32bcst | explicit | read |
imm8 | explicit | read |
Flags
None: XED records no flag that the forms test or change.
Exceptions
The exception class is XED's name for the set of exception conditions that a form follows. How to read.
- VEX forms
avx-type-2- EVEX forms
AVX512-E2
Attributes
What else XED records about the forms. How to read.
- All forms
- follows MXCSR
- EVEX forms
- write masking
- EVEX memory forms
- embedded broadcast (tuple Full); memory fault suppression
Intrinsics
The C intrinsics of Clang 23.1.2 that compile to VCMPPS, each with the form it compiles to and the Clang options it needs. The forms come from compiling every intrinsic and decoding the result with Intel XED; all intrinsics A–Z explains the method.
| Intrinsic | Compiles to |
|---|---|
_mm_cmp_ps_mask
__mmask8 _mm_cmp_ps_mask(__m128 a, __m128 b, const int p) |
|
_mm_cmpeq_ps
__m128 _mm_cmpeq_ps(__m128 __a, __m128 __b) |
|
_mm_cmpge_ps
__m128 _mm_cmpge_ps(__m128 __a, __m128 __b) |
|
_mm_cmpgt_ps
__m128 _mm_cmpgt_ps(__m128 __a, __m128 __b) |
|
_mm_cmple_ps
__m128 _mm_cmple_ps(__m128 __a, __m128 __b) |
|
_mm_cmplt_ps
__m128 _mm_cmplt_ps(__m128 __a, __m128 __b) |
|
_mm_cmpneq_ps
__m128 _mm_cmpneq_ps(__m128 __a, __m128 __b) |
|
_mm_cmpnge_ps
__m128 _mm_cmpnge_ps(__m128 __a, __m128 __b) |
|
_mm_cmpngt_ps
__m128 _mm_cmpngt_ps(__m128 __a, __m128 __b) |
|
_mm_cmpnle_ps
__m128 _mm_cmpnle_ps(__m128 __a, __m128 __b) |
|
_mm_cmpnlt_ps
__m128 _mm_cmpnlt_ps(__m128 __a, __m128 __b) |
|
_mm_cmpord_ps
__m128 _mm_cmpord_ps(__m128 __a, __m128 __b) |
|
_mm_cmpunord_ps
__m128 _mm_cmpunord_ps(__m128 __a, __m128 __b) |
|
_mm_mask_cmp_ps_mask
__mmask8 _mm_mask_cmp_ps_mask(__mmask8 m, __m128 a, __m128 b, const int p) |
|
_mm256_cmp_ps
__m256 _mm256_cmp_ps(__m256 a, __m256 b, const int c) |
|
_mm256_cmp_ps_mask
__mmask8 _mm256_cmp_ps_mask(__m256 a, __m256 b, const int p) |
|
_mm256_mask_cmp_ps_mask
__mmask8 _mm256_mask_cmp_ps_mask(__mmask8 m, __m256 a, __m256 b, const int p) |
|
_mm512_cmp_ps_mask
__mmask16 _mm512_cmp_ps_mask(__m512 A, __m512 B, const int P) |
|
_mm512_mask_cmp_ps_mask
__mmask16 _mm512_mask_cmp_ps_mask(__mmask16 U, __m512 A, __m512 B, const int P) |
|
_mm512_cmp_round_ps_mask
__mmask16 _mm512_cmp_round_ps_mask(__m512 A, __m512 B, const int P, const int R) |
|
_mm512_mask_cmp_round_ps_mask
__mmask16 _mm512_mask_cmp_round_ps_mask(__mmask16 U, __m512 A, __m512 B, const int P, const int R) |
|
_mm512_cmpeq_ps_mask
__mmask16 _mm512_cmpeq_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpeq_ps_mask
__mmask16 _mm512_mask_cmpeq_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmple_ps_mask
__mmask16 _mm512_cmple_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmple_ps_mask
__mmask16 _mm512_mask_cmple_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmplt_ps_mask
__mmask16 _mm512_cmplt_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmplt_ps_mask
__mmask16 _mm512_mask_cmplt_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmpneq_ps_mask
__mmask16 _mm512_cmpneq_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpneq_ps_mask
__mmask16 _mm512_mask_cmpneq_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmpnle_ps_mask
__mmask16 _mm512_cmpnle_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpnle_ps_mask
__mmask16 _mm512_mask_cmpnle_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmpnlt_ps_mask
__mmask16 _mm512_cmpnlt_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpnlt_ps_mask
__mmask16 _mm512_mask_cmpnlt_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmpord_ps_mask
__mmask16 _mm512_cmpord_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpord_ps_mask
__mmask16 _mm512_mask_cmpord_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
_mm512_cmpunord_ps_mask
__mmask16 _mm512_cmpunord_ps_mask(__m512 A, __m512 B) |
|
_mm512_mask_cmpunord_ps_mask
__mmask16 _mm512_mask_cmpunord_ps_mask(__mmask16 k, __m512 A, __m512 B) |
|
CPUID and processors
Each form belongs to an XED ISA set. A form can be used when the processor reports every CPUID bit of one of its ISA set's alternatives.
More AVX instructions
- VADDPD
- VADDPS
- VADDSD
- VADDSS
- VADDSUBPD
- VADDSUBPS
- VANDNPD
- VANDNPS
- VANDPD
- VANDPS
- VBLENDPD
- VBLENDPS
- VBLENDVPD
- VBLENDVPS
- VBROADCASTF128
- VBROADCASTSD
- VBROADCASTSS
- VCMPPD
- VCMPSD
- VCMPSS
- VCOMISD
- VCOMISS
- VCVTDQ2PD
- VCVTDQ2PS
- VCVTPD2DQ
- VCVTPD2PS
- VCVTPS2DQ
- VCVTPS2PD
- VCVTSD2SI
- VCVTSD2SS
- VCVTSI2SD
- VCVTSI2SS
- VCVTSS2SD
- VCVTSS2SI
- VCVTTPD2DQ
- VCVTTPS2DQ
- VCVTTSD2SI
- VCVTTSS2SI
- VDIVPD
- VDIVPS
More AVX10.1 instructions
- VANDNPD
- VANDNPS
- VANDPD
- VANDPS
- VBLENDMPD
- VBLENDMPS
- VBROADCASTF32X2
- VBROADCASTF32X4
- VBROADCASTF32X8
- VBROADCASTF64X2
- VBROADCASTF64X4
- VBROADCASTI32X2
- VBROADCASTI32X4
- VBROADCASTI32X8
- VBROADCASTI64X2
- VBROADCASTI64X4
- VBROADCASTSD
- VBROADCASTSS
- VCMPPD
- VCMPPH
- VCMPSD
- VCMPSH
- VCMPSS
- VCOMISD
- VCOMISH
- VCOMISS
- VCOMPRESSPD
- VCOMPRESSPS
- VCVTDQ2PD
- VCVTDQ2PH
- VCVTDQ2PS
- VCVTNE2PS2BF16
- VCVTNEPS2BF16
- VCVTPD2DQ
- VCVTPD2PH
- VCVTPD2PS
- VCVTPD2QQ
- VCVTPD2UDQ
- VCVTPD2UQQ
- VCVTPH2DQ
Sources
- Intel XED v2026.08.23 (commit
0bcb6237345c): forms, encodings, operands, flags, exception classes, attributes, ISA sets, CPUID bits and chip model. - The CPU data of x86-64.net: Zen 3 to Zen 6, from GCC’s
-marchfeature sets and AMD’s Processor Programming References, which the page of each processor cites. - Clang's x86 intrinsic headers, LLVM 23.1.2 (commit
85ac56026243): the intrinsics, their signatures and doc comments, and the Clang of that release, which compiled each of them. - LLVM 23.1.2's x86 scheduling models (commit
85ac56026243): the latency, reciprocal throughput and ports of each form, as llvm-mca reports them. - Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 2 (325383-093, September 2026): Volume 2A, page 3-175 (CMPPS)
- Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 1 (253665-093, September 2026)
- Intel Advanced Vector Extensions 10.2 Architecture Specification, revision 7.0 (361050-007, April 2026)
- Software Optimization Guide for the AMD Zen5 Microarchitecture (58455, rev. 1.00, August 2024), Wayback Machine copy of AMD's ZIP
The tables are derived from Intel XED, Copyright Intel Corporation, licensed under the Apache License 2.0; x86-64.net converted and reformatted them. The intrinsics and their signatures come from Clang and the timings from LLVM's scheduling models, both part of the LLVM Project, licensed under the Apache License 2.0 with LLVM Exceptions. The text is our own.