Extensions
Forms
7 (4 VEX, 3 EVEX)
Data
Intel XED v2026.08.23

VMOVSS is the VEX and EVEX form of MOVSS, whose page covers the single-precision move and its uses in C. A load of four bytes now clears the register up to bit 511; the store is unchanged. The register form names two sources: the low single comes from the last, singles 1 to 3 from the first, and bits 128 and up are cleared, so vmovss xmm0, xmm2, xmm1 merges into a third register. As for MOVSD, opcodes 10h and 11h both encode it. There is no ymm form, and the load and store need vvvv at 1111b. The VEX form needs AVX; the EVEX form, AVX-512F or AVX10.1, adds a write mask on the single: a masked store with bit 0 clear writes nothing, and a masked load clears bits 32 and up whatever the mask says.

On Zen 5, vmovss xmm12, xmm6, xmm6 and its {store} twin, opcode 11h, both gave the low 128 bits of XMM6 and cleared bits 511:128 of ZMM12. vmovss xmm0{k4}{z}, dword ptr [mem], with bit 0 of K4 set, loaded the single and zeroed the rest of ZMM0, and vmovss dword ptr [mem]{k1}, xmm5, with bit 0 of K1 clear, left the four bytes as they were.

Merging and selecting

In our builds at -O2 with -march=x86-64-v3 and x86-64-v4, GCC 14 and Clang 23 load and store float values with VMOVSS. For _mm_move_ss(a, b) GCC emits vmovss xmm0, xmm0, xmm1 and Clang vblendps xmm0, xmm0, xmm1, 1. The write mask appears at -v4, in Clang: c ? a : b on floats becomes SETE, KMOVD and vmovss xmm0{k1}, xmm0, xmm1, and x < y ? a : b becomes VCMPLTSS into K1 and a masked VMOVSS. GCC keeps a branch for the first and blends with VBLENDVPS for the second, as Clang does at -v3.

AMD’s latency spreadsheet for Zen 5 gives VMOVSS one macro-op on pipes FP0 to FP3 with a latency of 1 cycle: four per cycle in its VEX row and its EVEX row for registers and stores, two in its EVEX load row.

Forms

Every encoding of VMOVSS that Intel XED knows, one row per XED instruction form (iform). How to read the notation.
InstructionEncodingRequires
VMOVSS xmm, m32 VMOVSS_XMMdq_MEMdVEX.LIG.F3.0F.WIG 10 /rAVX
VMOVSS m32, xmm VMOVSS_MEMd_XMMdVEX.LIG.F3.0F.WIG 11 /rAVX
VMOVSS xmm, xmm, xmm VMOVSS_XMMdq_XMMdq_XMMd_10VEX.LIG.F3.0F.WIG 10 /rAVX
VMOVSS xmm, xmm, xmm VMOVSS_XMMdq_XMMdq_XMMd_11VEX.LIG.F3.0F.WIG 11 /rAVX
VMOVSS xmm {k}{z}, m32 VMOVSS_XMMf32_MASKmskw_MEMf32_AVX512EVEX.LIG.F3.0F.W0 10 /rAVX10.1 or AVX512F
VMOVSS m32 {k}, xmm VMOVSS_MEMf32_MASKmskw_XMMf32_AVX512EVEX.LIG.F3.0F.W0 11 /rAVX10.1 or AVX512F
VMOVSS xmm {k}{z}, xmm, xmm VMOVSS_XMMf32_MASKmskw_XMMf32_XMMf32_AVX512EVEX.LIG.F3.0F.W0 10 /r
EVEX.LIG.F3.0F.W0 11 /r
AVX10.1 or AVX512F

Latency and throughput

What the scheduling models of LLVM 23.1.2 give for each form, not measurements: latency / reciprocal throughput in cycles, the ports under them. A row is a model, or models that agree; a dash, a form that its processors lack. Memory forms: latency from the address, ports without the load and store units. Which processors each model covers.
Modelxmm, m32m32, xmm
m32 {k}, xmm
xmm, xmm, xmm
xmm {k}{z}, xmm, xmm
xmm {k}{z}, m32no maskxmm {k}{z}, m32with a mask, zeroing
Sandy Bridge6 / 0.5p231 / 1p4 p231 / 1p5
Haswell, Broadwell, Skylake5 / 0.5p231 / 1p23471 / 1p5
Skylake-SP5 / 0.5p231 / 1p23471 / 1p57 / 1p57 / 1p5
Ice Lake5 / 0.5p231 / 0.5p47891 / 0.33p0157 / 1p57 / 1p5
Alder Lake7 / 0.33p2 p3 p1012 / 0.5p47891 / 0.33p015
Sapphire Rapids7 / 0.33p2 p3 p1012 / 0.5p47891 / 0.33p0157 / 0.33p2 p3 p108 / 0.33p015
Lunar Lake7 / 0.33p20 p21 p2212 / 0.5p10 p11 p25 p26 p271 / 0.25V0 V1 V2 V3
Piledriver5 / 1.5FPFMA FPU0 FPU12 / 1.5AGLU01 FPSTO FPU2 FPU3 Store2 / 1FPFMA FPU0 FPU1
Zen8 / 0.5AGU0 AGU11 / 0.5AGU0 AGU11 / 0.5FPU1 FPU2
Zen 28 / 0.33AGU0 AGU1 AGU21 / 0.33AGU0 AGU1 AGU21 / 0.5FPU1 FPU2
Zen 38 / 0.5FP45 LSU Load1 / 1FP45 FPSt LSU Store1 / 0.5FP1 FP2
Zen 48 / 0.5FP45 LSU Load1 / 1FP45 FPSt LSU Store1 / 0.5FP1 FP28 / 0.5FP45 LSU Load8 / 0.5FP45 LSU Load
Jaguar5 / 1FPA FPM FPU0 FPU12 / 1FPU11 / 0.5FPA FPM FPU0 FPU1

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.

The single in m32 goes to the low end of xmm1, and the rest of xmm1 is zeroed.VMOVSS xmm, m32 VMOVSS xmm {k}{z}, m32
VMOVSS: the low elementResult singles 3 to 0: 0, 0, 0, a0.0m32a1k1a0000xmm1

The write mask k1 applies to the low single only: with bit 0 clear, it keeps its old value, or is zeroed with {z}.

Result singles 3 to 0: 0, 0, 0, a0.

The low single of xmm2 goes to m32.VMOVSS m32, xmm VMOVSS m32 {k}, xmm
VMOVSS: the low elementm32 receives single 0 of xmm2: a0.123xmm2aa0m32

The write mask k1 applies to the low single only: with bit 0 clear, it keeps its old value.

m32 receives single 0 of xmm2: a0.

The low single of xmm3 goes to the low end of xmm1; the others come from xmm2.Register forms
VMOVSS: the low elementResult singles 3 to 0: b3, b2, b1, a0.0123bb1b2b30123xmm3a

The write mask k1 applies to the low single only: with bit 0 clear, it keeps its old value, or is zeroed with {z}.

Result singles 3 to 0: b3, b2, b1, a0.

Operation

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

VMOVSS xmm, m32 VMOVSS xmm {k}{z}, m32
if k1[0]:  # 1 without a write mask
    xmm1.d[0] = mem.d[0]
elif zeroing:
    xmm1.d[0] = 0
# else: xmm1.d[0] keeps its value
for i in range(1, 4):
    xmm1.d[i] = 0
# xmm1 is zeroed from bit 128 up

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

VMOVSS m32, xmm VMOVSS m32 {k}, xmm
if k1[0]:  # 1 without a write mask
    mem.d[0] = xmm2.d[0]
# else: mem.d[0] is not written

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

Register forms
if k1[0]:  # 1 without a write mask
    xmm1.d[0] = xmm3.d[0]
elif zeroing:
    xmm1.d[0] = 0
# else: xmm1.d[0] keeps its value
for i in range(1, 4):
    xmm1.d[i] = xmm2.d[i]
# xmm1 is zeroed from bit 128 up

Run on AMD Zen 5 (EPYC 9645): 3 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
VMOVSS xmm, m32
xmmexplicitwrite
m32explicitread
VMOVSS m32, xmm
m32explicitwrite
xmmexplicitread
VMOVSS xmm, xmm, xmm
xmmexplicitwrite
xmmexplicitread
xmmexplicitread
VMOVSS xmm {k}{z}, m32
xmmexplicitwrite (masked)
{k}explicitread (write mask)
m32explicitread
VMOVSS m32 {k}, xmm
m32explicitwrite (masked)
{k}explicitread (write mask)
xmmexplicitread
VMOVSS xmm {k}{z}, xmm, xmm
xmmexplicitwrite (masked)
{k}explicitread (write mask)
xmmexplicitread
xmmexplicitread

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-5
EVEX forms
AVX512-E5

Attributes

What else XED records about the forms. How to read.

EVEX forms
write masking
EVEX memory forms
memory fault suppression

Intrinsics

The C intrinsics of Clang 23.1.2 that compile to VMOVSS, 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_load_ss __m128 _mm_load_ss(const float *__p)

VMOVSS xmm, m32 VEX.LIG -mavxwith AVX enabled

_mm_store_ss void _mm_store_ss(float *__p, __m128 __a)

VMOVSS m32, xmm VEX.LIG -mavxwith AVX enabled

_mm_mask_load_ss __m128 _mm_mask_load_ss(__m128 __W, __mmask8 __U, const float *__A)

VMOVSS xmm {k}, m32 EVEX.LIG -mavx512f

_mm_mask_move_ss __m128 _mm_mask_move_ss(__m128 __W, __mmask8 __U, __m128 __A, __m128 __B)

VMOVSS xmm {k}, xmm, xmm EVEX.LIG -mavx512f

_mm_mask_store_ss void _mm_mask_store_ss(float *__W, __mmask8 __U, __m128 __A)

VMOVSS m32 {k}, xmm EVEX.LIG -mavx512f

_mm_maskz_load_ss __m128 _mm_maskz_load_ss(__mmask8 __U, const float *__A)

VMOVSS xmm {k}{z}, m32 EVEX.LIG -mavx512f

_mm_maskz_move_ss __m128 _mm_maskz_move_ss(__mmask8 __U, __m128 __A, __m128 __B)

VMOVSS xmm {k}{z}, xmm, xmm EVEX.LIG -mavx512f

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 AVX instructions

All 253 AVX instructions

More AVX10.1 instructions

All 686 AVX10.1 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. LLVM 23.1.2's x86 scheduling models (commit 85ac56026243): the latency, reciprocal throughput and ports of each form, as llvm-mca reports them.
  5. Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 2 (325383-093, September 2026): Volume 2B, page 4-117 (MOVSS)
  6. Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 1 (253665-093, September 2026)
  7. Intel Advanced Vector Extensions 10.2 Architecture Specification, revision 7.0 (361050-007, April 2026)
  8. AMD64 Architecture Programmer's Manual, Volume 4: 128-Bit, 256-Bit, and 512-Bit Media Instructions (26568, rev. 3.27, July 2026)
  9. 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.