Extensions
Forms
4 (4 VEX)
Data
Intel XED v2026.08.23

VPMASKMOVD is AVX2’s integer twin of VMASKMOVPS: it loads or stores the doublewords of an XMM or YMM register only where the top bit of the matching element of a mask register is set. A load writes zero to the other elements, and a store leaves the memory under them as it was. The bits moved are the same as VMASKMOVPS’s; the two differ in the extension they need (AVX2 rather than AVX) and in whether the data is meant for integer or floating-point instructions next. VPMASKMOVQ does the same with quadwords.

A mask from an integer compare, VPCMPEQD or VPCMPGTD, has all 32 bits of each element set or clear and can be used directly. Whether masked-off elements can fault is where the manuals part: Intel’s says they never do, AMD’s leaves it to the implementation (see VMASKMOVPS, with the costs Intel’s optimization manual lists for both instructions in Section 15.9).

In compiled code

GCC 14 and Clang 23 at -O2 with -mavx2:

  • if (c[i]) a[i] = b[i] over int arrays: both compare c with zero by VPCMPEQD and invert the result (GCC with a second VPCMPEQD against zero, Clang with VPXOR of all ones), then load b and store a with VPMASKMOVD, so that elements the condition rules out are neither read nor written. GCC first skips blocks whose mask is all zero with VPTEST.
  • a[i] = c[i] ? b[i] : 0: both load b with VPMASKMOVD and store the result with a plain VMOVDQU. Clang relies on the zeros the masked load writes; GCC also clears those elements again with VPANDN.

A masked load or store also handles the last elements of a loop whose count is not a multiple of eight, with a mask from comparing a vector of element numbers 0 to 7 against the number left. Neither compiler does that at -O2: Clang finishes such a loop with scalar code, and GCC leaves a loop of unknown count scalar altogether.

With AVX-512 the same jobs go to VMOVDQU32 under a mask register. With -mavx512f, Clang builds the condition with VPTESTMD and GCC with VPCMPD, and both load and store with masked VMOVDQU32; GCC’s skip of empty blocks becomes KORTESTW.

In the optimization guide

What the optimization guide says about VPMASKMOVD, a line per claim. Each links to the claim in the guide, with its sources and where they differ.

Vectors

  • Masks and masked memory access: AVX’s VMASKMOV loads and stores can take assists of hundreds of cycles on Intel’s cores and are slow stores on Zen 3 and Zen 4.

Crestmont and Gracemont

  • Vectors and AVX2: Masked loads and stores run one every two cycles on 256 bits, slower when a masked-off element would fault.

Zen 2

  • Vectors and floating point: A masked load with VPMASKMOVD or vpmaskmovq is one or two macro-ops, but the masked store is microcoded, in AMD’s spreadsheet and in LLVM’s model. sources differ

Forms

Every encoding of VPMASKMOVD that Intel XED knows, one row per XED instruction form (iform). How to read the notation.
InstructionEncodingRequires
VPMASKMOVD xmm, xmm, m128 VPMASKMOVD_XMMdq_XMMdq_MEMdqVEX.128.66.0F38.W0 8C /rAVX2
VPMASKMOVD ymm, ymm, m256 VPMASKMOVD_YMMqq_YMMqq_MEMqqVEX.256.66.0F38.W0 8C /rAVX2
VPMASKMOVD m128, xmm, xmm VPMASKMOVD_MEMdq_XMMdq_XMMdqVEX.128.66.0F38.W0 8E /rAVX2
VPMASKMOVD m256, ymm, ymm VPMASKMOVD_MEMqq_YMMqq_YMMqqVEX.256.66.0F38.W0 8E /rAVX2

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.

A masked load: each doubleword moves where the sign bit of the doubleword in the same place of xmm2 is 1; elsewhere the result is 0.VPMASKMOVD xmm, xmm, m128 VPMASKMOVD ymm, ymm, m256
VPMASKMOVD with example sign bitsResult doublewords 3 to 0: a3, 0, a1, a0.1101xmm2sign bits0132m128aa0a1a30xmm1

Example sign bits of xmm2: 1011. Every doubleword works alike: 4 and 8 doublewords in the xmm and ymm forms.

Result doublewords 3 to 0: a3, 0, a1, a0.

A masked store: each doubleword moves where the sign bit of the doubleword in the same place of xmm2 is 1; elsewhere memory is left as it was.VPMASKMOVD m128, xmm, xmm VPMASKMOVD m256, ymm, ymm
VPMASKMOVD with example sign bitsResult doublewords 3 to 0: a3, unchanged, a1, a0.xmm3m128

Example sign bits of xmm2: 1011. Every doubleword works alike: 4 and 8 doublewords in the xmm and ymm forms.

Result doublewords 3 to 0: a3, unchanged, a1, a0.

Operation

What the forms do, in pseudocode that our tests run against results recorded on real processors. How to read.

VPMASKMOVD xmm, xmm, m128 VPMASKMOVD ymm, ymm, m256
for i in range(VL // 32):
    if ymm2.d[i] >> 31:
        ymm1.d[i] = mem.d[i]
    else:
        ymm1.d[i] = 0
# ymm1 is zeroed from bit VL up

Run on AMD Zen 5 (EPYC 9645): 2 cases.

VPMASKMOVD m128, xmm, xmm VPMASKMOVD m256, ymm, ymm
for i in range(VL // 32):
    if ymm2.d[i] >> 31:  # the sign bit of the element
        mem.d[i] = ymm3.d[i]
    # else: mem.d[i] is not written

Run on AMD Zen 5 (EPYC 9645): 2 cases.

Operands

What each form reads and writes, as Intel XED records it: the operands of its syntax, in order, and the implicit ones that the syntax does not name. How to read.
OperandKindAction
VPMASKMOVD xmm, xmm, m128 VPMASKMOVD ymm, ymm, m256
xmm, ymmexplicitwrite
xmm, ymmexplicitread
m128/256explicitread
VPMASKMOVD m128, xmm, xmm VPMASKMOVD m256, ymm, ymm
m128/256explicitwrite
xmm, ymmexplicitread
xmm, ymmexplicitread

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.

All forms
avx-type-6

Intrinsics

The C intrinsics of Clang 23.1.2 that compile to VPMASKMOVD, 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.

IntrinsicCompiles to
_mm_maskload_epi32 __m128i _mm_maskload_epi32(const int *__X, __m128i __M)

VPMASKMOVD xmm, xmm, m128 VEX.128 -mavx2

_mm_maskstore_epi32 void _mm_maskstore_epi32(int *__X, __m128i __M, __m128i __Y)

VPMASKMOVD m128, xmm, xmm VEX.128 -mavx2

_mm256_maskload_epi32 __m256i _mm256_maskload_epi32(const int *__X, __m256i __M)

VPMASKMOVD ymm, ymm, m256 VEX.256 -mavx2

_mm256_maskstore_epi32 void _mm256_maskstore_epi32(int *__X, __m256i __M, __m256i __Y)

VPMASKMOVD m256, ymm, ymm VEX.256 -mavx2

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.

CPUID requirements and processors of the XED ISA sets above. Alternatives are separated by “or”; processors follow XED’s chip model, whose AMD processors end with Zen 2, and the CPU data of this site for Zen 3 to Zen 6.

More AVX2 instructions

All 138 AVX2 instructions

Sources

  1. Intel XED v2026.08.23 (commit 0bcb6237345c): forms, encodings, operands, flags, exception classes, attributes, ISA sets, CPUID bits and chip model.
  2. The CPU data of x86-64.net: Zen 3 to Zen 6, from GCC’s -march feature sets and AMD’s Processor Programming References, which the page of each processor cites.
  3. 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.
  4. Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 2 (325383-093, September 2026): Volume 2C, page 5-571 (VPMASKMOV)
  5. Intel 64 and IA-32 Architectures Optimization Reference Manual, Volume 1 (248966-051, October 2026)
  6. AMD64 Architecture Programmer's Manual, Volume 4: 128-Bit and 256-Bit Media Instructions (26568, rev. 3.25, November 2021), Wayback Machine copy of AMD's PDF

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, part of the LLVM Project, licensed under the Apache License 2.0 with LLVM Exceptions. The text is our own.