View source for List of discontinued x86 instructions

{{short description|none}}
{{X86 instruction listings}}
Instructions that have at some point been present as documented instructions in one or more [[x86]] processors, but where the processor series containing the instructions are discontinued or superseded, with no known plans to reintroduce the instructions.

== [[Intel]] instructions ==

=== [[i386]] instructions ===

The following instructions were introduced in the Intel 80386, but later discontinued:
{| class="wikitable"
! Instruction !! Opcode !! Description !! Eventual fate
|-
| {{nowrap|<code>XBTS r, r/m</code>}} || {{nowrap|<code>0F A6 /r</code>}} || Extract Bit String || rowspan="2" | Discontinued from revision B1 of the 80386 onwards.

Opcodes briefly reused for <code>CMPXCHG</code> in Intel 486 stepping A only − <code>CMPXCHG</code> was moved to different opcode from 486 stepping B onwards.

Opcodes later reused for [[VIA PadLock]].
|-
| <code>IBTS r/m, r</code> || <code>0F A7 /r</code> || Insert Bit String
|-
| {{nowrap|<code>MOV r32,TRx</code>}} || <code>0F 24 /r</code> || Move from [[test register]]|| rowspan="2" | Present in Intel 386 and 486 − not present in Intel [[Pentium (original)|Pentium]] or any later Intel CPUs (except they're present in the i486-derived [[Intel Quark|Quark X1000]]).<p>Present in all [[Cyrix]] CPUs.</p>
|-
| <code>MOV TRx,r32</code> || <code>0F 26 /r</code> || Move to test register
|}

=== [[Itanium]] instructions ===

These instructions are only present in the x86 operation mode of early Intel Itanium processors with hardware support for x86. This support was added in "Merced" and removed in "Montecito", replaced with [[IA-32 Execution Layer|software emulation]].
{| class="wikitable"
! Instruction
! Opcode
! Description
|-
| <code>JMPE r/m16</code><br/><code>JMPE r/m32</code>
| <code>0F 00 /6</code>
| rowspan="2" | Jump To Intel Itanium Instruction Set.<ref>Intel [https://www.intel.sg/content/dam/www/public/us/en/documents/manuals/itanium-architecture-vol-4-manual.pdf Itanium Architecture Software Developer's Manual, volume 4], (document number: 323208, revision 2.3, May 2010).</ref>
|-
| {{nowrap|<code>JMPE disp16/32</code>}}
| {{nowrap|<code>0F B8 rel16/32</code>}}
|}

=== MPX instructions ===

{{main|Intel MPX}}

These instructions were introduced in 6th generation Intel Core [[Skylake (microarchitecture)|"Skylake"]] CPUs. The last CPU generation to support them was the 9th generation Core "[[Coffee Lake]]" CPUs.

Intel MPX adds 4 new registers, BND0 to BND3, that each contains a pair of addresses. MPX also defines a bounds-table as a 2-level directory/table data structure in memory that contains sets of upper/lower bounds.
{| class="wikitable"
|-
! Instruction !! Opcode{{efn|For all of the MPX instructions, 16-bit addressing is disallowed − this effectively makes the address-size override prefix <code>67h</code> mandatory in 16-bit mode and prohibited in 32-bit mode. In 64-bit mode, the <code>67h</code> prefix is ignored for the MPX instructions − address size is always 64-bit. These behaviors are unique to the MPX instructions.}} !! Description
|-
| <code>BNDMK b, m</code>
| {{nowrap|<code>F3 0F 1B /r</code>}}{{efn|For <code>BNDMK</code> in 64-bit mode, RIP-relative addressing is not permitted and will cause #UD.}}
| Make lower and upper bound from memory address expression.

The lower bound is given by base component of address, the upper bound by 1-s complement of the address as a whole.
|-
| <code>BNDCL b, r/m</code>
| <code>F3 0F 1A /r</code>
| Check address against lower bound.

<code>BNDCL</code>, <code>BNDCU</code> and <code>BNDCL</code> all produce a #BR exception if the bounds check fails.
|-
| <code>BNDCU b, r/m</code>
| <code>F2 0F 1A /r</code>
| Check address against upper bound in 1's-complement form
|-
| <code>BNDCN b, r/m</code>
| <code>F2 0F 1B /r</code>
| Check address against upper bound.
|-
| {{nowrap|<code>BMDMOV b, b/m</code>}}
| <code>66 0F 1A /r</code>
| rowspan="2" | Move a pair of memory bounds to/from memory or between bounds-registers.
|-
| <code>BNDMOV b/m, b</code>
| {{nowrap|<code>66 0F 1B /r</code>}}
|-
| <code>BNDLDX b,mib</code>
| <code>NP 0F 1A /r</code>{{efn|name=bndldx_sib|text=The <code>BNDLDX</code> and <code>BNDSTX</code> instructions requires memory addressing modes that use the SIB byte − non-SIB addressing modes cause #UD.}}
| Load bounds from the bounds-table, using address translation using an sib-addressing expression mib.{{efn|name=bndldx_br|text=The <code>BNDLDX</code> and <code>BNDSTX</code> instructions produce a #BR exception if bounds directory entry is not valid (which prevents address translation).}}
|-
| <code>BNDSTX mib,b</code>
| <code>NP 0F 1B /r</code>{{efn|name=bndldx_sib}}
| Store bounds into the bounds-table, using address translation using an sib-addressing expression mib.{{efn|name=bndldx_br}}
|-
| <code>BND</code>
| <code>F2</code>
| Instruction prefix used with certain branch instructions{{efn|The branch instructions that can accept a <code>BND</code> prefix are the near forms of <code>JMP</code> (opcodes <code>E9</code> and {{nowrap|<code>FF /4</code>}}), <code>CALL</code> (opcodes <code>E8</code> and {{nowrap|<code>FF /2</code>}}), <code>RET</code> (opcodes <code>C2</code> and <code>C3</code>), and the short/near forms of the <code>Jcc</code> instructions (opcodes <code>70..7F</code> and {{nowrap|<code>0F 80..8F</code>}}). If the BNDPRESERVE config bit is not set, then executing any of these branch instructions without the <code>BND</code> prefix will clear all four bounds registers. (Other branch instructions − such as e.g. far jumps, short jumps (<code>EB</code>), <code>LOOP</code>, <code>IRET</code> etc − do not clear the bounds registers regardless of whether an <code>F2h</code> prefix is present or not.)}} to indicate that they should not clear the bounds registers.
|}
{{notelist}}
{{vpad}}

=== Hardware Lock Elision ===

The Hardware Lock Elision feature of [[Transactional Synchronization Extensions|Intel TSX]] is marked in the Intel SDM as removed from 2019 onwards.<ref name="sdm83_removed">Intel [https://kib.kiev.ua/x86docs/Intel/SDMs/253665-083.pdf SDM, volume 1], order no. 253665-083, mar 2024, chapter 2.5</ref> This feature took the form of two instruction prefixes, <code>XACQUIRE</code> and <code>XRELEASE</code>, that could be attached to memory atomics/stores to elide the memory locking that they represent.

{| class="wikitable"
|-
! Instruction prefix !! Opcode !! Description
|-
| <code>XACQUIRE</code>
| <code>F2</code>
| Instruction prefix to indicate start of hardware lock elision, used with memory atomic instructions only (for other instructions, the <code>F2</code> prefix may have other meanings). When used with such instructions, may start a transaction instead of performing the memory atomic operation.
|-
| <code>XRELEASE</code>
| <code>F3</code>
| Instruction prefix to indicate end of hardware lock elision, used with memory atomic/store instructions only (for other instructions, the <code>F3</code> prefix may have other meanings). When used with such instructions during hardware lock elision, will end the associated transaction instead of performing the store/atomic.
|}

=== VP2Intersect instructions ===
The VP2INTERSECT instructions (an AVX-512 subset) were introduced in [[Tiger Lake]] (11th generation mobile Core processors), but were never officially supported on any other Intel processors - they are now considered deprecated<ref>R. Singhal, [https://twitter.com/rsinghal1/status/1681756682085634048 Yes. Deprecated.] (about VP2INTERSECT), Jul 19, 2023. [https://archive.today/20230723235553/https://twitter.com/rsinghal1/status/1681756682085634048 Archived] on Jul 23, 2023.</ref> and are listed in the Intel SDM as removed from 2023 onwards.<ref name="sdm83_removed" />

As of July 2024, the VP2INTERSECT instructions have been re-introduced on AMD [[Zen 5]] processors.<ref>Alexander Yee, [http://www.numberworld.org/blogs/2024_8_7_zen5_avx512_teardown/#VP2INTERSECT Zen5's AVX512 Teardown + More], 7 Aug 2024</ref>
{| class="wikitable"
! Instruction
! Opcode
! Description
|-
| {{nowrap|<code>VP2INTERSECTD k1+1, xmm2, xmm3/m128/m32bcst</code>}}<br/><code>VP2INTERSECTD k1+1, ymm2, ymm3/m256/m32bcst</code><br/><code>VP2INTERSECTD k1+1, zmm2, zmm3/m512/m32bcst</code>
| {{nowrap|<code>EVEX.NDS.F2.0F38.W0 68 /r</code>}}
| Store, in an even/odd pair of mask registers, the indicators of the locations of value matches between 32-bit lanes in the two vector source arguments.
|-
| {{nowrap|<code>VP2INTERSECTQ k1+1, xmm2, xmm3/m128/m64bcst</code>}}<br/><code>VP2INTERSECTQ k1+1, ymm2, ymm3/m256/m64bcst</code><br/><code>VP2INTERSECTQ k1+1, zmm2, zmm3/m512/m64bcst</code>
| {{nowrap|<code>EVEX.NDS.F2.0F38.W1 68 /r</code>}}
| Store, in an even/odd pair of mask registers, the indicators of the locations of value matches between 64-bit lanes in the two vector source arguments.
|}
{{vpad}}

=== Instructions specific to Xeon Phi processors ===

==== "Knights Corner" instructions ====

The first generation [[Xeon Phi]] processors, codenamed "Knights Corner" (KNC), supported a large number of instructions that are not seen in any later x86 processor. An instruction reference is available<ref>Intel, [https://www.intel.com/content/dam/develop/external/us/en/documents/327364001en.pdf Intel® Xeon Phi™ Coprocessor Instruction Set Architecture Reference Manual], sep 2012, order no. 327364-001. [https://web.archive.org/web/20210804022347/https://software.intel.com/content/dam/develop/external/us/en/documents/327364001en.pdf Archived] on 4 Aug 2021.</ref> − the instructions/opcodes unique to KNC are the ones with VEX and MVEX prefixes (except for the <code>KMOV</code>, <code>KNOT</code> and <code>KORTEST</code> instructions − these are kept with the same opcodes and function in AVX-512, but with an added "W" appended to their instruction names).

Most of these KNC-unique instructions are similar but not identical to instructions in [[AVX-512]] − later Xeon Phi processors replaced these instructions with AVX-512.

Early versions of AVX-512 avoided the instruction encodings used by KNC's MVEX prefix, however with the introduction of Intel APX ([[X86#APX (Advanced Performance Extensions)|Advanced Performance Extensions]]) in 2023, some of the old KNC MVEX instruction encodings have been reused for new APX encodings. For example, both KNC and APX accept the instruction encoding {{nowrap|1=<code>62 F1 79 48 6F 04 C1</code>}} as valid, but assign different meanings to it: 
* KNC: {{nowrap|1=<code>VMOVDQA32 zmm0, k0, xmmword ptr [rcx+rax*8]{uint8}</code>}} - vector load with data conversion
* APX: {{nowrap|1=<code>VMOVDQA32 zmm0, [rcx+r16*8]</code>}} - vector load with one of the new APX extended-[[General-purpose register|GPR]]s used as scaled index 
{{vpad}}

==== "Knights Landing" and "Knights Mill" instructions ====

Some of the AVX-512 instructions in the [[Xeon Phi]] "Knights Landing" and later models belong to the [[AVX-512]] subsets "AVX512ER", "AVX512_4FMAPS", "AVX512PF" and "AVX512_4VNNIW", all of which are unique to the Xeon Phi series of processors. The ER and PF subsets were introduced in "Knights Landing" − the 4FMAPS and 4VNNIW instructions were later added in "Knights Mill".
{{vpad}}
The ER and 4FMAPS instructions are floating-point arithmetic instructions that all follow a given pattern where:
* EVEX.W is used to specify floating-point format (0=FP32, 1=FP64)
* The bottom opcode bit is used to select between packed and scalar operation (0: packed, 1:scalar)
* For a given operation, all the scalar/packed variants belong to the same AVX-512 subset.
* The instructions all support result masking by opmask registers. The AVX512ER instructions also all support broadcast of memory operands.
* The only supported vector width is 512 bits.

{| class="wikitable"
! rowspan="2" | Operation
! rowspan="2" | AVX-512<br>subset
! rowspan="2" | Basic opcode
| scope="col" style="width: 1px; border-spacing:0; padding:0px" rowspan="8" |
! colspan="2" | FP32 instructions (W=0)
| scope="col" style="width: 1px; border-spacing:0; padding:0px" rowspan="8" |
! colspan="2" | FP64 instructions (W=1)
| scope="col" style="width: 1px; border-spacing:0; padding:0px" rowspan="8" |
! rowspan="2" | RC/SAE
|-
! Packed
! Scalar
! Packed
! Scalar
|-
! colspan="3" | Xeon Phi specific instructions (ER, 4FMAPS) !! colspan="2" | !! colspan="2" | !!
|-
| Reciprocal approximation with an accuracy of <math>2^{-28}</math>{{efn|name=avx512er_reference|text=For the AVX512ER instructions, a numerically exact reference is available as C code.<!-- as of sep 2023, the link provided in rev 80 of Intel SDM is broken, but the reference code nevertheless exists and remains googleable--><ref>Intel, [https://www.intel.com/content/www/us/en/developer/articles/code-sample/reference-implementations-for-ia-approximation-instructions-vrcp14-vrsqrt14-vrcp28-vrsqrt28-vexp2.html Reference Implementations for Intel® Architecture Approximation Instructions VRCP14, VRSQRT14, VRCP28, VRSQRT28, and VEXP2], id #671685, Dec 28, 2015. [https://archive.today/20230918212656/https://www.intel.com/content/www/us/en/developer/articles/code-sample/reference-implementations-for-ia-approximation-instructions-vrcp14-vrsqrt14-vrcp28-vrsqrt28-vexp2.html Archived] on Sep 18, 2023.<p>C code [https://www.intel.com/content/dam/develop/external/us/en/documents/RECIP28EXP2.c "RECIP28EXP2.c"] [https://web.archive.org/web/20230918212012/https://www.intel.com/content/dam/develop/external/us/en/documents/RECIP28EXP2.c archived] on Sep 18, 2023.</p></ref>}}
| ER || {{nowrap|<code>EVEX.66.0F38 (CA/CB) /r</code>}} || {{nowrap|<code>VRCP28PS z,z,z/m512</code>}} || {{nowrap|<code>VRCP28SS x,x,x/m32</code>}} || {{nowrap|<code>VRCP28PD z,z,z/m512</code>}} || {{nowrap|<code>VRCP28SD x,x,x/m64</code>}} || SAE
|-
| Reciprocal square root approximation with an accuracy of <math>2^{-28}</math>{{efn|name=avx512er_reference}} || ER || {{nowrap|<code>EVEX.66.0F38 (CC/CD) /r</code>}} || {{small|{{nowrap|<code>VRSQRT28PS z,z,z/m512</code>}}}} || {{small|{{nowrap|<code>VRSQRT28SS x,x,x/m32</code>}}}} || {{small|{{nowrap|<code>VRSQRT28PD z,z,z/m512</code>}}}} || {{small|{{nowrap|<code>VRSQRT28SD x,x,x/m64</code>}}}} || SAE
|-
| Exponential <math>2^{x}</math> approximation with <math>2^{-23}</math> relative error{{efn|name=avx512er_reference}} || ER || <code>EVEX.66.0F38 C8 /r</code> || <code>VEXP2PS z,z/m512</code> || {{no}} || <code>VEXP2PD z,z/m512</code> || {{no}} || SAE
|-
| Fused-multiply-add, 4 iterations || 4FMAPS || {{nowrap|<code>EVEX.F2.0F38 (9A/9B) /r</code>}} || {{small|{{nowrap|<code>V4FMADDPS z,z+3,m128</code>}}}} || {{small|{{nowrap|<code>V4FMADDSS x,x+3,m128</code>}}}} || {{no}} || {{no}} ||
|-
| Fused negate-multiply-add, 4 iterations || 4FMAPS || {{nowrap|<code>EVEX.F2.0F38 (AA/AB) /r</code>}} || {{small|{{nowrap|<code>V4FNMADDPS z,z+3,m128</code>}}}} || {{small|{{nowrap|<code>V4FNMADDSS x,x+3,m128</code>}}}} || {{no}} || {{no}} ||
|}
{{notelist}}
{{vpad}}
The AVX512PF instructions are a set of 16 prefetch instructions. These instructions all use VSIB encoding, where a memory addressing mode using the SIB byte is required, and where the index part of the SIB byte is taken to index into the AVX512 vector register file rather than the GPR register file. The selected AVX512 vector register is then interpreted as a vector of indexes, causing the standard x86 base+index+displacement address calculation to be performed for each vector lane, causing one associated memory operation (prefetches in case of the AVX512PF instructions) to be performed for each active lane. The instruction encodings all follow a pattern where:
* EVEX.W is used to specify format of the prefetchable data (0:FP32, 1:FP64)
* The bottom bit of the opcode is used to indicate whether the AVX512 index register is considered a vector of sixteen signed 32-bit indexes (bit 0 not set) or eight signed 64-bit indexes (bit 0 set)
* The instructions all support operation masking by opmask registers.
* The only supported vector width is 512 bits.

{| class="wikitable"
! rowspan=2 | Operation
! rowspan=2 | Basic opcode
! colspan=2 | 32-bit indexes (opcode <code>C6</code>)
! colspan=2 | 64-bit indexes (opcode <code>C7</code>)
|-
! FP32 prefetch (W=0)
! FP64 prefetch (W=1)
! FP32 prefetch (W=0)
! FP64 prefetch (W=1)
|-
| Prefetch into L1 cache (T0 hint)
| {{small|{{nowrap|<code>EVEX.66.0F38 (C6/C7) /1 /vsib</code>}}}} || {{small|{{nowrap|<code>VGATHERPF0DPS vm32z {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF0DPD vm32y {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF0QPS vm64z {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF0QPD vm64y {k1}</code>}}}}
|-
| Prefetch into L2 cache (T1 hint)
| {{small|{{nowrap|<code>EVEX.66.0F38 (C6/C7) /2 /vsib</code>}}}} || {{small|{{nowrap|<code>VGATHERPF1DPS vm32z {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF1DPD vm32y {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF1QPS vm64z {k1}</code>}}}} || {{small|{{nowrap|<code>VGATHERPF1QPD vm64y {k1}</code>}}}}
|-
| Prefetch into L1 cache (T0 hint) with intent to write
| {{small|{{nowrap|<code>EVEX.66.0F38 (C6/C7) /5 /vsib</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF0DPS vm32z {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF0DPD vm32y {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF0QPS vm64z {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF0QPD vm64y {k1}</code>}}}}
|-
| Prefetch into L2 cache (T1 hint) with intent to write
| {{small|{{nowrap|<code>EVEX.66.0F38 (C6/C7) /6 /vsib</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF1DPS vm32z {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF1DPD vm32y {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF1QPS vm64z {k1}</code>}}}} || {{small|{{nowrap|<code>VSCATTERPF1QPD vm64y {k1}</code>}}}}
|}
{{vpad}}
The AVX512_4VNNIW instructions read a 128-bit data item from memory, containing 4 two-component vectors (each component being signed 16-bit). Then, for each of 4 consecutive AVX-512 registers, they will, for each 32-bit lane, interpret the lane as a two-component vector (signed 16-bit) and perform a dot-product with the corresponding two-component vector that was read from memory (the first two-component vector from memory is used for the first AVX-512 source register, and so on). These results are then accumulated into a destination vector register.

{| class="wikitable"
! Instruction
! Opcode
! Description
|-
| {{nowrap|<code>VP4DPWSSD zmm1{k1}{z}, zmm2+3, m128</code>}} 
| {{nowrap|<code>EVEX.512.F2.0F38.W0 52 /r</code>}}
| Dot-product of signed words with dword accumulation, 4 iterations
|-
| {{nowrap|<code>VP4DPWSSDS zmm1{k1}{z}, zmm2+3, m128</code>}}
| {{nowrap|<code>EVEX.512.F2.0F38.W0 53 /r</code>}}
| Dot-product of signed words with dword accumulation and saturation, 4 iterations
|}
{{vpad}}
Xeon Phi processors (from Knights Landing onwards) also featured the <code>PREFETCHWT1 m8</code> instruction (opcode <code>0F 0D /2</code>, prefetch into L2 cache with intent to write) − these were the only Intel CPUs to officially support this instruction, but it continues to be supported on some non-Intel processors (e.g. [[Zhaoxin]] YongFeng).
{{vpad}}

== [[AMD]] instructions ==

=== [[Am386]] SMM instructions ===

A handful of instructions to support [[System Management Mode]] were introduced in the Am386SXLV and Am386DXLV processors.<ref name="mpr92_smm" /><ref>{{Cite web|url=https://www.ardent-tool.com/CPU/docs/AMD/386/386SX/21020A.pdf|title=Am386®SX/SXL/SXLV High-Performance, Low-Power, Embedded Microprocessors}}, publication #21020, rev A, apr 1997 − has SMM instruction descriptions on pages 5 and 6.</ref> They were also present in the later Am486SXLV/DXLV and [[AMD Élan|Elan]] SC300/310 processors.<ref>AMD, [https://www.amd.com/content/dam/amd/en/documents/archived-tech-docs/programmer-references/20665.pdf Élan™SC310 Microcontroller Programmer’s Reference Manual], order no. 20665A, April 1996, section 1.9.4, page 49. [https://web.archive.org/web/20240905221901/https://www.amd.com/content/dam/amd/en/documents/archived-tech-docs/programmer-references/20665.pdf Archived] on 5 Sep 2024.</ref>

The SMM functionality of these processors was implemented using Intel [[In-circuit emulation|ICE]] [[microcode]] without a valid license, resulting in a lawsuit that AMD lost in late 1994.<ref>Intel vs AMD, {{Cite web|url=https://ir.amd.com/sec-filings/content/0000898430-94-000804/EX-99_1.txt|title=Case No.C-93-20301 PVT, Findings of fact and conclusions of law following "ICE" module of trial|date=Oct 7, 1994|archive-url=https://web.archive.org/web/20210510143606/https://ir.amd.com/sec-filings/content/0000898430-94-000804/EX-99_1.txt|archive-date=10 May 2021|url-status=live}}</ref> As a result of this loss, the ICE microcode was removed from all later AMD CPUs, and the SMM instructions removed with it.

{| class="wikitable"
! Instruction !! Opcode !! Description
|-
| <code>SMI</code> || <code>F1</code> || Call SMM interrupt handler (only if [[x86 debug register|DR7]] bit 12 is set; not available on Am486SXLV/DXLV<ref name="complete_x86">John H. Wharton, [https://bitsavers.org/pdf/microDesign/Microdesign_-_The_Complete_X86_Volume_1_1994.pdf The Complete X86, Volume 1], 1994. ''MicroDesign Resources'', {{ISBN|1-885330-02-2}}.<br/>Covers instruction set additions of Am486SXLV on page 210, Cyrix 486S on page 273 and IBM 386SLC on page 298.</ref>)
|-
| <code>UMOV r/m8, r8</code> || <code>0F 10 /r</code> || rowspan="4" | Move data between registers and main system memory
|-
| <code>UMOV r/m, r16/32</code> || <code>0F 11 /r</code>
|-
| <code>UMOV r8, r/m8</code> || <code>0F 12 /r</code>
|-
| {{nowrap|<code>UMOV r16/32, r/m</code>}} || {{nowrap|<code>0F 13 /r</code>}}
|-
| <code>RES3</code> || <code>0F 07</code> || Return from SMM interrupt handler (Am386SXLV/DXLV only)<br/>Takes a pointer in ES:EDI to a processor save state to resume from − this save state has format nearly identical to that of the undocumented Intel 386 <code>[[LOADALL]]</code> instruction.<ref name="potemkin">Potemkin's Hackers Group, [http://phg.chat.ru/opcode.txt OPCODE.LST v4.51], 15 Oct 1999. [https://web.archive.org/web/20010521193749/http://phg.chat.ru/opcode.txt Archived] on 21 May 2001.</ref>
|-
| <code>RES4</code> || <code>0F 07</code> || Return from SMM interrupt handler (Am486SXLV/DXLV only).<br/>Similar to <code>RES3</code>, but with a different save state format.<ref>Hans Peter Messmer, "The Indispensable PC Hardware Book" (ISBN 0201403994), chapter 10.6.1, pages 280-281</ref>
|}

These SMM instructions were also present on the [[IBM 386SLC]] and its derivatives (albeit with the <code>[[LOADALL]]</code>-like SMM return opcode <code>0F 07</code> named <code>ICERET</code>),<ref name="potemkin" /><ref>Frank van Gilluwe, "The Undocumented PC, second edition", 1997, {{ISBN|0-201-47950-8}}, page 120</ref><ref name="complete_x86" /> as well as on the [[UMC Green CPU|UMC U5S]] processor.<ref>Microprocessor Report, [https://www.cecs.uci.edu/~papers/mpr/MPR/ARTICLES/080702.pdf UMC Announces Enhanced 486SX-Compatible], (vol 8, no.7, May 30, 1994) — describes the UMC U5S as having "built-in SMM, which is hardware- and software-compatible with AMD’s implementation." [https://web.archive.org/web/20240907104134/https://www.cecs.uci.edu/~papers/mpr/MPR/ARTICLES/080702.pdf Archived] on 7 Sep 2024.</ref>

=== 3DNow! instructions ===

{{main|3DNow!}}

The 3DNow! instruction set extension was introduced in the AMD [[K6-2]], mainly adding support for floating-point SIMD instructions using the MMX registers (two [[FP32]] components in a 64-bit vector register). The instructions were mainly promoted by AMD, but were supported on some non-AMD CPUs as well. The processors supporting 3DNow! were:
* AMD K6-2, [[AMD K6-III|K6-III]], and all processors based on the [[AMD K7|K7]], [[AMD K8|K8]] and [[AMD K10|K10]] microarchitectures. (Later AMD microarchitectures such as [[Bulldozer (microarchitecture)|Bulldozer]], [[Bobcat (microarchitecture)|Bobcat]] and [[Zen (microarchitecture)|Zen]] do not support 3DNow!)
* IDT [[WinChip]] 2 and 3
* VIA [[Cyrix III]] (both "Joshua" and "Samuel" variants), and the "Samuel" and "Ezra" revisions of [[VIA C3]]. (Later VIA CPUs, from C3 "Nehemiah" onwards, dropped 3DNow! in favor of [[Streaming SIMD Extensions|SSE]].)
* National Semiconductor [[Geode (processor)#Geode GX2|Geode GX2]]; AMD Geode GX and LX.

{| class="wikitable"
! Instruction !! Opcode !! colspan=2 | Instruction description
|-
| <code>PFADD mm1,mm2/m64</code> || <code>0F 0F /r 9E</code> || colspan=2 | Packed floating-point addition:<br/><code>dst <- dst + src</code>
|-
| <code>PFSUB mm1,mm2/m64</code> || <code>0F 0F /r 9A</code> || colspan=2 | Packed floating-point subtraction:<br/><code>dst <- dst − src</code>
|-
| <code>PFSUBR mm1,mm2/m64</code> || <code>0F 0F /r AA</code> || colspan=2 | Packed floating-point reverse subtraction:<br/><code>dst <- src − dst</code>
|-
| <code>PFMUL mm1,mm2/m64</code> || <code>0F 0F /r B4</code> || colspan=2 | Packed floating-point multiplication:<br/><code>dst <- dst * src</code>
|-
| <code>PFMAX mm1,mm2/m64</code> || <code>0F 0F /r A4</code> || colspan=2 | Packed floating-point maximum:<br/><code>dst <- (dst > src) ? dst : src</code>
|-
| <code>PFMIN mm1,mm2/m64</code> || <code>0F 0F /r 94</code> || colspan=2 | Packed floating-point minimum:<br/><code>dst <- (dst < src) ? dst : src</code>
|-
| <code>PFCMPEQ mm1,mm2/m64</code> || <code>0F 0F /r B0</code> || colspan=2 | Packed floating-point comparison, equal:<br/><code>dst <- (dst == src) ? 0xFFFFFFFF : 0</code>
|-
| <code>PFCMPGE mm1,mm2/m64</code> || <code>0F 0F /r 90</code> || colspan=2 | Packed floating-point comparison, greater than or equal:<br/><code>dst <- (dst >= src) ? 0xFFFFFFFF : 0</code> 
|-
| <code>PFCMPGT mm1,mm2/m64</code> || <code>0F 0F /r A0</code> || colspan=2 | Packed floating-point comparison, greater than:<br/><code>dst <- (dst > src) ? 0xFFFFFFFF : 0</code>
|-
| <code>PF2ID mm1,mm2/m64</code> || <code>0F 0F /r 1D</code> || colspan=2 | Converts packed floating-point operand to packed 32-bit signed integer, with round-to-zero
|-
| <code>PI2FD mm1,mm2/m64</code> || {{nowrap|<code>0F 0F /r 0D</code>}} || colspan=2 | Packed 32-bit signed integer to floating-point conversion, with round-to-zero
|-
! colspan=4 |
|-
| <code>PFRCP mm1,mm2/m64</code> || <code>0F 0F /r 96</code> || Floating-point reciprocal approximation (at least 14 bit precision):<br/>
<pre>
temp <- approx(1.0/src[31:0])
dst[31:0] <- temp
dst[63:32] <- temp
</pre>
| rowspan=5 | The 3DNow! specification<ref>AMD, [https://www.amd.com/system/files/TechDocs/21928.pdf 3DNow! Technology Manual], pub.no. 21928G/0, March 2000. [https://web.archive.org/web/20181009092652/https://www.amd.com/system/files/TechDocs/21928.pdf Archived] on 9 Oct 2018.</ref> does not directly specify the operation performed by the <code>PFRCPIT1</code>, <code>PFRSQIT1</code> and <code>PFRCPIT2</code> instructions − instead, it imposes requirements on the results of using these instructions together in specific ways:{{efn|text=The 3DNow! precision requirements can be fulfilled in several different ways, for example:<ul><li>On AMD K6-2, the <code>PFRCPIT1</code>, <code>PFRSQIT1</code> and <code>PFRCPIT2</code> instructions would perform various parts of a [[Newton-Raphson]] iteration to improve the precision of a low-precision initial result from <code>PFRCP</code>/<code>PFRSQRT</code>.<ref>AMD, [https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/26569.pdf AMD64 Architecture Programmer’s Manual Volume 5], pub.no.26569, rev 3.16, Nov 2021 − provides details on how <code>PFRCPIT1</code>, <code>PFRSQIT1</code> and <code>PFRCPIT2</code> perform their Newton-Raphson iterations on pages 118 to 125. [https://web.archive.org/web/20230924160446/https://www.amd.com/content/dam/amd/en/documents/processor-tech-docs/programmer-references/26569.pdf Archived] on 24 Sep 2023.</ref></li><li>On AMD Geode LX, the <code>PFRCP</code> and <code>PFRSQRT</code> instructions would instead compute their results with full 24-bit precision − this made it possible to turn the <code>PFRCPIT1</code>, <code>PFRSQIT1</code> and <code>PFRCPIT2</code> instructions into pure data movement instructions, performing the same operation as <code>MOVQ</code>.<ref>AMD, [https://www.amd.com/system/files/TechDocs/33234H_LX_databook.pdf Geode LX Processors Data Book], pub.no. 33234H, Feb 2009, page 673. [https://web.archive.org/web/20190315070443/https://www.amd.com/system/files/TechDocs/33234H_LX_databook.pdf Archived] on 15 Mar 2019.</ref></li></ul>}}

If the bottom 32 bits of <code>mm0</code> initially contains a value X in FP32 format, then the instruction sequence:

<pre>PFRCP mm1,mm0
PFRCPIT1 mm0,mm1
PFRCPIT2 mm0,mm1</pre>
must fill both 32-bit lanes of <code>mm0</code> with <math>\frac{1.0}{X}</math> in FP32 format, computed with an error of at most 1 [[Unit in the last place|ulp]].

Similarly, the instruction sequence:<pre>PFRSQRT mm1,mm0
MOVQ mm2,mm1
PFMUL mm1,mm1
PFRSQIT1 mm1,mm0
PFRCPIT2 mm1,mm2</pre>
must fill both 32-bit lanes of <code>mm1</code> with <math>\frac{1.0}{\sqrt{X}}</math> in FP32 format, computed with an error of at most 1 ulp.
|-
| <code>PFRSQRT mm1,mm2/m64</code> || <code>0F 0F /r 97</code> || Floating-point reciprocal square root approximation (at least 15 bit precision):<br/>
<pre>
temp <- approx(1.0/sqrt(src[31:0]))
dst[31:0] <- temp
dst[63:32] <- temp
</pre>
|-
| {{nowrap|<code>PFRCPIT1 mm1,mm2/m64</code>}} || <code>0F 0F /r A6</code> || Packed floating-point reciprocal, first iteration step
|-
| {{nowrap|<code>PFRSQIT1 mm1,mm2/m64</code>}} || <code>0F 0F /r A7</code> || Packed floating-point reciprocal square root, first iteration step
|-
| {{nowrap|<code>PFRCPIT2 mm1,mm2/m64</code>}} || <code>0F 0F /r B6</code> || Packed floating-point reciprocal/reciprocal square root, second iteration step
|-
! colspan=4 |
|-
| <code>PFACC mm1,mm2/m64</code> || <code>0F 0F /r AE</code> || colspan=2 | Floating-point accumulate (horizontal add):<br/><pre>
dst[31:0] <- dst[31:0] + dst[63:32]
dst[63:32] <- src[31:0] + src[63:32]</pre>
|-
| {{nowrap|1=<code>PMULHRW mm1,mm2/m64</code>,{{efn|text=The 3DNow! <code>PMULHRW</code> instruction has the same mnemonic as the Cyrix EMMI <code>PMULHRW</code> instruction, however its opcode and function differ (the EMMI instruction right-shifts its multiply-result by 15 bits, while the 3DNow! instruction right-shifts by 16 bits).<p>Some assemblers/disassemblers, such as NASM, resolve this ambiguity by using the mnemonic <code>PMULHRWA</code> for the 3DNow! instruction and <code>PMULHRWC</code> for the EMMI instruction.</p>}}}}<br/>{{nowrap|1=<code>PMULHRWA mm1,mm2/m64</code>}} || <code>0F 0F /r B7</code> || colspan=2 | Multiply signed packed 16-bit integers with rounding and store the high 16 bits:<br/><code>dst <- ((dst * src) + 0x8000) >> 16</code>
|-
| <code>PAVGUSB mm1,mm2/m64</code> || <code>0F 0F /r BF</code> || colspan=2 | Average of unsigned packed 8-bit integers:<br/><code>dst <- (src+dst+1) >> 1</code>
|-
| <code>FEMMS</code> || <code>0F 0E</code> || colspan=2 | Faster Enter/Exit of the MMX or x87 floating-point state{{efn|The <code>FEMMS</code> instruction differs from the standard MMX <code>EMMS</code> instruction in that <code>FEMMS</code> makes the FP/MMX register contents undefined after the instruction is executed.}}
|}
{{notelist}}
{{vpad}}
3DNow! also introduced a couple of prefetch instructions: {{nowrap|<code>PREFETCH m8</code>}} (opcode {{nowrap|<code>0F 0D /0</code>}}) and {{nowrap|<code>PREFETCHW m8</code>}} (opcode {{nowrap|<code>0F 0D /1</code>}}). These instructions, unlike the rest of 3DNow!, are not discontinued but continue to be supported on modern AMD CPUs. The <code>PREFETCHW</code> instruction is also supported on Intel CPUs starting with {{nowrap|65 nm}} Pentium 4,<ref>{{Cite web|url=https://superuser.com/questions/931742/windows-10-64-bit-requirements-does-my-cpu-support-cmpxchg16b-prefetchw-and-la|title=Windows 10 64-bit requirements: Does my CPU support CMPXCHG16b, PrefetchW and LAHF/SAHF?}}</ref> albeit executed as NOP until [[Broadwell (microarchitecture)|Broadwell]].
{{vpad}}

==== 3DNow+ instructions added with [[Athlon]] and [[AMD K6-III#K6-2+ (180 nm, mobile)|K6-2+]] ====

{| class="wikitable"
! Instruction !! Opcode !! Instruction description
|-
| <code>PF2IW mm1,mm2/m64</code>
| <code>0F 0F /r 1C</code> 
| Packed 32-bit floating-point to 16-bit signed integer conversion, with round-to-zero{{efn|name=pf2iw_undoc|The <code>PF2IW</code> and <code>PI2FW</code> instructions also existed as undocumented instructions on the original K6-2.<p>The undocumented variant of <code>PF2IW</code> in K6-2 would set the top 16 bits of each 32-bit result lane to all-0s, while the documented variant in later processors would sign-extend the 16-bit result to 32 bits.<ref>Grzegorz Mazur, [https://web.archive.org/web/20000121143428/http://x86.ddj.com/articles/3dnow/amd_3dnow.htm AMD 3DNow! undocumented instructions]</ref><ref name="mazur_3dnow">{{cite web |url=http://grafi.ii.pw.edu.pl/gbm/x86/3dundoc.html |title=Undocumented 3DNow! Instructions |website=grafi.ii.pw.edu.pl |access-date=22 February 2022 |archive-url=https://web.archive.org/web/20030130030723/http://grafi.ii.pw.edu.pl/gbm/x86/3dundoc.html |archive-date=30 January 2003 |url-status=dead}}</ref></p>}}
|-
| <code>PI2FW mm1,mm2/m64</code>
| <code>0F 0F /r 0C</code> 
| Packed 16-bit signed integer to 32-bit floating-point conversion{{efn|name=pf2iw_undoc}}
|-
| <code>PSWAPD mm1,mm2/m64</code>
| {{nowrap|<code>0F 0F /r BB</code>{{efn|The <code>PSWAPD</code> instruction uses same opcode as the older undocumented K6-2 <code>PSWAPW</code> instruction.<ref name="mazur_3dnow" />|}} 
| Packed Swap Doubleword:<br/><pre>
dst[31:0] <- src[63:32]
dst[63:32] <- src[31:0]</pre>
|-
| <code>PFNACC mm1,mm2/m64</code>
| <code>0F 0F /r 8A</code>
| Packed Floating-Point Negative Accumulate:<br/><pre>
dst[31:0] <- dst[31:0] − dst[63:32]
dst[63:32] <- src[31:0] − src[63:32]</pre>
|-
| {{nowrap|<code>PFPNACC mm1,mm2/m64</code>}}
| <code>0F 0F /r 8E</code> 
| Packed Floating-Point Positive-Negative Accumulate:<br/><pre>dst[31:0] <- dst[31:0] − dst[63:32]
dst[63:32] <- src[31:0] + src[63:32]</pre>
|}
{{notelist}}
{{vpad}}

==== 3DNow! instructions specific to [[Geode GX]] and LX ====

{| class="wikitable"
! Instruction !! Opcode !! Instruction description
|-
| <code>PFRCPV mm1,mm2/m64</code> || <code>0F 0F /r 86</code> || Packed Floating-point Reciprocal Approximation
|-
| {{nowrap|<code>PFRSQRTV mm1,mm2/m64</code> || {{nowrap|<code>0F 0F /r 87</code>}} || Packed Floating-point Reciprocal Square Root Approximation
|}
{{vpad}}

=== [[SSE5]] derived instructions ===
SSE5 was a proposed SSE extension by AMD, using a new "DREX" instruction encoding to add support for new 3-operand and 4-operand instructions to SSE.<ref>AMD, [https://web.archive.org/web/20090124092442/http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/43479.pdf AMD64 Technology: 128-bit SSE5 Instruction Set], pub.no. 43479, rev 3.01, Aug 2007. Archived from the [http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/43479.pdf original] on Jan 24, 2009.</ref> The bundle did not include the full set of Intel's SSE4 instructions, making it a competitor to SSE4 rather than a successor.

AMD chose not to implement SSE5 as originally proposed − it was instead reworked into FMA4 and XOP,<ref>AMD, [https://www.amd.com/system/files/TechDocs/43479.pdf AMD64 Architecture Programmer’s Manual Volume 6: 128-Bit and 256-Bit XOP and FMA4], pub.no. 43479, rev 3.04, Nov 2009. [https://web.archive.org/web/20181011133501/https://www.amd.com/system/files/TechDocs/43479.pdf Archived] on Oct 11, 2018.</ref> which provided similar functionality but with a quite different instruction encoding − using the [[VEX prefix]] for the FMA4 instructions and the new VEX-like XOP prefix for most of the remaining instructions.

==== [[XOP instruction set|XOP]] instructions ====
Introduced with the Bulldozer processor core, removed again from [[Zen (microarchitecture)]] onward.

A revision of most of the SSE5 instruction set.

The XOP instructions mostly make use of the XOP prefix, which is a 3-byte prefix with the following layout:
{| class="wikitable" style="text-align:center"
!
! scope="col" style="width: 2px; border-spacing:0; padding:0px" rowspan=3 |
! Byte 0
! scope="col" style="width: 2px; border-spacing:0; padding:0px" rowspan=3 |
! colspan=8 | Byte 1
! scope="col" style="width: 2px; border-spacing:0; padding:0px" rowspan=3 |
! colspan=8 | Byte 2
|-
! Bits
! 7:0
! 7 !! 6 !! 5 !! 4 !! 3 !! 2 !! 1 !! 0
! 7 !! 6 !! 5 !! 4 !! 3 !! 2 !! 1 !! 0
|-
! Usage
| <code>8Fh</code>
| R̅ || X̅ || B̅ || colspan=5 | mmmmm
| W || colspan=4 | v̅v̅v̅v̅ || L || colspan=2 | pp
|}
where:
* Overlines indicate inverted bits.
* The R/X/B bits are argument extension bits similar to the RXB bits of the REX prefix.
* ''mmmmm'' is an opcode-map specifier. While capable of encoding values from 8 to 31 (values 0 to 7 map to [[ModR/M]]-encoded variants of the older <code>POP</code> instruction, making them unusable for XOP), only maps <code>8</code>, <code>9</code> and <code>[[Hexadecimal|0Ah]]</code> were ever used: map <code>8</code> for instructions that take an 8-bit immediate, map <code>9</code> for instructions that don't take an immediate, and map <code>0Ah</code> for instructions that take a 32-bit immediate.
* W is used in a couple of different ways:
** For XOP vector instructions, W is used to swap the last two vector source arguments to the instruction. For instructions that allow W=1, encodings with W=0 allow the second-to-last vector argument to be a memory argument, while encodings with W=1 allow the last vector argument to be a memory argument. For instructions that don't allow their last two vector arguments to be swapped, W is required to be 0.
** For XOP-encoded integer-register instructions (the TBM and LWP instruction set extensions, see below), W is used for operand size. (0=32-bit, 1=64-bit)
* ''vvvv'' is an extra source register argument, normally the first non-r/m source argument for instructions with ≥3 register arguments.
* L is a vector length specifier. L=1 indicates 256-bit operation, L=0 indicates scalar or 128-bit operation.
* ''pp'' is an embedded prefix − nominally 0/1/2/3=none/66h/F2h/F3h, but only 0 was ever used with any of the instructions defined for the XOP prefix.
{{vpad}}
The XOP instructions encoded with the XOP prefix are as follows:
{| class="wikitable"
|-
! colspan=2 | Instruction description
! Instruction mnemonics
! Opcode
! W=1<br />swap<br />allowed
! L=1<br />(256b)<br />allowed
|-
! colspan=6 |
|-
| rowspan=4 | Extract fractional portion of floating-point value.
| Packed FP32
| <code>VFRCZPS ymm1,ymm2/m256</code>
| <code>XOP.9 80 /r</code>
| {{no}} || {{yes}}
|-
| Packed FP64
| <code>VFRCZPD ymm1,ymm2/m256</code>
| <code>XOP.9 81 /r</code>
| {{no}} || {{yes}}
|-
| Scalar FP32
| <code>VFRCZSS xmm1,xmm2/m32</code>
| <code>XOP.9 82 /r</code>
| {{no}} || {{no}}
|-
| Scalar FP64
| <code>VFRCZSD xmm1,xmm2/m64</code>
| <code>XOP.9 83 /r</code>
| {{no}} || {{no}}
|-
! colspan=6 |
|-
| colspan=2 | Vector per-bit-lane conditional move.

<code>VPCMOV dst,src1,src2,src3</code> performs the equivalent of {{nowrap|<code>dst <- (src1 AND src3) OR (src2 AND NOT(src3))</code>}}
| {{nowrap|<code>VPCMOV ymm1,ymm2,ymm3/m256,ymm4</code>}}
| {{nowrap|<code>XOP.8 A2 /r /is4</code>}}
| {{yes}} || {{yes}}
|-
! colspan=6 |
|-
| rowspan=8 | Vector integer compare.

For each vector-register lane, compare src1 to src2, then set destination to all-1s if the comparison passes, all-0s if it fails. The imm8 argument specifies comparison function to perform:
* 0: LT (less-than)
* 1: LE (less-than-or-equal)
* 2: GT (greater-than)
* 3: GE (greater-than-or-equal)
* 4: EQ (equal)
* 5: NE (not-equal)
* 6: FALSE (always-false)
* 7: TRUE (always-true)
| Signed 8-bit lanes
| <code>VPCOMB xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias|text=For each <code>VPCOM*</code> instruction, a series of alias mnemonics are available for the instruction, one for each of the eight comparison functions encodable in the imm8 argument. These alias mnemonics specify the comparison to perform after the "VPCOM" part of the mnemonic. For example:<ul><li>{{nowrap|<code>VPCOM<b>EQ</b>B xmm1,xmm2,xmm3</code>}} is an alias for {{nowrap|<code>VPCOMB xmm1,xmm2,xmm3,4</code>}}<li>{{nowrap|<code>VPCOM<b>FALSE</b>UQ xmm1,xmm2,[ebx]</code>}} is an alias for {{nowrap|<code>VPCOMUQ xmm1,xmm2,[ebx],6</code>}}</ul>}}
| <code>XOP.8 CC /r ib</code>
| rowspan=8 {{no}}
| rowspan=8 {{no}}
|-
| Signed 16-bit lanes
| <code>VPCOMW xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 CD /r ib</code>
|-
| Signed 32-bit lanes
| <code>VPCOMD xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 CE /r ib</code>
|-
| Signed 64-bit lanes
| <code>VPCOMQ xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 CF /r ib</code>
|-
| Unsigned 8-bit lanes
| <code>VPCOMUB xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 EC /r ib</code>
|-
| Unsigned 16-bit lanes
| {{nowrap|<code>VPCOMUW xmm1,xmm2,xmm3/m128,imm8</code>}}{{efn|name=vpcom_alias}}
| <code>XOP.8 ED /r ib</code>
|-
| Unsigned 32-bit lanes
| <code>VPCOMUD xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 EE /r ib</code>
|-
| Unsigned 64-bit lanes
| <code>VPCOMUQ xmm1,xmm2,xmm3/m128,imm8</code>{{efn|name=vpcom_alias}}
| <code>XOP.8 EF /r ib</code>
|-
! colspan=6 |
|-
| rowspan=12 | Vector Integer Horizontal Add.

For each N-bit lane, split the lane into a series of M-bit lanes, add the M-bit lanes together, then store the result into the destination as an N-bit zero/sign-extended value.
| 2x8bit -> 16bit, signed
| <code>VPHADDBW xmm1,xmm2/m128</code>
| <code>XOP.9 C1 /r</code>
| rowspan=12 {{no}}
| rowspan=12 {{no}}
|-
| 4x8bit -> 32bit, signed
| <code>VPHADDBD xmm1,xmm2/m128</code>
| <code>XOP.9 C2 /r</code>
|-
| 8x8bit -> 64bit, signed
| <code>VPHADDBQ xmm1,xmm2/m128</code>
| <code>XOP.9 C3 /r</code>
|-
| 2x16bit -> 32bit, signed
| <code>VPHADDWD xmm1,xmm2/m128</code>
| <code>XOP.9 C6 /r</code>
|-
| 4x16bit -> 64bit, signed
| <code>VPHADDWQ xmm1,xmm2/m128</code>
| <code>XOP.9 C7 /r</code>
|-
| 2x32bit -> 64bit, signed
| <code>VPHADDDQ xmm1,xmm2/m128</code>
| <code>XOP.9 CB /r</code>
|-
| 2x8bit -> 16bit, unsigned
| <code>VPHADDUBW xmm1,xmm2/m128</code>
| <code>XOP.9 D1 /r</code>
|-
| 4x8bit -> 32bit, unsigned
| <code>VPHADDUBD xmm1,xmm2/m128</code>
| <code>XOP.9 D2 /r</code>
|-
| 8x8bit -> 64bit, unsigned
| <code>VPHADDUBQ xmm1,xmm2/m128</code>
| <code>XOP.9 D3 /r</code>
|-
| 2x16bit -> 32bit, unsigned
| <code>VPHADDUWD xmm1,xmm2/m128</code>
| <code>XOP.9 D6 /r</code>
|-
| 4x16bit -> 64bit, unsigned<!-- version 3.04 of AMD 43479 has wrong figure here-->
| <code>VPHADDUWQ xmm1,xmm2/m128</code>
| <code>XOP.9 D7 /r</code>
|-
| {{nowrap|2x32bit -> 64bit, unsigned}}
| <code>VPHADDUDQ xmm1,xmm2/m128</code>
| <code>XOP.9 DB /r</code>
|-
! colspan=6 |
|-
| rowspan=3 | Vector Integer Horizontal Subtract.

For each N-bit lane, split the lane into two signed sub-lanes of N/2 bits each, then subtract the upper lane from the lower lane, then store the result as a signed N-bit result.
| 2x8bit -> 16bit
| <code>VPHSUBBW xmm1,xmm2/m128</code>
| <code>XOP.9 E1 /r</code>
| rowspan=3 {{no}}
| rowspan=3 {{no}}
|-
| 2x16bit -> 32bit
| <code>VPHSUBWD xmm1,xmm2/m128</code>
| <code>XOP.9 E2 /r</code>
|-
| 2x32bit -> 64bit
| <code>VPHSUBDQ xmm1,xmm2/m128</code>
| <code>XOP.9 E3 /r</code>
|-
! colspan=6 |
|-
| rowspan=10 | Vector Signed Integer Multiply-Add.

For each N-bit lane, perform <code>dest <- src1*src2 + src3</code>

For src1 and src2, the factors to multiply may be taken as signed values from the low half of each lane, high half of each lane or the lane in full (picked in the same way for src1 and src2) − the addend and the result use the full lane.
| 16-bit, full-lane
| <code>VPMACSWW xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 95 /r /is4</code>
| rowspan=10 {{no}}
| rowspan=10 {{no}}
|-
| 32-bit, low-half<!-- AMD documentation describes this as "odd-numbered", but figures in v3.04 of AMD 43479 clearly show that the low half is used. Newer documentation, such as v4.07 of 40332, omits the figure, making the text ambiguous − it is not clear from context whether they do 0-based or 1-based counting of lanes-->
| <code>VPMACSWD xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 96 /r /is4</code>
|-
| 64-bit, low-half
| <code>VPMACSDQL xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 97 /r /is4</code>
|-
| 32-bit, full-lane
| <code>VPMACSDD xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 9E /r /is4</code>
|-
| 64-bit, high-half
| <code>VPMACSDQH xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 9F /r /is4</code>
|-
| 16-bit, full-lane, saturating
| <code>VPMACSSWW xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 85 /r /is4</code>
|-
| 32-bit, low-half, saturating
| <code>VPMACSSWD xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 86 /r /is4</code>
|-
| 64-bit, low-half, saturating
| <code>VPMACSSDQL xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 87 /r /is4</code>
|-
| 32-bit, full-lane, saturating
| <code>VPMACSSDD xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 8E /r /is4</code>
|-
| {{nowrap|64-bit, high-half, saturating}}
| {{nowrap|<code>VPMACSSDQH xmm1,xmm2,xmm3/m128,xmm4</code>}}
| <code>XOP.8 8F /r /is4</code>
|-
! colspan=6 |
|-
| rowspan=2 | Packed multiply, add and accumulate signed word to signed doubleword.

For each 32-bit lane, treat src1 and src2 as 2-component vectors of signed 16-bit values, then compute their dot-product, then add src3 as a 32-bit value.
| with saturation
| {{nowrap|<code>VPMADCSSWD xmm1,xmm2,xmm3/m128,xmm4</code>}}
| <code>XOP.8 A6 /r /is4</code>
| rowspan=2 {{no}}
| rowspan=2 {{no}}
|-
| without saturation
| <code>VPMADCSWD xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 B6 /r /is4</code>
|-
! colspan=6 |
|-
| colspan=2 | Packed Permute Bytes.

For <code>VPPERM dst,src1,src2,src3</code>, src2:src1 are considered a 32-element vector of bytes. For each byte-lane, the byte in src3 is used to index into this 32-byte vector and transform the element:
* bits 4:0 is used to pick one of the 32 bytes.
* bits 7:6 specify a transform to perform on the byte (0=keep, 1=bitreverse, 2=set-to-zero, 3=replicate-MSB)
* bit 5, if set, inverts the result after the transform.
| <code>VPPERM xmm1,xmm2,xmm3/m128,xmm4</code>
| <code>XOP.8 A3 /r /is4</code>
| {{yes}} || {{no}}
|-
! colspan=6 |
|-
| rowspan=8 | Packed left-rotate.

Rotation amount is given in the last source argument. It may be provided as an immediate or a vector register − in the latter case, the rotation amount is provided on a per-lane basis.
| rowspan=2 | 8-bit lanes
| <code>VPROTB xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 90 /r</code>
| {{yes}}
| rowspan=8 {{no}}
|-
| <code>VPROTB xmm1,xmm2/m128,imm8</code>
| <code>XOP.8 C0 /r ib</code>
| {{no}}
|-
| rowspan=2 | 16-bit lanes
| <code>VPROTW xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 91 /r</code>
| {{yes}}
|-
| <code>VPROTW xmm1,xmm2/m128,imm8</code>
| <code>XOP.8 C1 /r ib</code>
| {{no}}
|-
| rowspan=2 | 32-bit lanes
| <code>VPROTD xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 92 /r</code>
| {{yes}}
|-
| <code>VPROTD xmm1,xmm2/m128,imm8</code>
| <code>XOP.8 C2 /r ib</code>
| {{no}}
|-
| rowspan=2 | 64-bit lanes
| <code>VPROTQ xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 93 /r</code>
| {{yes}}
|-
| <code>VPROTQ xmm1,xmm2/m128,imm8</code>
| <code>XOP.8 C3 /r ib</code>
| {{no}}
|-
! colspan=6 |
|-
| rowspan=8 | Packed shift, with signed shift-amounts.

Shift-amount is provided on a per-vector-lane basis, and is taken from the bottom 8 bits of each lane of the last source argument. The shift-amount is considered signed − a positive value will cause left-shift, while a negative value causes right-shift.
| 8-bit, signed
| <code>VPSHAB xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 98 /r</code>
| rowspan=8 {{yes}}
| rowspan=8 {{no}}
|-
| 16-bit, signed
| <code>VPSHAW xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 99 /r</code>
|-
| 32-bit, signed
| <code>VPSHAD xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 9A /r</code>
|-
| 64-bit, signed
| <code>VPSHAQ xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 9B /r</code>
|-
| 8-bit, unsigned
| <code>VPSHLB xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 94 /r</code>
|-
| 16-bit, unsigned
| <code>VPSHLW xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 95 /r</code>
|-
| 32-bit, unsigned
| <code>VPSHLD xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 96 /r</code>
|-
| 64-bit, unsigned
| <code>VPSHLQ xmm1,xmm2/m128,xmm3</code>
| <code>XOP.9 97 /r</code>
|}
{{notelist}}
{{vpad}}
XOP also included two vector instructions that used the VEX prefix instead of the XOP prefix:
{| class="wikitable"
|-
! Instruction description
! Instruction mnemonics
! Opcode
! W=1<br />swap<br />allowed
! L=1<br />(256b)<br />allowed
|-
| Permute two-source double-precision floating-point values.
| <code>VPERMIL2PD ymm1,ymm2,ymm3/m256,ymm4,imm4</code>
| <code>VEX.NP.0F3A 49 /r /is4</code>
| {{yes}} || {{yes}}
|-
| Permute two-source single-precision floating-point values.
| <code>VPERMIL2PS ymm1,ymm2,ymm3/m256,ymm4,imm4</code>
| <code>VEX.NP.0F3A 48 /r /is4</code>
| {{yes}} || {{yes}}
|}
The instructions <code>VPERMIL2PD</code> and <code>VPERMIL2PS</code> were originally defined by Intel in early drafts of the AVX specification<ref>Intel, [https://web.archive.org/web/20110807135414/http://software.intel.com/file/17976/ Advanced Vector Extensions Programming Reference], order no. 319433-002, March 2008 - contains specifications of <code>VPERMIL2PD</code> and <code>VPERMIL2PS</code> on pages 411 and 420, as well as FMA4 instructions on pages 612 to 660. Archived from the [http://software.intel.com/file/17976/ original] on 7 Aug 2011.</ref> − they were removed in later drafts<ref>Intel, [https://kib.kiev.ua/x86docs/Intel/ISAFuture/319433-004.pdf Advanced Vector Extensions Programming Reference], order no. 319433-004, December 2008 − does not contain specifications of <code>VPERMIL2PD</code> and <code>VPERMIL2PS</code> and has FMA3 instead of FMA4. [https://web.archive.org/web/20230924090048/https://kib.kiev.ua/x86docs/Intel/ISAFuture/319433-004.pdf Archived] on Sep 24, 2023.</ref><ref>Intel Software Network, [https://web.archive.org/web/20090202000953/http://software.intel.com/en-us/blogs/2009/01/29/recent-intelr-avx-architectural-changes/  Recent Intel(R) AVX Architectural Changes], 29 Jan 2009. Archived from the [http://software.intel.com/en-us/blogs/2009/01/29/recent-intelr-avx-architectural-changes/ original] on 2 Feb 2009.</ref> and were never implemented in any Intel processor. They were, however, implemented by AMD, who designated them as being a part of the XOP instruction set extension. (Like the other parts of XOP, they've been removed in [[AMD Zen]].)
{{vpad}}

==== [[FMA instruction set|FMA4]] instructions ====
Supported in AMD processors starting with the [[Bulldozer (microarchitecture)|Bulldozer]] architecture, removed in [[Zen (microarchitecture)|Zen]]. Not supported by any Intel chip as of 2023.

[[Fused multiply-add]] with four operands. FMA4 was realized in hardware before FMA3.

{| class="wikitable"
! Instruction !! Opcode !! Meaning !! Notes
|-
| VFMADDPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 69 /r /is4 || Fused Multiply-Add of Packed Double-Precision Floating-Point Values ||
|-
| VFMADDPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 68 /r /is4 || Fused Multiply-Add of Packed Single-Precision Floating-Point Values ||
|-
| VFMADDSD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6B /r /is4 || Fused Multiply-Add of Scalar Double-Precision Floating-Point Values ||
|-
| VFMADDSS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6A /r /is4 || Fused Multiply-Add of Scalar Single-Precision Floating-Point Values ||
|-
| VFMADDSUBPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 5D /r /is4 || Fused Multiply-Alternating Add/Subtract of Packed Double-Precision Floating-Point Values ||
|-
| VFMADDSUBPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 5C /r /is4 || Fused Multiply-Alternating Add/Subtract of Packed Single-Precision Floating-Point Values ||
|-
| VFMSUBADDPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 5F /r /is4 || Fused Multiply-Alternating Subtract/Add of Packed Double-Precision Floating-Point Values ||
|-
| VFMSUBADDPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 5E /r /is4 || Fused Multiply-Alternating Subtract/Add of Packed Single-Precision Floating-Point Values ||
|-
| VFMSUBPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6D /r /is4 || Fused Multiply-Subtract of Packed Double-Precision Floating-Point Values ||
|-
| VFMSUBPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6C /r /is4 || Fused Multiply-Subtract of Packed Single-Precision Floating-Point Values ||
|-
| VFMSUBSD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6F /r /is4 || Fused Multiply-Subtract of Scalar Double-Precision Floating-Point Values ||
|-
| VFMSUBSS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 6E /r /is4 || Fused Multiply-Subtract of Scalar Single-Precision Floating-Point Values ||
|-
| VFNMADDPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 79 /r /is4 || Fused Negative Multiply-Add of Packed Double-Precision Floating-Point Values ||
|-
| VFNMADDPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 78 /r /is4 || Fused Negative Multiply-Add of Packed Single-Precision Floating-Point Values ||
|-
| VFNMADDSD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7B /r /is4 || Fused Negative Multiply-Add of Scalar Double-Precision Floating-Point Values ||
|-
| VFNMADDSS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7A /r /is4 || Fused Negative Multiply-Add of Scalar Single-Precision Floating-Point Values ||
|-
| VFNMSUBPD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7D /r /is4 || Fused Negative Multiply-Subtract of Packed Double-Precision Floating-Point Values ||
|-
| VFNMSUBPS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7C /r /is4 || Fused Negative Multiply-Subtract of Packed Single-Precision Floating-Point Values ||
|-
| VFNMSUBSD xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7F /r /is4 || Fused Negative Multiply-Subtract of Scalar Double-Precision Floating-Point Values ||
|-
| VFNMSUBSS xmm0, xmm1, xmm2, xmm3 || C4E3 WvvvvL01 7E /r /is4 || Fused Negative Multiply-Subtract of Scalar Single-Precision Floating-Point Values ||
|}

=== [[Bit Manipulation Instruction Sets#TBM .28Trailing Bit Manipulation.29|Trailing Bit Manipulation Instructions]] ===

AMD introduced TBM together with BMI1 in its [[Piledriver (processor)|Piledriver]]<ref name=piledriver-ins>{{cite web|last1=Hollingsworth|first1=Brent|title=New "Bulldozer" and "Piledriver" instructions|url=http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/New-Bulldozer-and-Piledriver-Instructions.pdf|publisher=Advanced Micro Devices, Inc.|access-date=11 December 2014|archive-url=https://web.archive.org/web/20140726174733/http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/New-Bulldozer-and-Piledriver-Instructions.pdf|archive-date=26 Jul 2014}}</ref> line of processors; later AMD Jaguar and Zen-based processors do not support TBM.<ref name=fam16hsheet>{{cite web |url=http://support.amd.com/TechDocs/52169_KB_A_Series_Mobile.pdf |title=Family 16h AMD A-Series Data Sheet |date=October 2013 |access-date=2014-01-02 |publisher=[[AMD]] |work=amd.com |archive-url=https://web.archive.org/web/20131107153414/http://support.amd.com/TechDocs/52169_KB_A_Series_Mobile.pdf |archive-date=7 Nov 2013}}</ref>  No Intel processors (as of 2023) support TBM.

The TBM instructions are all encoded using the XOP prefix. They are all available in 32-bit and 64-bit forms, selected with the XOP.W bit (0=32bit, 1=64bit). (XOP.W is ignored outside 64-bit mode.) Like all instructions encoded with VEX/XOP prefixes, they are unavailable in Real Mode and Virtual-8086 mode.

{| class="wikitable"
|-
! Instruction
! Opcode
! Description<ref name=amd64apiv3>{{cite web|url=http://support.amd.com/TechDocs/24594.pdf|title=AMD64 Architecture Programmer's Manual, Volume 3: General-Purpose and System Instructions|date=October 2013 |access-date=2014-01-02 |publisher=[[AMD]] |work=amd.com |archive-url=https://web.archive.org/web/20140104003442/http://support.amd.com/TechDocs/24594.pdf |archive-date=4 Jan 2014}}</ref>
! Equivalent C expression<ref>{{cite web|url=https://gcc.gnu.org/viewcvs/gcc/branches/gcc-4_8-branch/gcc/config/i386/tbmintrin.h?revision=196696&view=markup|title=tbmintrin.h from GCC 4.8|access-date=2014-03-17|archive-url=https://web.archive.org/web/20170223034217/https://gcc.gnu.org/viewcvs/gcc/branches/gcc-4_8-branch/gcc/config/i386/tbmintrin.h?revision=196696&view=markup|archive-date=23 Feb 2017}}</ref>
|-
| <code>BEXTR reg,r/m,imm32</code>
| <code>XOP.A 10 /r imm32</code>
| Bit field extract (immediate form){{efn|text=For <code>BEXTR</code>, a register form is available as part of BMI1.}}

The imm32 is interpreted as follows:
* Bit 7:0 : start position
* Bit 15:8 : length
* Bit 31:16 : ignored
|  <code>(src >> start) & ((1 << len) − 1)</code>
|-
| <code>BLCFILL reg,r/m</code>
| <code>XOP.9 01 /1</code>
| Fill from lowest clear bit
| <code>x & (x + 1)</code>
|-
| <code>BLCI reg,r/m</code>
| <code>XOP.9 02 /6</code>
| Isolate lowest clear bit
| <code>x &#124; ~(x + 1)</code>
|-
| <code>BLCIC reg,r/m</code>
| <code>XOP.9 01 /5</code>
| Isolate lowest clear bit and complement
| <code>~x & (x + 1)</code>
|-
| <code>BLCMSK reg,r/m</code>
| <code>XOP.9 02 /1</code>
| Mask from lowest clear bit
| <code>x ^ (x + 1)</code>
|-
| <code>BLCS reg,r/m</code>
| <code>XOP.9 01 /3</code>
| Set lowest clear bit
| <code>x &#124; (x + 1)</code>
|-
| <code>BLSFILL reg,r/m</code>
| <code>XOP.9 01 /2</code>
| Fill from lowest set bit
| <code>x &#124; (x − 1)</code>
|-
| <code>BLSIC reg,r/m</code>
| <code>XOP.9 01 /6</code>
| Isolate lowest set bit and complement
| <code>~x &#124; (x − 1)</code>
|-
| <code>T1MSKC reg,r/m</code>
| <code>XOP.9 01 /7</code>
| Inverse mask from trailing ones
| <code>~x &#124; (x + 1)</code>
|-
| <code>TZMSK reg,r/m</code>
| <code>XOP.9 01 /4</code>
| Mask from trailing zeros
| <code>~x & (x − 1)</code>
|}
{{notelist}}
{{vpad}}

=== Lightweight Profiling instructions ===

The AMD Lightweight Profiling (LWP) feature was introduced in AMD [[Bulldozer (microarchitecture)|Bulldozer]] and removed in [[AMD Zen]].<!-- The Zen2-based "Desktop Kit 4700S" processor has the CPUID bits for LWP set − this appears to be the only Zen processor with LWP--> On all supported CPUs, the latest available microcode updates have disabled LWP due to [[Spectre (security vulnerability)|Spectre]] mitigations.<ref>Xen-devel mailing list, [https://lore.kernel.org/all/1558347216-19179-1-git-send-email-andrew.cooper3@citrix.com/ x86/svm: Drop support for AMD's Lightweight Profiling], 20 May 2019</ref>

These instructions are available in Ring 3, but not available in Real Mode and Virtual-8086 mode. All of them use the XOP prefix.

{| class="wikitable"
|-
! Instruction
! Opcode
! Description
|-
| <code>LLWPCB r32/64</code>
| <code>XOP.9 12 /0</code>
| Load LWPCB (Lightweight Profiling Control Block) address.{{efn|name=lwpcb_addr|text=The address used by <code>LLWPCB</code> and <code>SLWPCB</code> is an effective-address, specified relative to the DS: segment base address. <code>LLWPCB</code> converts this effective-address to a linear-address by adding the DS base address to it,<!-- AMD documentation does not specify whether segment-override prefixes affect the operation of LLWPCB and SLWPCB --> and <code>SLWPCB</code> converts it back by subtracting the DS base address. Changing the DS base address while LWP is enabled will thereby cause <code>SLWPCB</code> to return a different address than what was specified to <code>LLWPCB</code>, and may also cause <code>XSAVE</code> to fail to save LWP state properly.}}

Loading an address of 0 disables LWP. Loading a nonzero address will cause the CPU to perform validation of the specified LWPCB, then enable LWP if the validation passed. If LWP was already enabled, state for the previous LWPCB is flushed to memory.
|-
| <code>SLWPCB r32/64</code>
| <code>XOP.9 12 /1</code>
| Store LWPCB address{{efn|name=lwpcb_addr}} to register, and flush LWP state to memory.

If LWP is not enabled, the stored address is 0.
|-
| {{nowrap|<code>LWPINS r32/64, r/m32, imm32</code>}}
| {{nowrap|<code>XOP.A 12 /0 imm32</code>}}
| Insert user event record with EventID=255 in LWP ring buffer. The arguments are inserted into the event record as follows:
* The first argument is stored in bytes 23:16 (zero-extended if 32-bit)
* The second argument is stored in bytes 7:4
* The low 16 bits of the imm32 are stored in bytes 3:2 (the high 16 bits are ignored)

The <code>LWPINS</code> instruction sets CF=1 if LWP is enabled and the ring buffer is full, CF=0 otherwise.
|-
| {{nowrap|<code>LWPVAL r32/64, r/m32, imm32</code>}}
| {{nowrap|<code>XOP.A 12 /1 imm32</code>}}
| Decrement the event counter associated with the programmed value sample event. If the resulting counter value ends up negative, insert an event record with EventID=1 in LWP ring buffer. (The instruction arguments are inserted in this record in the same way as for <code>LWPINS</code>.)

Executes as NOP if LWP is not enabled or if the event counter is not enabled. If no event record is inserted, then the second argument (which may be a memory argument) is not accessed.
|}
{{notelist}}
{{vpad}}

== Instructions from other vendors ==

=== Instructions specific to [[NEC V20|NEC V-series]] processors ===
These instructions are specific to the NEC V20/V30 CPUs and their successors, and do not appear in any non-NEC CPUs. Many of their opcodes have been reassigned to other instructions in later non-NEC CPUs.
{| class="wikitable"
! Instruction
! Opcode
! Description
! Available on
|-
! colspan="4" |
|-
| <code>TEST1 r/m8, CL</code><br/><code>TEST1 r/m16, CL</code>
| <code>0F 10 /0</code><br/><code>0F 11 /0</code>
| rowspan="2" | Test one bit.
First argument specifies an 8/16-bit register or memory location.

Second argument specifies which bit to test.
| rowspan="20" | All V-series<ref name="nec-16bit">NEC, [https://www.ardent-tool.com/CPU/docs/NEC/V20-V30/v_series.pdf 16-bit V-series User's Manual], sep 2000. [https://web.archive.org/web/20211202213532/https://www.ardent-tool.com/CPU/docs/NEC/V20-V30/v_series.pdf Archived] on Dec 2, 2021.</ref> except V30MZ<ref>NEC, [https://www.ardent-tool.com/CPU/docs/NEC/V20-V30/v30mz.pdf V30MZ Preliminary User's Manual], 1998, page 14. [https://web.archive.org/web/20211202212740/https://www.ardent-tool.com/CPU/docs/NEC/V20-V30/v30mz.pdf Archived] on Dec 2, 2021.</ref>
|-
| <code>TEST1 r/m8, imm8</code><br/><code>TEST1 r/m16, imm8</code>
| <code>0F 18 /0 ib</code><br/><code>0F 19 /0 ib</code>
|-
| <code>CLR1 r/m8, CL</code><br/><code>CLR1 r/m16, CL</code>
| <code>0F 12 /0</code><br/><code>0F 13 /0</code>
| rowspan="2" | Clear one bit.
|-
| <code>CLR1 r/m8, imm8</code><br/><code>CLR1 r/m16, imm8</code>
| <code>0F 1A /0 ib</code><br/><code>0F 1B /0 ib</code>
|-
| <code>SET1 r/m8, CL</code><br/><code>SET1 r/m16, CL</code>
| <code>0F 14 /0</code><br/><code>0F 15 /0</code>
| rowspan="2" | Set one bit.
|-
| <code>SET1 r/m8, imm8</code><br/><code>SET1 r/m16, imm8</code>
| <code>0F 1C /0 ib</code><br/><code>0F 1D /0 ib</code>
|-
| <code>NOT1 r/m8, CL</code><br/><code>NOT1 r/m16, CL</code>
| <code>0F 16 /0</code><br/><code>0F 17 /0</code>
| rowspan="2" | Invert one bit.
|-
| <code>NOT1 r/m8, imm8</code><br/><code>NOT1 r/m16, imm8</code>
| <code>0F 1E /0 ib</code><br/><code>0F 1F /0 ib</code>
|-
| <code>ADD4S</code>
| <code>0F 20</code>
| Add Nibble Strings.
Performs a string addition of integers in packed BCD format (2 BCD digits per byte). DS:SI points to a source integer, ES:DI to a destination integer, and CL provides the number of digits to add. The operation is then:

destination <- destination + source
|-
| <code>SUB4S</code>
| <code>0F 22</code>
| Subtract Nibble Strings.
destination <- destination − source
|-
| <code>CMP4S</code>
| <code>0F 26</code>
| Compare Nibble Strings.
|-
| <code>ROL4 r/m8</code>
| <code>0F 28 /0</code>
| Rotate Left Nibble.
Concatenates its 8-bit argument with the bottom 4 bits of AL to form a 12-bit bitvector, then left-rotates this bitvector by 4 bits, then writes this bitvector back to its argument and the bottom 4 bits of AL.
|-
| <code>ROR4 r/m8</code>
| <code>0F 2A /0</code>
| Rotate Right Nibble. Similar to <code>ROL4</code>, except performs a right-rotate by 4 bits.
|-
| <code>EXT r8,r8</code>
| <code>0F 33 /r</code>
| rowspan="2" | Bitfield extract.
Perform a bitfield read from memory. DS:SI (DS0:IX in NEC nomenclature) points to memory location to read from, first argument specifies bit-offset to read from, and second argument specifies the number of bits to read minus 1. The result is placed in AX. After the bitfield read, SI and the first argument are updated to point just beyond the just-read bitfield.
|-
| <code>EXT r8,imm8</code>
| <code>0F 3B /0 ib</code>
|-
| <code>INS r8,r8</code>
| <code>0F 31 /r</code>
| rowspan="2" | Bitfield Insert.
Perform a bitfield write to memory. ES:DI (DS1:IY in NEC nomenclature) points to memory location to write to, AX contains data to write, first argument specifies bit-offset to write to, and second argument specifies the number of bits to write minus 1. After the bitfield write, DI and the first argument are updated to point just beyond the just-written bitfield.
|-
| <code>INS r8,imm8</code>
| <code>0F 39 /0 ib</code>
|-
| <code>REPC</code>
| <code>64</code>
| Repeat if carry. Instruction prefix for use with <code>CMPS</code>/<code>SCAS</code>.
|-
| <code>REPNC</code>
| <code>65</code>
| Repeat if not carry. Instruction prefix for use with <code>CMPS</code>/<code>SCAS</code>.
|-
| <code>FPO2</code>
| <code>66 /r</code><br/><code>67 /r</code>
| "Floating Point Operation 2": extra escape opcodes for floating-point coprocessor, in addition to the standard <code>D8-DF</code> ones used for [[x87]].

The FPO2 escape opcodes are used by the NEC 72291 floating-point coprocessor - this coprocessor also uses the standard <code>D8-DF</code> escape opcodes, but uses them to encode an instruction set that is unique to the 72291 and not compatible with x87. A listing of the opcodes/instructions supported by the 72291 is available.<ref>NEC 72291 FPU: an instruction listing can be found in the [http://bitsavers.trailing-edge.com/pdf/hp/64700/software_toolchain/64873-97007-V-Series_Cross-Assembler_Jun91.pdf HP 64873 V-series Cross Assembler Reference], pages F-31 to F-34.</ref>
|-
! colspan="4" |
|-
| <code>BRKEM imm8</code>
| <code>0F FF ib</code>
| Break to [[Intel 8080|8080]] emulation mode.
Jump to an address picked from the IVT (Interrupt Vector Table) using the imm8 argument, similar to the 8086 <code>INT</code> instruction, but start executing as [[Intel 8080]] code rather than x86 code.
| V20, V30, V40, V50<ref name="nec-16bit" />
|-
! colspan="4" |
|-
| <code>BRKXA imm8</code>
| <code>0F E0 ib</code>
| Break to Extended Address Mode.
Jump to an address picked from the IVT using the imm8 argument. Enables a simple memory paging mechanism after reading the IVT but before executing the jump.
The paging mechanism uses an on-chip page table with 16Kbyte pages and no access rights checking.<ref>[http://www.bitsavers.org/components/nec/_dataBooks/1991_16_bit_V-Series_Microprocessor_Data_Book.pdf NEC 16-bit V-series Microprocessor Data Book, 1991], p. 360-361</ref> 
| rowspan="2" | V33, V53<ref name="nec-16bit" />
|-
| <code>RETXA imm8</code>
| <code>0F F0 ib</code>
| Return from Extended Address Mode.
Jump to an address picked from the IVT using the imm8 argument. Disables paging after reading the IVT but before executing the jump.
|-
! colspan="4" |
|-
| <code>MOVSPA</code>
| <code>0F 25</code>
| Transfer both SS and SP of old register bank after the bank has been switched by an interrupt or <code>BRKCS</code> instruction.
| rowspan="8" | V25, V35,<ref>[https://www.verical.com/datasheet/renesas-technology-microcontroller-upd70320gj-8-5bg-4484185.pdf Renesas Data Sheet MOS Integrated Circuit uPD70320]. [https://web.archive.org/web/20220106140726/https://www.verical.com/datasheet/renesas-technology-microcontroller-upd70320gj-8-5bg-4484185.pdf Archived] on Jan 6, 2022.</ref> V55<ref name="nec-v55pi-db" />
|-
| <code>BRKCS r16</code>
| <code>0F 2D /0</code>
| Perform software interrupt with context switch to register bank specified by low 3 bits of r16.
|-
| <code>RETRBI</code>
| <code>0F 91</code>
| Return from register bank context switch interrupt.
|-
| <code>FINT</code>
| <code>0F 92</code>
| Finish Interrupt.
|-
| <code>TSKSW r16</code>
| <code>0F 94 /7</code>
| Perform task switch to register bank indicated by low 3 bits of r16.
|-
| <code>MOVSPB r16</code>
| <code>0F 95 /7</code>
| Transfer SS and SP of current register bank to register bank indicated by low 3 bits of r16.
|-
| {{nowrap|<code>BTCLR imm8,imm8,cb</code>}}
| {{nowrap|<code>0F 9C ib ib rel8</code>}}
| Bit Test and Clear.
The first argument specifies a V25/V35 Special Function Register to test a bit in. The second argument specifies a bit position in that register. The third argument specifies a short branch offset. If the bit was set to 1, then it is cleared and a short branch is taken, else the branch is not taken.
|-
| <code>STOP</code>
| <code>0F 9E</code>
| CPU Halt.

Differs from the conventional 8086 <code>HLT</code> instruction in that the clock is stopped too, so that an NMI or CPU reset is needed to resume operation.
|-
! colspan="4" |
|-
| <code>BRKS imm8</code>
| <code>F1 ib</code>
| Break and Enable Software Guard.
Jump to an address picked from the IVT using the imm8 argument, and then continue execution with "Software Guard" enabled. The "Software Guard" is an 8-bit [[Substitution cipher]] that, during instruction fetch/decode, translates opcode bytes using a 256-entry lookup table stored in an on-chip [[Read-only memory#Factory programmed|Mask ROM]].
| rowspan="2" | V25, V35 "Software Guard"<ref>[http://www.bitsavers.org/components/nec/_dataBooks/1991_16_bit_V-Series_Microprocessor_Data_Book.pdf NEC 16-bit V-series Microprocessor Data Book, 1991], p. 765-766</ref>
|-
| <code>BRKN imm8</code>
| <code>63 ib</code>
| Break and Enable Native Mode. Similar to <code>BRKS</code>, excepts disables "Software Guard" rather than enabling it.
|-
! colspan="4" |
|-
| <code>MOV r/m,DS3</code>
| <code>8C /6</code>
| rowspan="8" | Move to/from the DS2 and DS3 extended segment registers.

The DS2 and DS3 registers (which are specific to the NEC V55) act similar to regular x86 [[real mode]] segment registers except that they are left-shifted by 8 rather than 4, enabling access to 16MB of memory. Block transfer instructions, such as MOVBKW, can access the 16MB memory space by simultaneously prefixing with DS2 and DS3.<ref>{{Cite web |url=https://www.renesas.com/us/en/document/dst/upd70433-data-sheet#page=23 |title=V55PI 16-BIT MICROPROCESSOR |pages=21–22 |access-date=2024-01-18}}</ref>
| rowspan="19" | V55<ref name="nec-v55pi-db">Renesas, [https://www.renesas.com/us/en/document/dst/upd70433-data-sheet NEC V55PI 16-bit microprocessor Data Sheet, U11775E]. [https://web.archive.org/web/20230727193709/https://www.renesas.com/us/en/document/dst/upd70433-data-sheet Archived] on Jul 27, 2023.</ref>
|-
| <code>MOV r/m,DS2</code>
| <code>8C /7</code>
|-
| <code>MOV DS3,r/m</code>
| <code>8E /6</code>
|-
| <code>MOV DS2,r/m</code>
| <code>8E /7</code>
|-
| <code>PUSH DS3</code>
| <code>0F 76</code><ref>Renesas, [https://www.renesas.com/us/ja/document/man/709891 NEC V55PI Users Manual Instruction, U10231J (Japanese)]. Opcodes for {{nowrap|<code>PUSH/POP DS2/DS3</code>}} listed in macro definitions on p. 378. [https://web.archive.org/web/20221211131644/https://www.renesas.com/us/ja/document/man/709891 Archived] on Dec 11, 2022.</ref>
|-
| <code>POP DS3</code>
| <code>0F 77</code>
|-
| <code>PUSH DS2</code>
| <code>0F 7E</code>
|-
| <code>POP DS2</code>
| <code>0F 7F</code>
|-
| {{nowrap|<code>MOV DS3,r16,m32</code>}}
| <code>0F 36 /r</code>
| rowspan="2" | Instructions to load both extended segment register and general-purpose register at once, similar to 8086's <code>LDS</code> and <code>LES</code> instructions
|-
| {{nowrap|<code>MOV DS2,r16,m32</code>}}
| <code>0F 3E /r</code>
|-
| <code>DS2:</code>
| <code>63</code>
| rowspan="2" | Segment-override prefixes for the DS2 and DS3 extended segments.
|-
| <code>DS3:</code>
| <code>D6</code>
|-
| <code>IRAM:</code>
| <code>F1</code>
| Register File Override Prefix. Will cause memory operands to index into register file rather than general memory.
|-
| <code>BSCH r/m8</code><br/><code>BSCH r/m16</code>
| <code>0F 3C /0</code><br/><code>0F 3D /0</code>
| Count Trailing Zeroes and store result in CL. Sets ZF=1 for all-0s input.
|-
| {{nowrap|<code>RSTWDT imm8,imm8</code>}}
| <code>0F 96 ib ib</code>
| Watchdog Timer Manipulation Instruction.
|-
| {{nowrap|<code>BTCLRL imm8,imm8,cb</code>}}
| {{nowrap|<code>0F 9D ib ib rel8</code>}}
| Bit test and clear for second bank of special purpose registers (similar to <code>BTCLR</code>).
|-
| <code>QHOUT imm16</code>
| <code>0F E0 iw</code>
| rowspan="3" | Queue manipulation instructions.
|-
| <code>QOUT imm16</code>
| <code>0F E1 iw</code>
|-
| <code>QTIN imm16</code>
| <code>0F E2 iw</code>
|-
! colspan="4" |
|-
| <code>IDLE</code>
| <code>0F 9F</code>
| Put CPU in idle mode.
| V55SC<ref name="nec-v55sc-db">NEC V55SC 16-bit Microprocessor Preliminary Data Sheet (O.D.No ID-8206A, March 1993), pages 70 and 127. Located on Apr 20, 2022 by searching for [https://www.datasheetarchive.com/?q=nec+v55sc "nec v55sc"] at datasheetarchive.com. [https://web.archive.org/web/20221125133950/https://datasheet.datasheetarchive.com/originals/scans/Scans-054/DSAIH000102047.pdf Archived] on Nov 22, 2022.</ref>
|-
! colspan="4" |
|-
| <code>ALBIT</code>
| <code>0F 9A</code>
| rowspan="9" | Dedicated fax instructions.
| rowspan="9" | V55PI<ref name="nec-v55pi-db" />
|-
| <code>COLTRP</code>
| <code>0F 9B</code>
|-
| <code>MHENC</code>
| <code>0F 93</code>
|-
| <code>MRENC</code>
| <code>0F 97</code>
|-
| <code>SCHEOL</code>
| <code>0F 78</code>
|-
| <code>GETBIT</code>
| <code>0F 79</code>
|-
| <code>MHDEC</code>
| <code>0F 7C</code>
|-
| <code>MRDEC</code>
| <code>0F 7D</code>
|-
| <code>CNVTRP</code>
| <code>0F 7A</code>
|-
! colspan="4" |
|-
| (no mnemonic)
| <code>63</code>
| Designated opcode for termination of the x86 emulation mode on the [[NEC V60]].<ref>NEC [https://multimedia.cx/NEC_V60pgmRef.pdf uPD70616 Programmer's Reference Manual] (november 1986), p.287. [https://web.archive.org/web/20061205220723/https://multimedia.cx/NEC_V60pgmRef.pdf Archived] on Dec 5, 2006.</ref>
| V60, V70
|}

=== Instructions specific to [[Cyrix]] and [[Geode (processor)|Geode]] CPUs ===

These instructions are present in Cyrix CPUs as well as NatSemi/AMD Geode CPUs derived from Cyrix microarchitectures (Geode GX and LX, but not NX). They are also present in [[Cyrix#Manufacturing partners|Cyrix manufacturing partner CPUs]] from IBM, ST and TI, as well as the VIA [[Cyrix III]] ("Joshua" core only, not "Samuel") and a few SoCs such as STPC ATLAS and ZFMicro ZFx86.<ref>ZFMicro, [https://www.zfmicro.com/library/manuals/ZFx86_Data_Book.pdf ZFx86 System-on-a-chip Data Book 1.0 Rev D], june 5, 2005, section 2.2.6.3, page 76. [https://web.archive.org/web/20090211090201/https://www.zfmicro.com/library/manuals/ZFx86_Data_Book.pdf Archived] on Feb 11, 2009.</ref> Many of these opcodes have been reassigned to other instructions in later non-Cyrix CPUs.

{| class="wikitable"
! Instruction
! Opcode
! Description
! Available on
|-
| {{nowrap|<code>SVDC m80,sreg</code>}}
| <code>0F 78 /r</code>
| Save segment register and descriptor to memory as a 10-byte data structure.

The first 8 bytes are the descriptor, the last two bytes are the selector.<ref>Texas Instruments, [http://www.bitsavers.org/components/ti/TI486/1993_TI486_Microprocessor_Reference_Guide.pdf TI486 Microprocessor Reference Guide, 1993], section A.14, page 308</ref>
| rowspan="6" | System Management Mode instructions.{{efn|The Cyrix SMM instructions also include <code>RSM</code> ({{nowrap|<code>0F AA</code>}}; Return from System Management mode), however, <code>RSM</code> is not a Cyrix-specific instruction, and it continues to exist in modern non-Cyrix x86 processors.}}  
Not present on stepping A of Cx486SLC and Cx486DLC.<ref name="debs_cpuid">Debbie Wiles, [https://web.archive.org/web/20040604002243/http://debs.future.easyspace.com/Programming/OS/cpuid.txt CPU identification], archived on 2004-06-04</ref>

Present on Cx486SLC/e<ref name="cx486slce">[http://www.bitsavers.org/components/cyrix/Cyrix_Cx486SLCe_Data_Sheet_1992.pdf Cyrix 486SLC/e Data Sheet (1992)], section 2.6.4</ref> and all later Cyrix CPUs.

Present on all Cyrix-derived Geode CPUs.
|-
| {{nowrap|<code>RSDC sreg,m80</code>{{efn|<code>RSDC</code> with <code>CS</code> as a destination register is only supported on NatSemi Geode GX2 and AMD Geode GX/LX<ref name="geodelx_instrs" /> - on other processors, it causes #UD.}}}}
| <code>0F 79 /r</code>
| Restore segment register and descriptor from memory
|-
| <code>SVLDT m80</code>
| {{nowrap|<code>0F 7A /0</code>}}
| Save LDTR and descriptor
|-
| <code>RSLDT m80</code>
| <code>0F 7B /0</code>
| Restore LDTR and descriptor
|-
| <code>SVTS m80</code>
| <code>0F 7C /0</code>
| Save TSR and descriptor
|-
| <code>RSTS m80</code>
| <code>0F 7D /0</code>
| Restore TSR and descriptor
|-
| rowspan="2" | <code>SMINT</code>{{efn|Some assemblers/disassemblers, such as [[Netwide Assembler|NASM]], use the instruction mnemonic <code>SMINTOLD</code> for the <code>0F 7E</code> encoding.}}
| <code>0F 7E</code>
| rowspan="2" | System management software interrupt.
Uses {{nowrap|<code>0F 7E</code>}} encoding on Cyrix 486, 5x86, 6x86 and ZFx86.

Uses {{nowrap|<code>0F 38</code>}} encoding on Cyrix 6x86MX, MII, MediaGX and Geode.
| rowspan="2" | Cyrix 486S<ref name="complete_x86" /> and later processors - not available on older Cyrix 486SLC/DLC/SRx2/DRx2 processors.

Not available on any Ti486 processors.
|-
| <code>0F 38</code>
|-
| <code>RDSHR r/m32</code>
| <code>0F 36 /0</code>{{efn|name=cyrix_rdshr_arg|text=For the <code>RDSHR</code> and <code>WRSHR</code> instructions, Cyrix's documentation<ref name="cyrix_rdshr_ref"/> specifies that the instruction accepts a [[ModR/M]] byte but does not specify the encoding of the ModR/M byte's reg field. [[Netwide Assembler|NASM]] v0.98.31 and later uses /0 for these instructions,<ref>[https://sourceforge.net/projects/nasm/files/nasm%20documentation/0.98.31/ NASM 0.98.31 documentation] at SourceForge, see sections B.275 and B.331. [https://web.archive.org/web/20230721024257/https://sourceforge.net/projects/nasm/files/nasm%20documentation/0.98.31/ Archived] on Jul 21, 2023.</ref> while sandpile.org's opcode tables<ref>Sandpile, [https://sandpile.org/x86/opc_2.htm x86 architecture 2 byte opcodes]. [https://web.archive.org/web/20111103094056/https://sandpile.org/x86/opc_2.htm Archived] on Nov 3, 2011.</ref> indicate that the reg field is ignored for these instructions.}}
| Read SMM Header Pointer Register
| rowspan="2" | Cyrix 6x86MX<ref name="cyrix_rdshr_ref">[https://www.ardent-tool.com/CPU/docs/Cyrix/6x86MX/94329.pdf Cyrix 6x86MX Data Book], section 2.15.3</ref> and MII

VIA Cyrix III<ref>VIA, [http://datasheets.chipdb.org/VIA/Joshua/cyrix3db.pdf Cyrix III Processor Data Book], v1.00, Jan 25, 2000, p. 103.</ref>
|-
| <code>WRSHR r/m32</code>
| <code>0F 37 /0</code>{{efn|name=cyrix_rdshr_arg}}
| Write SMM Header Pointer Register
|-
| <code>BB0_RESET</code>
| <code>0F 3A</code>
| Reset BLT Buffer Pointer 0 to base
| rowspan="4" | Cyrix MediaGX and MediaGXm<ref>[http://datasheets.chipdb.org/Cyrix/MediaGX/gxmdb_v20.pdf Cyrix MediaGX Data Book], section 4.1.5</ref>

NatSemi Geode GXm, GXLV, GX1
|-
| <code>BB1_RESET</code>
| <code>0F 3B</code>
| Reset BLT Buffer Pointer 1 to base
|-
| <code>CPU_WRITE</code>
| <code>0F 3C</code>
| Write to CPU internal special register (EBX=register-index, EAX=data)
|-
| <code>CPU_READ</code>
| <code>0F 3D</code>
| Read from CPU internal special register (EBX=register-index, EAX=data)
|-
| <code>DMINT</code>
| <code>0F 39</code>
| Debug Management Mode Interrupt
| rowspan="2" | NatSemi Geode GX2

AMD Geode GX, LX<ref name="geodelx_instrs">AMD, [https://www.amd.com/content/dam/amd/en/documents/archived-tech-docs/datasheets/33234H_LX_databook.pdf Geode LX Processors Data Book], Feb 2009, publication ID 33234H, section 8.3.4, pages 643-657. [https://web.archive.org/web/20231203113022/https://www.amd.com/content/dam/amd/en/documents/archived-tech-docs/datasheets/33234H_LX_databook.pdf Archived] on 3 Dec 2023.</ref>
|-
| <code>RDM</code>
| <code>0F 3A</code>
| Return from Debug Management Mode
|}
{{notelist}}

==== Cyrix [[Extended MMX|EMMI]] instructions ====

These instructions were introduced in the Cyrix [[6x86MX]] and MII processors, and were also present in the [[MediaGX]]m and Geode GX1<ref>AMD, [https://www.amd.com/system/files/TechDocs/goede_gx1_databook-rev5.pdf AMD Geode GX1 Processor Data Book], rev 5.0, dec 2003, p. 226. [https://web.archive.org/web/20200420011559/https://www.amd.com/system/files/TechDocs/goede_gx1_databook-rev5.pdf Archived] on 20 Apr 2020.</ref> processors. (In later non-Cyrix processors, all of their opcodes have been used for SSE or SSE2 instructions.)

These instructions are integer SIMD instructions acting on 64-bit vectors in MMX registers or memory. Each instruction takes two explicit operands, where the first one is an MMX register operand and the second one is either a memory operand or a second MMX register. In addition, several of the instructions take an implied operand, which is an MMX register implied from the first operand as follows:
{| class="wikitable"
|-
! First explicit operand
| <code>mm0</code> || <code>mm1</code> || <code>mm2</code> || <code>mm3</code> || <code>mm4</code> || <code>mm5</code> || <code>mm6</code> || <code>mm7</code>
|-
! Implied operand
| <code>mm1</code> || <code>mm0</code> || <code>mm3</code> || <code>mm2</code> || <code>mm5</code> || <code>mm4</code> || <code>mm7</code> || <code>mm6</code>
|}
In the instruction descriptions in the below table, <code>arg1</code> and <code>arg2</code> refer to the two explicit operands of the instruction, and <code>imp</code> to the implied operand.  
{| class="wikitable"
|-
! Instruction !! Opcode !! colspan=2 | Description
|-
| <code>PAVEB mm,mm/m64</code> || <code>0F 50 /r</code> || colspan=2 | Packed average bytes:{{efn|Implementations differ on whether the <code>PAVEB</code> instruction treats the bytes as signed or unsigned.<ref>Cyrix, [https://www.dosdays.co.uk/media/cyrix/M2/108ap.pdf Application Note 108 − Cyrix Extensions to the Multimedia Instruction Set], rev 0.93, 9 sep 1998, page 7</ref>}}<br/><code>arg1 <- (arg1+arg2) >> 1</code>
|-
| {{nowrap|<code>PADDSIW mm,mm/m64</code>}} || <code>0F 51 /r</code> || colspan=2 | Packed add signed words with saturation, using implied destination:<br/><code>imp <- saturate_s16(arg1+arg2)</code>
|-
| <code>PMAGW mm,mm/m64</code> || <code>0F 52 /r</code> || colspan=2 | Packed signed word magnitude maximum value:<br/><code>if (abs(arg2) > abs(arg1)) then arg1 <- arg2</code>
|-
| <code>PDISTIB mm,m64</code>{{efn|name=emmi_memop|text=For <code>PDISTIB</code>, <code>PMACHRIW</code> and the <code>PMV*</code> instructions, the second explicit operand is required to be a memory operand − register operands are not supported.}} || {{nowrap|<code>0F 54 /r</code>}} || colspan=2 | Packed unsigned byte distance and accumulate to implied destination, with saturation:<br/><code>imp <- saturate_u8(imp + (abs(arg1-arg2)))</code>
|-
| {{nowrap|<code>PSUBSIW mm,mm/m64</code>}} || <code>0F 55 /r</code> || colspan=2 | Packed subtract signed words with saturation, using implied destination:<br/><code>imp <- saturate_s16(arg1-arg2)</code>
|-
| {{nowrap|<code>PMULHRW mm,mm/m64</code>,{{efn|The Cyrix EMMI <code>PMULHRW</code> instruction has the same mnemonic as the 3DNow! <code>PMULHRW</code> instruction, however its opcode and function differ (the EMMI instruction right-shifts its multiply-result by 15 bits, while the 3DNow! instruction right-shifts by 16 bits).<p>Some assemblers/disassemblers, such as NASM, resolve this ambiguity by using the mnemonic <code>PMULHRWA</code> for the 3DNow! instruction and <code>PMULHRWC</code> for the EMMI instruction.</p>}}}}<br/>{{nowrap|1=<code>PMULHRWC mm,mm/m64</code>}}|| <code>0F 59 /r</code> || colspan=2 | Packed signed word multiply high with rounding:<br/><code>arg1 <- (arg1*arg2+0x4000)>>15</code>
|-
| {{nowrap|<code>PMULHRIW mm,mm/m64</code>}} || <code>0F 5D /r</code> || colspan=2 | Packed signed word multiply high with rounding and implied destination:<br/><code>imp <- (arg1*arg2+0x4000)>>15</code>
|-
| <code>PMACHRIW mm,m64</code>{{efn|name=emmi_memop}} || <code>0F 5E /r</code> || colspan=2 | Packed signed word multiply high with rounding and accumulation to implied destination:<br><code>imp <- imp + ((arg1*arg2+0x4000)>>15)</code>
|-
! colspan=4 |
|-
| <code>PMVZB mm,m64</code>{{efn|name=emmi_memop}} || <code>0F 58 /r</code> || {{nowrap|1=<code>if (imp == 0) then arg1 <- arg2</code>}}
| rowspan=4 | Packed conditional load from memory to MMX register.

Condition is evaluated on a per-byte-lane basis, by comparing byte lanes in the implied source to zero (with signed compare) − if the comparison passes, then the corresponding destination lane is loaded from memory, otherwise it keeps its original value.
|-
| <code>PMVNZB mm,m64</code>{{efn|name=emmi_memop}} || <code>0F 5A /r</code> || {{nowrap|1=<code>if (imp != 0) then arg1 <- arg2</code>}}
|-
| <code>PMVLZB mm,m64</code>{{efn|name=emmi_memop}} || <code>0F 5B /r</code> || {{nowrap|1=<code>if (imp <&nbsp; 0) then arg1 <- arg2</code>}}
|-
| <code>PMVGEZB mm,m64</code>{{efn|name=emmi_memop}} || <code>0F 5C /r</code> || {{nowrap|1=<code>if (imp >= 0) then arg1 <- arg2</code>}}
|}
{{notelist}}
{{vpad}}

=== Instructions specific to [[VIA Technologies]] CPUs ===
All [[VIA C3]] processors support the VIA AIS ([[Alternate Instruction Set]]). The x86 instructions present in these processors to support AIS are:
{| class="wikitable"
! Instruction !! Opcode !! Description
|-
| {{nowrap|<code>JMPAI EAX</code>}} || <code>0F 3F</code><ref name="via_public">VIA Technologies, [https://web.archive.org/web/20040410030107/http://www.via.com.tw:80/en/viac3/VIA%20C3%20Samuel%202%20datasheet%20v%201.10.pdf VIA C3 Samuel 2 Processor Datasheet], version 1.10, January 2002 - publicly available datasheet that lists the <code>0F 3F</code> and {{nowrap|<code>8D 84 00 imm32</code>}} AIS opcodes (without mnemonics) on page 60. Archived from the [http://www.via.com.tw/en/viac3/VIA%20C3%20Samuel%202%20datasheet%20v%201.10.pdf original] on 10 Apr 2004.</ref> || Near Jump to address in EAX, and enter Alternate Instruction mode.
|-
| rowspan=2 | {{nowrap|<code>AI uop32</code>}}
| {{nowrap|<code>8D 84 00 imm32</code><ref name="via_public" />}} || Alternate instruction wrapper opcode ("Samuel"/"Ezra" variants of C3 - repurposes the instruction encoding for {{nowrap|<code>LEA EAX,[EAX+EAX+disp32]</code>)}}

32-bit immediate is treated as a 32-bit instruction of the RISC-like Alternate Instruction Set. An instruction set reference is available.<ref name="ais_reference">VIA, [http://www.bitsavers.org/components/viaTechnologies/C3-ais-reference.pdf VIA C3 Processor Alternate Instruction Set Programming Reference], version 0.25, november 2002. Accessed on Apr 26, 2023.</ref>
|-
| <code>62 80 imm32</code><ref name="ais_appnote">VIA, [http://www.bitsavers.org/components/viaTechnologies/C3-ais-appnote.pdf VIA C3 Processor Alternate Instruction Set Application Note], version 0.24, 2002, page 14. Accessed on Apr 26, 2023.</ref> || Alternate instruction wrapper opcode ("Nehemiah" variants of C3 - repurposes the instruction encoding for {{nowrap|<code>BOUND EAX,[EAX+disp32]</code>)}}
|}
These instructions are not present in [[VIA C7]] or any later VIA processor. 
{{vpad}}

=== Instructions specific to [[Chips and Technologies]] CPUs ===
The C&T F8680 PC/Chip is a system-on-a-chip featuring an 80186-compatible CPU core, with a few additional instructions to support the F8680-specific "SuperState R"<ref>[https://archive.org/details/eu_BYTE-1991-11_OCR/page/n245/mode/2up BYTE Magazine, november 1991], page 245</ref> supervisor/system-management feature. Some of the added instructions for "SuperState R" are:<ref>Institute Of Oceanographic Sciences, [https://eprints.soton.ac.uk/392463/1/1197993-1001.pdf Sonic buoy − Formatter Handbook] contains some F8680 instruction macros on page 34. [https://web.archive.org/web/20181104040741/https://eprints.soton.ac.uk/392463/1/1197993-1001.pdf Archived] on Nov 4, 2018.</ref>
<!-- The F8680 instruction list given here is known to be very incomplete − as of may 2022, the "F8680 PC/Chip Programmer's Reference Manual" that lists these instructions does not appear to be available anywhere -->
{| class="wikitable"
! Instruction !! Opcode !! Description
|-
| <code>LFEAT AX</code> || <code>FE F8</code> || Load datum into F8680 "CREG" configuration register (AH=register-index, AL=datum)<ref>The [http://www.bitsavers.org/components/chipsAndTech/F8680_System_Design_Guide_1991.pdf F8680 PC/Chip System Design Guide] contains descriptions of many of the F8680 CREG registers.</ref>
|-
| <code>STFEAT AL,imm8</code> || {{nowrap|<code>FE F0 ib</code>}} || Read F8680 status register into AL (imm8=register-index)
|}

C&T also developed a 386-compatible processor known as the Super386. This processor supports, in addition to the basic Intel 386 instruction set, a number of instructions to support the Super386-specific {{nowrap|"SuperState V"}} system-management feature. The added instructions for {{nowrap|"SuperState V"}} are:<ref name="mpr92_smm">Microprocessor Report, [http://www.cecs.uci.edu/~papers/mpr/MPR/ARTICLES/060805.PDF System Management Mode Explained] (vol 6, no. 8, june 17, 1992) − includes a listing of the AMD/Cyrix SMM opcodes and the C&T Super386 "SuperState V" opcodes. [https://web.archive.org/web/20220629220530/http://www.cecs.uci.edu/~papers/mpr/MPR/ARTICLES/060805.PDF Archived] on 29 Jun 2022.</ref>

{| class="wikitable"
! Instruction !! Opcode !! Description
|-
| {{nowrap|<code>SCALL r/m</code>}} || {{nowrap|<code>0F 18 /0</code>}} || Call SMM interrupt handler<ref>Michal Necasek, [http://www.os2museum.com/wp/more-on-the-ct-super386/ More on the C&T Super386]</ref><ref>Corexor, [https://corexor.wordpress.com/2015/12/05/calling-ct-scall-safely/ Calling C&T SCALL safely], 5 Dec 2015. [https://web.archive.org/web/20201017080133/https://corexor.wordpress.com/2015/12/05/calling-ct-scall-safely/ Archived] on 27 Oct 2020.</ref>
|-
| <code>SRET</code> || <code>0F 19</code> || Return from SMM interrupt handler
|-
| <code>SRESUME</code> || <code>0F 1A</code> || Return from SMM with interrupts disabled for one instruction
|-
| <code>SVECTOR</code> || <code>0F 1B</code> || Exit from SMM and issue a shutdown cycle
|-
| <code>EPIC</code> || <code>0F 1E</code> || Load one of the six interrupt or I/O traps
|-
| <code>RARF1</code> || <code>0F 3C</code> || Read from bank 1 of the register file (includes visible and invisible CPU registers)
|-
| <code>RARF2</code> || <code>0F 3D</code> || Read from bank 2 of the register file
|-
| <code>RARF3</code> || <code>0F 3E</code> || Read from bank 3 of the register file
|-
| <code>LTLB</code> || <code>0F F0</code> || Load TLB with page table entry
|-
| <code>RCT</code> || <code>0F F1</code> || Read cache tag
|-
| <code>WCT</code> || <code>0F F2</code> || Write cache tag
|-
| <code>RCD</code> || <code>0F F3</code> || Read cache data
|-
| <code>WCD</code> || <code>0F F4</code> || Write cache data
|-
| <code>RTLBPA</code> || <code>0F F5</code> || Read TLB data (physical address)
|-
| <code>RTLBLA</code> || <code>0F F6</code> || Read TLB tag (linear address)
|-
| <code>LCFG</code> || <code>0F F7</code> || Load configuration register
|-
| <code>SCFG</code> || <code>0F F8</code> || Store configuration register
|-
| <code>RGPR</code> || <code>0F F9</code> || Read general-purpose register or any bank of register file
|-
| <code>RARF0</code> || <code>0F FA</code> || Read from bank 0 of the register file
|-
| <code>RARFE</code> || <code>0F FB</code> || Read from extra bank of the register file
|-
| <code>WGPR</code> || <code>0F FD</code> || Write general-purpose register or any bank of register file
|-
| <code>WARFE</code> || <code>0F FE</code> || Write extra bank of the register file
|}

=== Instructions specific to [[ALi Corporation|ALi]]/[[Nvidia]]/[[D&MP Electronics|DM&P]] M6117 MCUs ===
The [[ALi Corporation#For embedded systems|M6117]] series of embedded microcontrollers feature an Intel 386SX compatible CPU core derived from V.M. Technology (VMT) VM386SX+ processor. VMT VM386SX+ adds a few processor specific additions to the Intel 386 instruction set. The ones documented for DM&P M6117D are:<ref>DM&P, [http://www.dmp.com.tw/app/webcamera/pdf/m6117d.pdf M6117D : System on a chip], pages 31,34,68. [https://web.archive.org/web/20060720130638/http://www.dmp.com.tw/tech/m6117d/doc/m6117d.pdf Archived] on Jul 20,2006.</ref>
{| class="wikitable"
! Instruction !! Opcode !! Description
|-
| <code>BRKPM</code> || <code>F1</code> || System management interrupt − enters "hyper state mode"
|-
| <code>RETPM</code> || <code>D6 E6</code> || Return from "hyper state mode"
|-
| {{nowrap|<code>LDUSR UGRS,EAX</code>}} || {{nowrap|<code>D6 CA 03 A0</code>}} || Set page address of SMI entry point
|-
| (mnemonic not listed) || {{nowrap|<code>D6 C8 03 A0</code>}} || Read page address of SMI entry point
|-
| <code>MOV PWRCR,EAX</code> || <code>D6 FA 03 02</code> || Write to power control register
|}

== Instructions present in specific [[80387]] clones ==
Several 80387-class floating-point coprocessors provided extra instructions in addition to the standard 80387 ones − none of these are supported in later processors:
{| class="wikitable"
! Instruction
! Opcode
! Description
! Available on
|-
| <code>FRSTPM</code>
| {{nowrap|<code>DB F4</code><ref>Intel [https://www.ardent-tool.com/CPU/docs/Intel/287/datasheets/290376-003.pdf "Intel287 XL/XLT Math Coprocessor"], (oct 1992, order no 290376-003) p.33</ref>}}
or

{{nowrap|<code>DB E5</code><ref name="potemkin" />}}
| FPU Reset Protected Mode.
Instruction to signal to the FPU that the main CPU is exiting protected mode, similar to how the FSETPM instruction is used to signal to the FPU that the CPU is entering protected mode.

Different sources provide different encodings for this instruction.
| Intel 287XL
|-
| {{nowrap|<code>FNSTDW AX</code>}}
| <code>DF E1</code>
| Store FPU Device Word to AX
| rowspan="2" | Intel 387SL<ref name="potemkin" /><ref>Intel "Intel387 SL Mobile Math Coprocessor" (feb 1992, order no 290427-001), appendix A. Located on Jan 7, 2022 by searching for [https://www.datasheetarchive.com/?q=intel387+sl "intel387 sl"] at datasheetarchive.com. [https://web.archive.org/web/20220107003754/https://datasheet.datasheetarchive.com/originals/scans/Scans-101/DSAIHSC000149849.pdf Archived] on Jan 7, 2022.</ref>
|-
| {{nowrap|<code>FNSTSG AX</code>}}
| <code>DF E2</code>
| Store FPU Signature Register to AX{{efn|The <code>FNSTSG AX</code> instruction can be executed not just on the Intel 387SL FPU but on the Intel 387SX as well - executing the instruction immediately after an <code>FNINIT</code> will cause the instruction to return <code>0000h</code> on 387SX, but a nonzero signature value on the 387SL.<ref>Desmond Yuen, [http://www.bitsavers.org/components/intel/80486/Intels_SL_Architecture_Designing_Portable_Applications_1993/Intels_SL_Architecture_Designing_Portable_Applications_1993.pdf Intel's SL Architecture: Designing Portable Applications], (1993, ISBN 0-07-911336-2) p.127</ref>}}
|-
| <code>FSBP0</code>
| <code>DB E8</code>
| Select Coprocessor Register Bank 0
| rowspan="5" | IIT 2c87, 3c87<ref name="potemkin" /><ref name="iit387">[https://www.ardent-tool.com/CPU/docs/IIT/3c87dx.pdf IIT 3c87 Advanced Math CoProcessor Data Book]</ref>
|-
| <code>FSBP1</code>
| <code>DB EB</code>
| Select Coprocessor Register Bank 1
|-
| <code>FSBP2</code>
| <code>DB EA</code>
| Select Coprocessor Register Bank 2
|-
| <code>FSBP3</code>
| {{nowrap|<code>DB E9</code><ref name="hamarsoft">Harald Feldmann, [https://feldmann.home.xs4all.nl/86bugs.htm Hamarsoft 86BUGS List]</ref>}}
| Select Coprocessor Register Bank 3 (undocumented)
|-
| <code>F4X4</code>,
<code>FMUL4X4</code>
| <code>DB F1</code>
| Multiply 4-component vector with 4x4 matrix. For proper operation, the matrix must be preloaded into Coprocessor Register banks 1 and 2 (unique to IIT FPUs), and the vector must be loaded into Coprocessor Register Bank 0. Example code is available.<ref name="iit387" /><ref name="juffa">Norbert Juffa [https://mikro.naprvyraz.sk/docs/Coding/Hardware/COPRO16A.TXT "Everything You Always Wanted To Know About Math Coprocessors"], 01-oct-94 revision</ref>
|-
| <code>FTSTP</code>
| <code>D9 E6</code>
| Equivalent to <code>FTST</code> followed by a stack pop.
| rowspan="4" | Cyrix EMC87, 83s87, 83d87, 387+<ref name="juffa" /><ref name="potemkin" /><ref name="Hummel">Robert L. Hummel, [https://archive.org/details/pc-magazine-programmers-technical-reference-1992/ PC Magazine Programmer's Technical Reference], 1992, {{ISBN|1-56276-016-5}}, pages 670-672 and 710.</ref> 
|-
| <code>FRINT2</code>
| <code>DB FC</code>
| Round st(0) to integer, with round-to-nearest ties-away-from-zero rounding.<ref name="Hummel"/>
|-
| <code>FRICHOP</code>
| <code>DD FC</code>
| Round st(0) to integer, with round-to-zero rounding.
|-
| <code>FRINEAR</code>
| <code>DF FC</code>
| Round st(0) to integer, with round-to-nearest-even rounding.<ref name="Hummel"/>
|}
{{notelist}}

== See also ==
* [[x86 instruction listings]]

== References ==
{{reflist}}

{{x86 assembly topics}}

[[Category:X86 instructions| ]]
[[Category:Instruction set listings]]