CPUID
APX_F
CPUID.(EAX=07H,ECX=1):EDX[21]
Instructions
88 mnemonics
Processors
Nova Lake, Diamond Rapids

APX is the largest change to the general-purpose side of x86-64 since AMD’s original 64-bit extension added R8 to R15. It gives 64-bit code twice as many integer registers and removes two long-standing constraints of the x86 integer instructions: that the destination is also a source, and that almost every arithmetic instruction overwrites the flags.

Sixteen more registers

APX adds R16 to R31, the extended general-purpose registers (EGPRs). They exist only in 64-bit mode and behave like R8 to R15, but they are XSAVE-managed state: the operating system must set bit 19 of XCR0 before any APX instruction runs, and saves and restores them with XSAVE like vector registers. Their 128-byte save area reuses the space of the retired MPX state.

Two prefixes reach them:

  • REX2 is a two-byte prefix, D5 followed by a payload byte. It carries the REX bits plus a fifth bit for each register number, and works with the instructions of legacy opcode maps 0 and 1, which covers most integer code. Opcode rows whose instructions name no register, such as the short Jcc row 7x, are reserved under REX2; the single exception, A1, becomes JMPABS.
  • The extended EVEX prefix reuses reserved bits of EVEX for the high register bits. Integer instructions promoted from the legacy maps move to the new EVEX map 4; promoted VEX instructions such as ANDN or SHLX keep their maps. Existing EVEX vector instructions can use the new registers in their memory addresses.

Because REX2 is two bytes shorter than EVEX, it is the encoding of choice whenever an instruction only needs the extra registers.

New data destination (NDD)

With EVEX.ND set, many integer instructions take an extra destination register, so ADD r10, r11, r12 computes r11 + r12 without destroying either source. The promoted instructions with NDD forms include ADD, SUB, AND, OR, XOR, ADC, SBB, INC, DEC, NEG, NOT, the shifts and rotates, IMUL and CMOVcc. An NDD destination is always written in full: results narrower than 64 bits are zero-extended, where the legacy 8- and 16-bit forms keep the upper bits. A few instructions without an NDD form, such as the immediate forms of IMUL and SETcc, use the same bit to zero the upper bits instead (ZU).

Flag suppression (NF)

With EVEX.NF set, an instruction leaves the arithmetic flags as they were. The compiler can then schedule arithmetic between a compare and the branch or conditional move that consumes its flags. NF applies to the common arithmetic, logic, shift, multiply and divide instructions, to LZCNT, TZCNT and POPCNT, and to the promoted BMI instructions that write flags, such as ANDN and BZHI.

Conditional instructions

APX makes if-conversion cheaper for the compiler:

  • CCMPscc and CTESTscc compare or test only if a condition holds, and otherwise load the flags from a value in the instruction, so a == 1 && b == 2 needs one branch.
  • CFCMOVcc is a conditional move that neither performs nor faults on its memory access when the condition is false, which lets a compiler turn a guarded load or store into straight-line code. With a register destination it writes zero when the condition is false.
  • SETcc gains a zero-upper form that writes the whole register, removing the usual zeroing instruction before it.

The REX2 forms of CMOVcc keep the legacy behavior, memory faults included, so that their timing still follows Intel’s guidance for constant-time cryptographic code.

Saving registers

More registers mean more to save around calls. PUSH2 and POP2 move two registers in one instruction to a 16-byte-aligned stack slot. The push-pop acceleration (PPX) hint, available on PUSHP, POPP, PUSH2P and POP2P, marks a push and the pop that reads it back, so the processor can forward the value without a round trip through memory. The hint never changes what the program does.

Detection

APX_F is CPUID.(EAX=07H,ECX=1):EDX[21]. It also announces leaf 29H, whose EBX[0] (APX_NCI_NDD_NF) covers the new conditional instructions and the NDD and NF controls. Intel’s specification says every Intel processor with APX_F also sets that bit; XED keeps the forms that need it in a separate ISA set, APX_F_N3, that requires both. Software must also check that the operating system enabled XCR0 bit 19; without it every APX instruction and prefix raises #UD.

GCC 14 added part of APX (the extra registers, NDD, PPX and PUSH2/POP2) behind -mapxf. XED’s chip model places APX in Diamond Rapids and Nova Lake.

Instructions

Mnemonics with at least one form in APX. Each page lists all forms of the mnemonic, including those of other extensions.
MnemonicSummaryForms
AADDAtomically adds a register to a naturally aligned 32- or 64-bit value in memory without returning anything, as a weakly ordered remote atomic operation.2
AANDAtomically ANDs a register into a naturally aligned 32- or 64-bit value in memory without returning anything, as a weakly ordered remote atomic operation.2
ADCAdds two integers and the carry flag, the step that chains multi-word additions; APX adds a three-operand form.24
ADCXAdds two unsigned integers and the carry flag and changes only CF, so a carry chain can run next to an ADOX chain; APX adds a three-operand form.8
ADDAdds two integers and sets the arithmetic flags; APX adds three-operand forms and forms that leave the flags unchanged.36
ADOXAdds two unsigned integers and the overflow flag and changes only OF, so a carry chain can run next to an ADCX chain; APX adds a three-operand form.8
ANDComputes the bitwise AND of two operands; APX adds three-operand forms and forms that leave the flags unchanged.36
ANDNComputes the bitwise AND of the inverted first source with the second source into a separate destination; APX adds a form that leaves the flags unchanged.8
AORAtomically ORs a register into a naturally aligned 32- or 64-bit value in memory without returning anything, as a weakly ordered remote atomic operation.2
AXORAtomically XORs a register into a naturally aligned 32- or 64-bit value in memory without returning anything, as a weakly ordered remote atomic operation.2
BEXTRExtracts a bit field whose start and length come from a second register; APX adds a form that leaves the flags unchanged.8
BLSIIsolates the lowest set bit of the source, clearing all others; APX adds a form that leaves the flags unchanged.8
BLSMSKSets all bits up to and including the lowest set bit of the source and clears the rest; APX adds a form that leaves the flags unchanged.8
BLSRClears the lowest set bit of the source; APX adds a form that leaves the flags unchanged.8
BZHIClears the bits of the source from a given bit position upward; APX adds a form that leaves the flags unchanged.8
CCMPsccAPX conditional compare: if the flags meet a condition, compares two operands, otherwise sets OF, SF, ZF and CF to a value in the instruction.12
CFCMOVccAPX conditionally faulting move: on a false condition, memory is untouched and cannot fault; a register destination gets zero, or a source with NDD.5
CMOVccCopies the source to a register if a condition on the flags holds; APX adds a three-operand form that picks one of two sources.2
CMPccXADDAtomically compares memory with a register, adds a second register to memory if the condition holds, and returns the old value in the first.2
CRC32Accumulates a CRC-32C checksum (Castagnoli polynomial) over a 1-, 2-, 4- or 8-byte operand.4
CTESTsccAPX conditional test: if the flags meet a condition, tests two operands with AND, otherwise sets OF, SF, ZF and CF to a value in the instruction.8
DECSubtracts one from an operand without changing the carry flag; APX adds three-operand forms and forms that leave the flags unchanged.12
DIVDivides an unsigned double-width dividend in rDX:rAX (AX for bytes) by the operand into quotient and remainder; APX adds a form that keeps the flags.8
ENQCMDSends a 64-byte command, tagged with the PASID from the IA32_PASID MSR, to a device's enqueue register and sets ZF if the device did not accept it.1
ENQCMDSKernel version of ENQCMD that takes the PASID and privilege bit of the 64-byte command from its memory operand instead of the IA32_PASID MSR.1
IDIVDivides a signed double-width dividend in rDX:rAX (AX for bytes) by the operand into quotient and remainder; APX adds a form that keeps the flags.8
IMULMultiplies signed integers in one-, two- and three-operand forms; APX adds new-destination, flag-preserving and zero-upper immediate forms.26
INCAdds one to an operand without changing the carry flag; APX adds three-operand forms and forms that leave the flags unchanged.12
INVEPTInvalidates cached translations derived from a VMX guest's extended page tables, for one EPT context or all of them.1
INVPCIDInvalidates TLB entries and paging-structure caches for one address, one process-context identifier or all of them, as the type in a register selects.1
INVVPIDInvalidates cached translations tagged with a VMX virtual-processor identifier (VPID), for one address, one VPID or all of them.1
JMPABSAPX jump to a 64-bit absolute address given as an immediate, encoded with a REX2 prefix as an 11-byte instruction.1
KMOVBMoves an 8-bit mask between mask registers, general-purpose registers and memory; APX adds EVEX forms that reach the extended general-purpose registers.5
KMOVDMoves a 32-bit mask between mask registers, general-purpose registers and memory; APX adds EVEX forms that reach the extended general-purpose registers.5
KMOVQMoves a 64-bit mask between mask registers, general-purpose registers and memory; APX adds EVEX forms that reach the extended general-purpose registers.5
KMOVWMoves a 16-bit mask between mask registers, general-purpose registers and memory; APX adds EVEX forms that reach the extended general-purpose registers.5
LDTILECFGLoads the AMX tile configuration (palette, rows and bytes per row of each tile) from a 64-byte memory block and zeroes the tile registers.1
LZCNTCounts the leading zero bits of an operand; APX adds a form that leaves the flags unchanged.4
MOVBELoads or stores a 16-, 32- or 64-bit value with its byte order reversed; APX adds a register-to-register form.3
MOVDIR64BCopies 64 bytes from memory to a 64-byte-aligned destination as one direct store that is written atomically and bypasses the caches.1
MOVDIRIStores a 32- or 64-bit register to memory as a direct store that bypasses the caches.1
MOVRSLoads a register from memory with a hint that other cores are likely to read the same data before it is written.2
MULMultiplies unsigned integers, producing a double-width result in rDX:rAX (AX for bytes); APX adds a form that leaves the flags unchanged.8
MULXMultiplies rDX by an unsigned operand and writes the high and low halves of the product to two registers without touching the flags.4
NEGReplaces an operand with its two's complement; APX adds three-operand forms and forms that leave the flags unchanged.12
NOTInverts every bit of an operand without changing the flags; APX adds a three-operand form.8
ORComputes the bitwise OR of two operands; APX adds three-operand forms and forms that leave the flags unchanged.36
PDEPDeposits the low bits of the source at the bit positions selected by a mask, clearing the others.4
PEXTExtracts the bits of the source at the positions selected by a mask and packs them into the low bits of the destination.4
POP2APX instruction that pops two 64-bit registers from a 16-byte-aligned stack slot.1
POP2PPOP2 with APX's push-pop acceleration hint, marking it as the partner of a PUSH2P so the processor can forward the values without the memory round trip.1
POPCNTCounts the bits that are set in an operand; APX adds a form that leaves the flags unchanged.4
POPPPops a 64-bit register with APX's push-pop acceleration hint, marking it as the partner of an earlier PUSHP.1
PUSH2APX instruction that pushes two 64-bit registers to a 16-byte-aligned stack slot.1
PUSH2PPUSH2 with APX's push-pop acceleration hint, marking it as the partner of a POP2P so the processor can forward the values without the memory round trip.1
PUSHPPushes a 64-bit register with APX's push-pop acceleration hint, marking it as the partner of a later POPP.1
RCLRotates an operand left through the carry flag; APX adds a three-operand form.24
RCRRotates an operand right through the carry flag; APX adds a three-operand form.24
RDMSRReads a model-specific register into EDX:EAX, or with MSR_IMM into any 64-bit register from an MSR number given as an immediate; allowed only in ring 0.1
ROLRotates an operand left; APX adds three-operand forms and forms that leave the flags unchanged.36
RORRotates an operand right; APX adds three-operand forms and forms that leave the flags unchanged.36
RORXRotates the source right by an immediate count into a separate destination without touching the flags.4
SARShifts an operand right, copying the sign bit into the vacated bits; APX adds three-operand forms and forms that leave the flags unchanged.36
SARXShifts the source right arithmetically by a count in a register into a separate destination without touching the flags.4
SBBSubtracts an integer and the carry flag, the step that chains multi-word subtractions; APX adds a three-operand form.24
SETccWrites 1 or 0 to a byte depending on a condition on the flags; APX adds a form that also clears the rest of the destination register.4
SHLShifts an operand left, filling with zeros (SAL is the same instruction); APX adds three-operand forms and forms that leave the flags unchanged.36
SHLDShifts an operand left and fills the vacated bits from a second register; APX adds three-operand forms and forms that leave the flags unchanged.12
SHLXShifts the source left by a count in a register into a separate destination without touching the flags.4
SHRShifts an operand right, filling with zeros; APX adds three-operand forms and forms that leave the flags unchanged.36
SHRDShifts an operand right and fills the vacated bits from a second register; APX adds three-operand forms and forms that leave the flags unchanged.12
SHRXShifts the source right logically by a count in a register into a separate destination without touching the flags.4
STTILECFGStores the current AMX tile configuration to a 64-byte memory block.1
SUBSubtracts one integer from another and sets the arithmetic flags; APX adds three-operand forms and forms that leave the flags unchanged.36
TILELOADDLoads a tile from memory, row by row, with the row stride taken from the index register of its SIB-encoded address.1
TILELOADDRSLoads a tile from memory like TILELOADD, with a hint that other cores are likely to read the same data before it is written.1
TILELOADDRST1Loads a tile like TILELOADDRS, with the added hint that the data will be reused but need not stay in the nearest cache.1
TILELOADDT1Loads a tile like TILELOADD, with a hint that the data will be reused but need not stay in the nearest cache.1
TILESTOREDStores a tile to memory, row by row, with the row stride taken from the index register of its SIB-encoded address.1
TZCNTCounts the trailing zero bits of an operand; APX adds a form that leaves the flags unchanged.4
URDMSRReads a model-specific register from user mode, if the operating system allows that register in its user-MSR bitmap.2
UWRMSRWrites a model-specific register from user mode, if the operating system allows that register in its user-MSR bitmap.2
WRMSRNSWrites a model-specific register like WRMSR but without serializing the processor; the MSR_IMM form takes the MSR number as an immediate.1
WRSSDWrites a 32-bit value to the current privilege level's shadow stack, where the operating system allows such writes.1
WRSSQWrites a 64-bit value to the current privilege level's shadow stack, where the operating system allows such writes.1
WRUSSDLets ring-0 code write a 32-bit value to a user-mode shadow stack.1
WRUSSQLets ring-0 code write a 64-bit value to a user-mode shadow stack.1
XORComputes the bitwise exclusive OR of two operands; APX adds three-operand forms and forms that leave the flags unchanged.36

CPUID and processors

XED splits APX into 31 ISA sets. Software can use a form when the processor reports every CPUID bit of one alternative of the form's ISA set.

XED ISA sets of APX. Alternatives are separated by “or”; processors follow XED’s chip model, which covers AMD processors up to Zen 2.
ISA setCPUIDProcessors in XED
APX_F

APX_F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F

Nova Lake, Diamond Rapids
APX_F_ADX

APX_F + ADX
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[19] ADX

Nova Lake, Diamond Rapids
APX_F_ADX_N3

APX_F + APX_NCI_NDD_NF + ADX
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF
CPUID.(EAX=07H,ECX=0):EBX[19] ADX

Nova Lake, Diamond Rapids
APX_F_AMX

APX_F + AMX_TILE
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EDX[24] AMX_TILE

Diamond Rapids
APX_F_AMX_BASE

ACE v1
CPUID.(EAX=07H,ECX=1):ECX[11] ACE
CPUID.(EAX=1DH,ECX=2):EAX[7:0] ≥ 1 ACE version

or

APX_F + AMX_TILE
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EDX[24] AMX_TILE

Diamond Rapids
APX_F_AMX_MOVRS

APX_F + AMX_MOVRS
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=1EH,ECX=1):EAX[8] AMX_MOVRS

Diamond Rapids
APX_F_BMI1

APX_F + BMI1
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[3] BMI1

Nova Lake, Diamond Rapids
APX_F_BMI1_N3

APX_F + APX_NCI_NDD_NF + BMI1
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF
CPUID.(EAX=07H,ECX=0):EBX[3] BMI1

Nova Lake, Diamond Rapids
APX_F_BMI2

APX_F + BMI2
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[8] BMI2

Nova Lake, Diamond Rapids
APX_F_BMI2_N3

APX_F + APX_NCI_NDD_NF + BMI2
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF
CPUID.(EAX=07H,ECX=0):EBX[8] BMI2

Nova Lake, Diamond Rapids
APX_F_CET

APX_F + CET
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):ECX[7] CET

Nova Lake, Diamond Rapids
APX_F_CMPCCXADD

APX_F + CMPCCXADD
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EAX[7] CMPCCXADD

Nova Lake, Diamond Rapids
APX_F_ENQCMD

APX_F + ENQCMD
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):ECX[29] ENQCMD

Nova Lake, Diamond Rapids
APX_F_INVPCID

APX_F + INVPCID
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[10] INVPCID

Nova Lake, Diamond Rapids
APX_F_KOPB

AVX10.1 + APX_F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EDX[19] AVX10
CPUID.(EAX=24H,ECX=0):EBX[7:0] ≥ 1 AVX10 version

or

APX_F + AVX512DQ
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[17] AVX512DQ

Nova Lake, Diamond Rapids
APX_F_KOPD

AVX10.1 + APX_F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EDX[19] AVX10
CPUID.(EAX=24H,ECX=0):EBX[7:0] ≥ 1 AVX10 version

or

APX_F + AVX512BW
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[30] AVX512BW

Nova Lake, Diamond Rapids
APX_F_KOPQ

AVX10.1 + APX_F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EDX[19] AVX10
CPUID.(EAX=24H,ECX=0):EBX[7:0] ≥ 1 AVX10 version

or

APX_F + AVX512BW
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[30] AVX512BW

Nova Lake, Diamond Rapids
APX_F_KOPW

AVX10.1 + APX_F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EDX[19] AVX10
CPUID.(EAX=24H,ECX=0):EBX[7:0] ≥ 1 AVX10 version

or

APX_F + AVX512F
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):EBX[16] AVX512F

Nova Lake, Diamond Rapids
APX_F_LZCNT

APX_F + LZCNT
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.80000001H:ECX[5] LZCNT

Nova Lake, Diamond Rapids
APX_F_LZCNT_N3

APX_F + APX_NCI_NDD_NF + LZCNT
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF
CPUID.80000001H:ECX[5] LZCNT

Nova Lake, Diamond Rapids
APX_F_MOVBE

APX_F + MOVBE
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.01H:ECX[22] MOVBE

Nova Lake, Diamond Rapids
APX_F_MOVDIR64B

APX_F + MOVDIR64B
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):ECX[28] MOVDIR64B

Nova Lake, Diamond Rapids
APX_F_MOVDIRI

APX_F + MOVDIRI
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=0):ECX[27] MOVDIRI

Nova Lake, Diamond Rapids
APX_F_MOVRS

APX_F + MOVRS
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EAX[31] MOVRS

Nova Lake, Diamond Rapids
APX_F_MSR_IMM

APX_F + MSR_IMM
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):ECX[5] MSR_IMM

None yet: XED lists these instructions only under its placeholder for future processors.
APX_F_N3

APX_F + APX_NCI_NDD_NF
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF

Nova Lake, Diamond Rapids
APX_F_POPCNT

APX_F + POPCNT
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.01H:ECX[23] POPCNT

Nova Lake, Diamond Rapids
APX_F_POPCNT_N3

APX_F + APX_NCI_NDD_NF + POPCNT
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=29H,ECX=0):EBX[0] APX_NCI_NDD_NF
CPUID.01H:ECX[23] POPCNT

Nova Lake, Diamond Rapids
APX_F_RAO_INT

APX_F + RAO_INT
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EAX[3] RAO_INT

None yet: XED lists these instructions only under its placeholder for future processors.
APX_F_USER_MSR

APX_F + USER_MSR
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.(EAX=07H,ECX=1):EDX[15] USER_MSR

None yet: XED lists these instructions only under its placeholder for future processors.
APX_F_VMX

APX_F + VMX
CPUID.(EAX=07H,ECX=1):EDX[21] APX_F
CPUID.01H:ECX[5] VMX

Nova Lake, Diamond Rapids

Sources

  1. Intel XED v2026.08.23 (commit 0bcb6237345c): forms, encodings, ISA sets, CPUID bits and chip model.
  2. Intel Advanced Performance Extensions (Intel APX) Architecture Specification, revision 7.0 (July 2025)
  3. GCC 14 release notes (x86 target)

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 text is our own.