Diary Soft Elec FM Doc Lib 　

x86SIMD拡張命令リファレンス

2004/2/23

拡張命令を使って配布目的のプログラムを書く場合、どのCPUでどの命令がサポートされたかをしっかり把握しておかないと、自分の環境では動いても他のCPUでは無効命令落ち、なんてことになります。特にSSEの新命令は紛らわしいのが多いので。そこでこれらの命令をまとめたクイックリファレンスを作ってみました。

CPUと命令セットの対応表

-MMXSSESSE2SSE33DNow!E3DNow!
Pentium MMX○-----
PentiumII○-----
PentiumIII○○----
Pentium4○○○---
Pentium4(Prescott)○○○○--
K6○-----
K6-2○---○-
Athlon○---○○
Athlon4/XP○○--○○
Athlon64○○○-○○
Opteron○○○-○○
6x86MX○-----
MediaGXm○-----
MII○-----
WinChip○-----
CyrixIII/C3○---○-
C3(Nehemiah)○○--○-

各命令セットの概要

MMX
FPUのレジスタの64ビット分を用い、8ビット整数8組、16ビット整数4組、または32ビット整数2組を同時に扱うことができます。オーバーフロー及びアンダーフローが発生したとき、最大値及び最小値で留める飽和演算という演算方法を採用しています。
SSE
PentiumIII以降新設された128ビットのレジスタを用い、32ビット単精度実数を4つ同時に扱えます。 また、キャッシュ制御命令が追加されました。
SSE2
SSEと同じレジスタで、64ビット倍精度実数を2つ同時に扱えます。また、64ビットの整数として扱う命令もあります。
SSE3
いくつかの浮動小数命令が追加されました。
3DNow!
FPUのレジスタの64ビット分を用い、32ビット単精度実数2つを同時に扱うことができます。キャッシュのプリフェッチ命令があります。
Enhanced 3DNow!
DSP命令とキャッシュ制御命令が追加されました。ちなみに、3DNow! ProfessionalというのはこれとSSEをあわせた呼び名です。

MMXで追加された命令

EMMSEmpty MMX State
FPUタグワードを空にします。
MMX命令を使った後は、この命令を実行する必要があります。
MOVD mm,r/m32Move 32 Bits
汎用レジスタ及びメモリから、MMレジスタへダブルワードをコピーします。
mm[63:32] = 0
mm[31:0] = r/m32[31:0]
MOVD r/m32,mmMove 32 Bits
MMレジスタから、汎用レジスタ及びメモリへダブルワードをコピーします。
r/m32[31:0] = mm[31:0]
MOVQ mm1,mm2/m64
MOVQ mm1/m64,mm2		Move 64 Bits
メモリ及びMMレジスタから、MMレジスタへクワッドワードをコピーします。
mm1/m64[63:0] = mm2/m64[63:0]
MOVQ m64,mmMove 64 Bits
MMレジスタからメモリへクワッドワードをコピーします。
m64[63:0] = mm[63:0]
PACKSSWB mm1,mm2/m64Pack with Signed Saturation
mm1からの符号付き4ワードとmm2/m64からの符号付き4ワードをmm1の符号付き8バイトにパックして飽和させます。
mm1[63:56] = Sat8s(mm2/m64[63:48])
～
mm1[39:32] = Sat8s(mm2/m64[15:0])
mm1[31:24] = Sat8s(mm1[63:48])
～
mm1[7:0] = Sat8s(mm1[15:0])
PACKSSDW mm1,mm2/m64Pack with Signed Saturation
mm1からの符号付き2ダブルワードとmm2/m64からの符号付き2ダブルワードをmm1の符号付き4ワードにパックして飽和させます。
mm1[63:48] = Sat16s(mm2/m64[63:32])
mm1[47:32] = Sat16s(mm2/m64[31:0])
mm1[31:16] = Sat16s(mm1[63:32])
mm1[15:0] = Sat16s(mm1[31:0])
PACKUSWB mm1,mm2/m64Pack with Unsigned Saturation
mm1からの符号付き4ワードとmm2/m64からの符号無し4ワードをmm1の符号無し8バイトにパックして飽和させます。
mm1[63:56] = Sat8u(mm2/m64[63:48])
～
mm1[39:32] = Sat8u(mm2/m64[15:0])
mm1[31:24] = Sat8u(mm1[63:48])
～
mm1[7:0] = Sat8u(mm1[15:0])
PADDB mm1,mm2/m64Packed Add
mm2/m64からのパックドバイトをmm1のパックドバイトに加算します。
mm1[63:56] = mm1[63:56] + mm2/m64[63:56]
～
mm1[7:0] = mm1[7:0] + mm2/m64[7:0]
PADDW mm1,mm2/m64Packed Add
mm2/m64からのパックドワードをmm1のパックドワードに加算します。
mm1[63:48] = mm1[63:48] + mm2/m64[63:48]
～
mm1[15:0] = mm1[15:0] + mm2/m64[15:0]
PADDD mm1,mm2/m64Packed Add
mm2/m64からのパックドダブルワードをmm1のパックドダブルワードに加算します。
mm1[63:32] = mm1[63:32] + mm2/m64[63:32]
mm1[31:0] = mm1[31:0] + mm2/m64[31:0]
PADDSB mm1,mm2/m64Packed Add with Saturation
mm2/m64からの符号付きパックドバイトをmm1の符号付きパックドバイトに加算し、飽和させます。
mm1[63:56] = Sat8s(mm1[63:56] + mm2/m64[63:56])
～
mm1[7:0] = Sat8s(mm1[7:0] + mm2/m64[7:0])
PADDSW mm1,mm2/m64Packed Add with Saturation
mm2/m64からの符号付きパックドワードをmm1の符号付きパックドワードに加算し、飽和させます。
mm1[63:48] = Sat16s(mm1[63:48] + mm2/m64[63:48])
～
mm1[15:0] = Sat16s(mm1[15:0] + mm2/m64[15:0])
PADDUSB mm1,mm2/m64Packed Add Unsigned with Saturation
mm2/m64からの符号無しパックドバイトをmm1の符号無しパックドバイトに加算し、飽和させます。
mm1[63:56] = Sat8u(mm1[63:56] + mm2/m64[63:56])
～
mm1[7:0] = Sat8u(mm1[7:0] + mm2/m64[7:0])
PADDUSW mm1,mm2/m64Packed Add Unsigned with Saturation
mm2/m64からの符号無しパックドワードをmm1の符号無しパックドワードに加算し、飽和させます。
mm1[63:48] = Sat16u(mm1[63:48] + mm2/m64[63:48])
～
mm1[15:0] = Sat16u(mm1[15:0] + mm2/m64[15:0])
PAND mm1,mm2/m64Logical AND
論理積を求めます。
mm1[63:0] = mm1[63:0] & mm2/m64[63:0]
PANDN mm1,mm2/m64Logical AND NOT
mm1を反転させ、mm2/m64との論理積を求めます。
mm1[63:0] = !mm1[63:0] & mm2/m64[63:0]
PCMPEQB mm1,mm2/m64Packed Compare for Equal
パックドバイトが等しいかどうか比較します。
mm1[63:56] = mm1[63:56] == mm2/m64[63:56] ? FFh : 0
～
mm1[7:0] = mm1[7:0] == mm2/m64[7:0] ? FFh : 0
PCMPEQW mm1,mm2/m64Packed Compare for Equal
パックドワードが等しいかどうか比較します。
mm1[63:48] = mm1[63:48] == mm2/m64[63:48] ? FFFFh : 0
～
mm1[15:0] = mm1[15:0] == mm2/m64[15:0] ? FFFFh : 0
PCMPEQD mm1,mm2/m64Packed Compare for Equal
パックドダブルワードが等しいかどうか比較します。
mm1[63:32] = mm1[63:32] == mm2/m64[63:32] ? FFFFFFFFh : 0
mm1[31:0] = mm1[31:0] == mm2/m64[31:0] ? FFFFFFFFh : 0
PCMPGTB mm1,mm2/m64Packed Compare for Greater Than
符号付きパックドバイトがより大きいかどうか比較します。
mm1[63:56] = mm1[63:56] > mm2/m64[63:56] ? FFh : 0
～
mm1[7:0] = mm1[7:0] > mm2/m64[7:0] ? FFh : 0
PCMPGTW mm1,mm2/m64Packed Compare for Greater Than
符号付きパックドワードがより大きいかどうか比較します。
mm1[63:48] = mm1[63:48] > mm2/m64[63:48] ? FFFFh : 0
～
mm1[15:0] = mm1[15:0] > mm2/m64[15:0] ? FFFFh : 0
PCMPGTD mm1,mm2/m64Packed Compare for Greater Than
符号付きパックドダブルワードがより大きいかどうか比較します。
mm1[63:32] = mm1[63:32] > mm2/m64[63:32] ? FFFFFFFFh : 0
mm1[31:0] = mm1[31:0] > mm2/m64[31:0] ? FFFFFFFFh : 0
PMADDWD mm1,mm2/m64Packed Multiply and Add
パックドワード同士を掛け、結果の32ビットペアを加算します。
mm1[63:32] = mm1[63:48]*mm2/m64[63:48] + mm1[47:32]*mm2/m64[47:32]
mm1[31:0] = mm1[31:16]*mm2/m64[31:16] + mm1[15:0]*mm2/m64[15:0]
PMULHW mm1,mm2/m64Packed Multiply High
符号付きパックドワード同士を掛け、結果の上位ワードを求めます。
mm1[63:48] = (mm1[63:48] * mm2/m64[63:48])>>16
～
mm1[15:0] = (mm1[15:0] * mm2/m64[15:0])>>16
PMULLW mm1,mm2/m64Packed Multiply Low
パックドワード同士を掛け、結果の下位ワードを求めます。
mm1[63:48] = (mm1[63:48] * mm2/m64[63:48])&FFFFh
～
mm1[15:0] = (mm1[15:0] * mm2/m64[15:0])&FFFFh
POR mm1,mm2/m64Bitwise Logical OR
論理和を求めます。
mm1[63:0] = mm1[63:0] | mm2/m64[63:0]
PSLLW mm1,mm2/m64/imm8Packed Shift Left Logical
パックドワードの左シフトを行います。
mm1[63:48] = mm1[63:48] << mm2/m64/imm8
～
mm1[15:0] = mm1[15:0] << mm2/m64/imm8
PSLLD mm1,mm2/m64/imm8Packed Shift Left Logical
パックドダブルワードの左シフトを行います。
mm1[63:32] = mm1[63:32] << mm2/m64/imm8
mm1[31:0] = mm1[31:0] << mm2/m64/imm8
PSLLQ mm1,mm2/m64/imm8Packed Shift Left Logical
クワッドワードの左シフトを行います。
mm1[63:0] = mm1[63:0] << mm2/m64/imm8
PSRAW mm1,mm2/m64/imm8Packed Shift Right Arithmetic
パックドワードの算術右シフトを行います。
mm1[63:48] = mm1[63:48] >> mm2/m64/imm8
～
mm1[15:0] = mm1[15:0] >> mm2/m64/imm8
PSRAD mm1,mm2/m64/imm8Packed Shift Right Arithmetic
パックドダブルワードの算術右シフトを行います。
mm1[63:32] = mm1[63:32] >> mm2/m64/imm8
mm1[31:0] = mm1[31:0] >> mm2/m64/imm8
PSRLW mm1,mm2/m64/imm8Packed Shift Right Logical
パックドワードの論理右シフトを行います。
mm1[63:48] = mm1[63:48] >> mm2/m64/imm8
～
mm1[15:0] = mm1[15:0] >> mm2/m64/imm8
PSRLD mm1,mm2/m64/imm8Packed Shift Right Logical
パックドダブルワードの論理右シフトを行います。
mm1[63:32] = mm1[63:32] >> mm2/m64/imm8
mm1[31:0] = mm1[31:0] >> mm2/m64/imm8
PSUBB mm1,mm2/m64Packed Subtract
mm1のパックドバイトからmm2/m64のパックドバイトを引きます。
mm1[63:56] = mm1[63:56] - mm2/m64[63:56]
～
mm1[7:0] = mm1[7:0] - mm2/m64[7:0]
PSUBW mm1,mm2/m64Packed Subtract
mm1のパックドワードからmm2/m64のパックドワードを引きます。
mm1[63:48] = mm1[63:48] - mm2/m64[63:48]
～
mm1[15:0] = mm1[15:0] - mm2/m64[15:0]
PSUBD mm1,mm2/m64Packed Subtract
mm1のパックドダブルワードからmm2/m64のパックドダブルワードを引きます。
mm1[63:32] = mm1[63:32] - mm2/m64[63:32]
mm1[31:0] = mm1[31:0] - mm2/m64[31:0]
PSUBSB mm1,mm2/m64Packed Subtract with Saturation
mm1の符号付きパックドバイトからmm2/m64の符号付きパックドバイトを引き、飽和させます。
mm1[63:56] = Sat8s(mm1[63:56] - mm2/m64[63:56])
～
mm1[7:0] = Sat8s(mm1[7:0] - mm2/m64[7:0])
PSUBSW mm1,mm2/m64Packed Subtract with Saturation
mm1の符号付きパックドワードからmm2/m64の符号付きパックドワードを引き、飽和させます。
mm1[63:48] = Sat16s(mm1[63:48] - mm2/m64[63:48])
～
mm1[15:0] = Sat16s(mm1[15:0] - mm2/m64[15:0])
PSUBUSB mm1,mm2/m64Packed Subtract Unsigned with Saturation
mm1の符号無しパックドバイトからmm2/m64の符号無しパックドバイトを引き、飽和させます。
mm1[63:56] = Sat8u(mm1[63:56] - mm2/m64[63:56])
～
mm1[7:0] = Sat8u(mm1[7:0] - mm2/m64[7:0])
PSUBUSW mm1,mm2/m64Packed Subtract Unsigned with Saturation
mm1の符号無しパックドワードからmm2/m64の符号無しパックドワードを引き、飽和させます。
mm1[63:48] = Sat16u(mm1[63:48] - mm2/m64[63:48])
～
mm1[15:0] = Sat16u(mm1[15:0] - mm2/m64[15:0])
PUNPCKHBW mm1,mm2/m64Unpack High Packed Data
mm1及びmm2/m64からの上位バイトをインターリーブします。
mm1[63:56] = mm2/m64[63:56]
mm1[55:48] = mm1[63:56]
mm1[47:40] = mm2/m64[55:48]
mm1[39:32] = mm1[55:48]
mm1[31:24] = mm2/m64[47:40]
mm1[23:16] = mm1[47:40]
mm1[15:8] = mm2/m64[39:32]
mm1[7:0] = mm1[39:32]
PUNPCKHWD mm1,mm2/m64Unpack High Packed Data
mm1及びmm2/m64からの上位ワードをインターリーブします。
mm1[63:48] = mm2/m64[63:48]
mm1[47:32] = mm1[63:48]
mm1[31:16] = mm2/m64[47:32]
mm1[15:0] = mm1[47:32]
PUNPCKHDQ mm1,mm2/m64Unpack High Packed Data
mm1及びmm2/m64からの上位ダブルワードをインターリーブします。
mm1[63:32] = mm2/m64[63:32]
mm1[31:0] = mm1[63:32]
PUNPCKLBW mm1,mm2/m64Unpack Low Packed Data
mm1及びmm2/m64からの下位バイトをインターリーブします。
mm1[63:56] = mm2/m64[31:24]
mm1[55:48] = mm1[31:24]
mm1[47:40] = mm2/m64[23:16]
mm1[39:32] = mm1[23:16]
mm1[31:24] = mm2/m64[15:8]
mm1[23:16] = mm1[15:8]
mm1[15:8] = mm2/m64[7:0]
mm1[7:0] = mm1[7:0]
PUNPCKLWD mm1,mm2/m64Unpack Low Packed Data
mm1及びmm2/m64からの下位ワードをインターリーブします。
mm1[63:48] = mm2/m64[31:16]
mm1[47:32] = mm1[31:16]
mm1[31:16] = mm2/m64[15:0]
mm1[15:0] = mm1[15:0]
PUNPCKLDQ mm1,mm2/m64Unpack Low Packed Data
mm1及びmm2/m64からの下位ダブルワードをインターリーブします。
mm1[63:32] = mm2/m64[31:0]
mm1[31:0] = mm1[31:0]
PXOR mm1,mm2/m64Logical Exlcusive OR
排他的論理和を求めます。
mm1[63:0] = mm1[63:0] ^ mm2/m64[63:0]

SSEで追加された命令

ADDPS xmm1,xmm2/m128Add Packed Single-Precision Floating-Point Values
パックド単精度実数の和を求めます。
xmm1[127:96] = xmm1[127:96] + xmm2/m128[127:96]
～
xmm1[31:0] = xmm1[31:0] + xmm2/m128[31:0]
ADDSS xmm1,xmm2/m32Add Scalar Single-Precision Floating-Point Values
パックド単精度実数のスカラー和を求めます。
xmm1[31:0] = xmm1[31:0] + xmm2/m32[31:0]
ANDPS xmm1,xmm2/m128Bitwise Logical AND of Packed Sungle-Precision Floating-Point Values
パックド単精度実数の論理積を求めます。
xmm1[127:0] = xmm1[127:0] & xmm2/m128[127:0]
ANDNPS xmm1,xmm2/m128Bitwise Logical AND NOT of Packed Single-Precision Floating-Point Values
xmm1を反転させ、xmm2/m128との論理積を求めます。
xmm1[127:0] = !xmm1[127:0] & xmm2/m128[127:0]
CMPEQPS xmm1,xmm2/m128
CMPLTPS xmm1,xmm2/m128
CMPLEPS xmm1,xmm2/m128
CMPUNORDPS xmm1,xmm2/m128
CMPNEQPS xmm1,xmm2/m128
CMPNLTPS xmm1,xmm2/m128
CMPNLEPS xmm1,xmm2/m128
CMPORDPS xmm1,xmm2/m128 		Compare Packed Single-Precision Floating-Point Values
パックド単精度実数の比較を行います。
CMPEQPS : xmm1 == xmm2/m128
CMPLTPS : xmm1 < xmm2/m128
CMPLEPS : xmm1 <= xmm2/m128
CMPUNORDPS : xmm1 == NaN || xmm2/m128 == NaN
CMPNEQPS : xmm1 != xmm2/m128
CMPNLTPS : xmm1 >= xmm2/m128
CMPNLEPS : xmm1 > xmm1/m128
CMPORDPS : xmm1 != NaN && xmm2/m128 != NaN

xmm1[127:96] = Cmp(xmm1[127:96],xmm2/m128[127:96]) ? FFFFFFFFh : 0
～
xmm1[31:0] = Cmp(xmm1[31:0],xmm2/m128[31:0]) ? FFFFFFFFh : 0
CMPEQSS xmm1,xmm2/m32
CMPLTSS xmm1,xmm2/m32
CMPLESS xmm1,xmm2/m32
CMPUNORDSS xmm1,xmm2/m32
CMPNEQSS xmm1,xmm2/m32
CMPNLTSS xmm1,xmm2/m32
CMPNLESS xmm1,xmm2/m32
CMPORDSS xmm1,xmm2/m32 		Compare Scalar Single-Precision Floating-Point Values
スカラー単精度実数の比較を行います。
CMPEQSS : xmm1 == xmm2/m32
CMPLTSS : xmm1 < xmm2/m32
CMPLESS : xmm1 <= xmm2/m32
CMPUNORDSS : xmm1 == NaN || xmm2/m32 == NaN
CMPNEQSS : xmm1 != xmm2/m32
CMPNLTSS : xmm1 >= xmm2/m32
CMPNLESS : xmm1 > xmm1/m32
CMPORDSS : xmm1 != NaN && xmm2/m32 != NaN

xmm1[31:0] = Cmp(xmm1[31:0],xmm2/m32[31:0]) ? FFFFFFFFh : 0
COMISS xmm1,xmm2/m32Compare Scalar Ordered Single-Precision Floating-Point Values and Set EFLAGS
スカラー単精度実数の比較を行い、結果をEFLAGSに反映させます。
CVTPI2PS xmm,mm/m64Convert Packed Doubleword Integers to Packed Single-Precision Floating-Point Values
パックド符号付き32ビット整数を単精度実数に変換します。
xmm[63:32] = Float(mm/m64[63:32])
xmm[31:0] = Float(mm/m64[31:0])
CVTPS2PI mm,xmm/m64Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
パックド単精度実数を符号付き32ビット整数に変換します。
mm[63:32] = Int(xmm/m64[63:32])
mm[31:0] = Int(xmm/m64[31:0])
CVTSI2SS xmm,r/m32Convert Doubleword Integers to Scalar Single-Precision Floating-Point Value
符号付き32ビット整数を倍精度実数に変換します。
xmm[31:0] = Float(r/m32[31:0])
CVTSS2SI r32,xmm/m32Convert Scalar Single-Precision Floating-Point Value to Doubleword Integer
スカラー単精度実数を符号付き32ビット整数に変換し、汎用レジスタへ格納します。
r32[31:0] = Int(xmm/m32[31:0])
CVTTPS2PI mm,xmm/m64Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
パックド単精度実数を符号付き32ビット整数に丸めます。
mm[63:32] = Intt(xmm/m64[63:32])
mm[31:0] = Intt(xmm/m64[31:0])
CVTTSS2SI r32,xmm/m32Convert with Truncation Scalar Single-Precision Floating-Point Value to Doubleword Integer
スカラー単精度実数を符号付き32ビット整数に丸め、汎用レジスタへ格納します。
r32[31:0] = Int(xmm/m32[31:0])
DIVPS xmm1,xmm2/m128Divide Packed Singkle-Precision Floating-Point Values
パックド単精度実数の除算を行います。
xmm1[127:96] = xmm1[127:96] / xmm2/m128[127:96]
～
xmm1[31:0] = xmm1[31:0] / xmm2/m128[31:0]
DIVSS xmm1,xmm2/m32Divide Scalar Single-Precision Floating-Point Values
スカラー単精度実数の除算を行います。
xmm1[31:0] = xmm1[31:0] / xmm2/m32[31:0]
FXSTOR m512byteResotre x87 FPU,MMX Technology,SSE,and SSE2 State
FPU及びMMX、XMM、MXCSRレジスタの内容を復元します。
FXSAVE m512byteSave x87 FPU,MMX Technology,SSE,and SSE2 State
FPU及びMMX、XMM、MXCSRレジスタの内容を退避します。
LDMXCSR m32Load MXCSR Register
MXCSRレジスタにパラメータをロードします。
MASKMOVDQ mm1,mm2Sotre Selected Bytes of Quadword
mm2によってマスクされたmm1のバイトをメモリに書き込みます。
if(mm2[63]) byte ptr [edi + 56] = mm1[63:56]
～
if(mm2[7]) byte ptr [edi] = mm1[7:0]
MAXPS xmm1,xmm2/m128Return Maximum Packed Single-Precision Floating-Point Values
パックド単精度実数を比較し、大きいほうを返します。
xmm1[127:96] = Max(xmm1[127:96],xmm2/m128[127:96])
～
xmm1[31:0] = Max(xmm1[31:0],xmm2/m128[31:0])
MAXSS xmm1,xmm2/m32Return Maximum Scalar Single-Precision Floating-Point Value
スカラー単精度実数を比較し、大きいほうを返します。
xmm1[31:0] = Max(xmm1[31:0],xmm2/m32[31:0])
MINPS xmm1,xmm2/m128Return Minimum Packed Single-Precision Floating-Point Values
パックド単精度実数を比較し、小さいほうを返します。
xmm1[127:96] = Min(xmm1[127:96],xmm2/m128[127:96])
～
xmm1[31:0] = Min(xmm1[31:0],xmm2/m128[31:0])
MINSS xmm1,xmm2/m32Return Minimum Scalar Single-Precision Floating-Point Value
スカラー単精度実数を比較し、小さいほうを返します。
xmm1[31:0] = Min(xmm1[31:0],xmm2/m32[31:0])
MOVAPS xmm1,xmm2/m128
MOVAPD xmm1/m128,xmm2		Move Aligned Packed Single-Precisin Floating-Point Values
16バイトにアラインされたメモリ領域及びXMMレジスタから、パックド単精度実数を読み書きします。
xmm1/m128 = xmm2/m128
MOVD xmm,r/m32Move Duobleword
XMMレジスタへダブルワードをコピーします。
xmm[127:32] = 0
xmm[31:0] = r/m32[31:0]
MOVHLPS xmm1,xmm2Move Packed Single-Precision Floating-Point Values High to Low
パックド単精度実数の上位クワッドワードを下位クワッドワードにコピーします。
xmm1[63:0] = xmm2[127:64]
MOVHPS xmm,m64
MOVHPS m64,xmm		Move High Packed Single-Precision Floating-Point Values
パックド単精度実数の上位クワッドワードを読み書きします。
xmm[127:64] = m64[63:0]
m64[63:0] = xmm[127:64]
MOVLHPS xmm1,xmm2Move Packed Single-Precision Floating-Point Values Low to High
パックド単精度実数の下位クワッドワードを上位クワッドワードにコピーします。
xmm1[127:64] = xmm2[63:0]
MOVLPS xmm,m64
MOVLPS m64,xmm		Move Los Packed Single-Precision FLoating-Point Values
パックド単精度実数の下位クワッドワードを読み書きします。
xmm1[63:0] = m64[63:0]
m64[63:0] = xmm[63:0]
MOVMSKPS r32,xmmExtract Packed Single-Precision Floating-Point Sign Mask
パックド単精度実数の符号ビットを抽出します。
r32[31:4] = 0
r32[3] = xmm[127]
r32[2] = xmm[95]
r32[2] = xmm[63]
r32[1] = xmm[31]
MOVNTPS m128,xmmStore Packed Single-Precision Floating-Point Values Using Non-Temporal Hint
パックド単精度実数をキャッシュを介さずメモリに書き込みます。
m128 = xmm
MOVNTQ m64,mmStore of Quadword Using Non-Temporal Hint
MMレジスタのクワッドワードをキャッシュを介さずメモリに書き込みます。
m128 = xmm
MOVQ xmm1,xmm2/m64Move Quadword
XMMレジスタ及びメモリから、XMMレジスタへクワッドワードをコピーします。
xmm1[127:64] = 0
xmm1[63:0] = xmm2/m64[63:0]
MOVQ m64,xmmMove Quadword
XMMレジスタからメモリへクワッドワードをコピーします。
m64[63:0] = xmm1[63:0]
MOVSS xmm1,xmm2/m32Move Scalar Single-Precision Floating-Point Value
XMMレジスタ及びメモリから、XMMレジスタへスカラー単精度実数をコピーします。
xmm1[127:32] = 0
xmm1[31:0] = xmm2/m32[31:0]
MOVSS m32,xmmMove Scalar Single-Precision Floating-Point Value
XMMレジスタから、メモリへスカラー単精度実数をコピーします。
m32[31:0] = xmm[31:0]
MOVUPS xmm1,xmm2/m128
MOVUPS xmm1/m128,xmm2		Move Unaligned Packed Single-Precision Floating-Point Values
アラインされていないメモリ領域から、パックド単精度実数をコピーします。
xmm1 = xmm2/m128
xmm1/m128 = xmm2
MULPS xmm1,xmm2/m128Multiply Packed Single-Precision Floating-Point Values
パックド単精度実数の乗算を行います。
xmm1[127:96] = xmm1[127:96] * xmm2/m128[127:96]
～
xmm1[31:0] = xmm1[31:0] * xmm2/m128[31:0]
MULSS xmm1,xmm2/m32Multiply Scalar Single-Precision Floating-Point Values
スカラー単精度実数の乗算を行います。
xmm1[31:0] = xmm1[31:0] * xmm2/m32[31:0]
ORPS xmm1,xmm2/m128Bitwise Logical OR of Single-Precision Floating-Point Values
パックド単精度実数の論理和を求めます。
xmm1[127:0] = xmm1[127:0] | xmm2/m128[127:0]
PACKSSWB xmm1,xmm2/m128
PACKSSDW xmm1,xmm2/m128
PACKUSWB xmm1,xmm2/m128
PADDB xmm1,xmm2/m128
PADDW xmm1,xmm2/m128
PADDD xmm1,xmm2/m128
PADDSB xmm1,xmm2/m128
PADDSW xmm1,xmm2/m128
PADDUSB xmm1,xmm2/m128
PADDUSW xmm1,xmm2/m128
PAND xmm1,xmm2/m128
PANDN xmm1,xmm2/m128
PMADDWD xmm1,xmm2/m128
PMULHW xmm1,xmm2/m128
PMULLW xmm1,xmm2/m128
PSLLW xmm1,xmm2/m128/imm8
PSLLD xmm1,xmm2/m128/imm8
PSLLQ xmm1,xmm2/m128/imm8
PSRAW xmm1,xmm2/m128/imm8
PSRAD xmm1,xmm2/m128/imm8
PSRLW xmm1,xmm2/m128/imm8
PSRLD xmm1,xmm2/m128/imm8
PSRLQ xmm1,xmm2/m128/imm8
PSUBB xmm1,xmm2/m128
PSUBW xmm1,xmm2/m128
PSUBD xmm1,xmm2/m128
PSUBSB xmm1,xmm2/m128
PSUBSW xmm1,xmm2/m128
PSUBUSB xmm1,xmm2/m128
PSUBUSW xmm1,xmm2/m128
PUNPCKHBW xmm1,xmm2/m128
PUNPCKHWD xmm1,xmm2/m128
PUNPCKHDQ xmm1,xmm2/m128
PUNCPKLBW xmm1,xmm2/m128
PUNPCKLWD xmm1,xmm2/m128
PUNPCKLDQ xmm1,xmm2/m128
PXOR xmm1,xmm2/m128 		-
オペランドにXMMレジスタが使用できるようになり、128ビットに拡張されたほかは MMXのものと同様です。
PAVGB mm1,mm2/m64
PAVGB xmm1,xmm2/m128		Average Packed Integers
符号無しパックドバイトの平均を求めます。
mm1[63:56] = (mm1[63:56] + mm2/m64[63:56] + 1)>>1
～
mm1[7:0] = (mm1[7:0] + mm2/m64[7:0] + 1)>>1

xmm1[127:120] = (xmm1[127:120] + xmm2/m128[127:120] + 1)>>1
～
xmm1[7:0] = (xmm1[7:0] + xmm2/m128[7:0] + 1)>>1
PAVGW mm1,mm2/m64
PAVGW xmm1,xmm2/m128		Average Packed Integers
符号無しパックドワードの平均を求めます。
mm1[63:48] = (mm1[63:48] + mm2/m64[63:48] + 1)>>1
～
mm1[15:0] = (mm1[15:0] + mm2/m64[15:0] + 1)>>1

xmm1[127:112] = (xmm1[127:112] + xmm2/m128[127:112] + 1)>>1
～
xmm1[15:0] = (xmm1[15:0] + xmm2/m128[15:0] + 1)>>1
PEXTRW r32,mm/xmm,imm8Extract Word
MMレジスタ及びXMMレジスタから、指定したワードを抽出します。
r32[31:0] = 0
r32[15:0] = mm/xmm[imm8*16 + 15:imm8*16]
PINSRW mm/xmm,r32/m16,imm8Insert Word
MMレジスタ及びXMMレジスタの指定した位置にワードを挿入します。
mm/xmm[imm8*16 + 15:imm8*16] = r32/m16[15:0]
PMAXSW mm1,mm2/m64
PMAXSW xmm1,xmm2/m128		Maximum of Packed Signed Word Integers
符号付きパックドワードの、大きいほうを返します。
mm1[63:48] = Max(mm1[63:48},mm2/m64[63:48])
～
mm1[15:0] = Max(mm1[15:0},mm2/m64[15:0])

xmm1[127:112] = Max(xmm1[127:112},mm2/m128[127:112])
～
xmm1[15:0] = Max(xmm1[15:0},xmm2/m128[15:0])
PMAXUB mm1,mm2/m64
PMAXUB xmm1,xmm2/m128		Maximum of Packed Unsigned Byte Integers
符号無しパックドバイトの、大きいほうを返します。
mm1[63:56] = Max(mm1[63:56},mm2/m64[63:56])
～
mm1[7:0] = Max(mm1[7:0},mm2/m64[7:0])

xmm1[127:120] = Max(xmm1[127:120},mm2/m128[127:120])
～
xmm1[7:0] = Max(xmm1[7:0},xmm2/m128[7:0])
PMINSW mm1,mm2/m64
PMINSW xmm1,xmm2/m128		Minimum of Packed Signed Word Integers
符号付きパックドワードの、小さいほうを返します。
mm1[63:48] = Min(mm1[63:48},mm2/m64[63:48])
～
mm1[15:0] = Min(mm1[15:0},mm2/m64[15:0])

xmm1[127:112] = Min(xmm1[127:112},mm2/m128[127:112])
～
xmm1[15:0] = Min(xmm1[15:0},xmm2/m128[15:0])
PMINUB mm1,mm2/m64
PMINUB xmm1,xmm2/m128		Miniimum of Packed Unsigned Byte Integers
符号無しパックドバイトの、小さいほうを返します。
mm1[63:56] = Min(mm1[63:56},mm2/m64[63:56])
～
mm1[7:0] = Min(mm1[7:0},mm2/m64[7:0])

xmm1[127:120] = Min(xmm1[127:120},mm2/m128[127:120])
～
xmm1[7:0] = Min(xmm1[7:0},xmm2/m128[7:0])
PMOVMSKB r32,mm/xmmMove Byte Mask
パックドバイトの各最上位ビットを返します。
r32[31:16] = 0
r32[15] = xmm[127]
～
r32[0] = mm/xmm[7]
PMULHUW mm1,mm2/m64
PMULHUW xmm1,xmm2/m128		Multiply Packed Unsigned Integers and Store High Result
符号無しパックドワードの乗算を行い、上位ワードを返します。
mm1[63:48] = (mm1[63:48] * mm2/m64[64:48])>>16
～
mm1[15:0] = (mm1[15:0] * mm2/m64[15:0])>>16

xmm1[127:112] = (xmm1[127:112] * xmm2/m128[127:112])>>16
～
xmm1[15:0] = (xmm1[15:0] * xmm2/m128[15:0])>>16
PREFETCHT0 m8
PREFETCHT1 m8
PREFETCHT2 m8
PREFETCHNTA m8		 Prefetch Data Into Caches
キャッシュへ32バイトのデータを読み込みます。
T0 : １次/２次キャッシュへ読み込み
T1 : ２次キャッシュへ読み込み
T2 : ２次キャッシュへ読み込み
NTA : １次キャッシュへ読み込み
PSADBW mm1,mm2/m64
xmm1,xmm2/m128		Compute Sum of Absolute Differences
符号無しパックドワードの差の絶対値の総和を求めます。
mm1[63:16] = 0
mm1[15:0] = Abs(mm1[63:48] - mm2/m64[63:48]) + ... + Abs(mm1[15:0] - mm2/m64[15:0]

xmm1[127:16] = 0
xmm1[15:0] = Abs(xmm1[127:112] - xmm2/m128[127:112]) + ... + Abs(xmm1[15:0] - xmm2/m128[15:0]
PSHUFW mm1,mm2/m64,imm8Shuffle Packed Words
パックドワードの並べ替えを行います。
Index3 = imm8[7:6]*16
Index2 = imm8[5:4]*16
Index1 = imm8[3:2]*16
Index0 = imm8[1:0]*16
mm1[63:48] = mm2/m64[Index3 + 15,Index3]
mm1[47:32] = mm2/m64[Index2 + 15,Index2]
mm1[31:16] = mm1[Index1 + 15,Index1] mm1[15:0] = mm1[Index0 + 15,Index0]
RCPPS xmm1,xmm2/m128Compute Reciprocals of Packed Single-Precision Floating-Point Values
パックド単精度実数の逆数の近似値を返します。
xmm1[127:96] = 1/xmm2[127:96]
～
xmm1[31:0] = 1/xmm2[31:0]
RCPSS xmm1,xmm2/m32Compute Reciprocals of Scalar Single-Precision Floating-Point Values
スカラー単精度実数の逆数の近似値を返します。
xmm1[31:0] = 1/xmm2[31:0]
RSQRTPS xmm1,xmm2/m128Compute Reciprocals of Square Roots of Packed Single-Precision Floating-Point Values
パックド単精度実数の平方根の逆数の近似値を返します。
xmm1[127:96] = 1/Sqrt(xmm2/m128[127:96])
～
xmm1[31:0] = 1/Sqrt(xmm2/m128[31:0])
RSQRTSS xmm1,xmm2/m128Compute Reciprocals of Square Roots of Scalar Single-Precision Floating-Point Values
スカラー単精度実数の平方根の逆数の近似値を返します。
xmm1[31:0] = 1/Sqrt(xmm2/m128[31:0])
SFENCEStore Fence
ストア操作をシリアル化します。
SHUFPS xmm1,xmm2/m128,imm8Shuffle Packed Single-Precision Floating-Point Values
パックド単精度実数を並べ替えます。
Index3 = imm8[7:6]*32
Index2 = imm8[5:4]*32
Index1 = imm8[3:2]*32
Index0 = imm8[1:0]*32
xmm1[127:96] = xmm2/m128[Index3 + 31:Index3]
xmm1[95:64] = xmm2/m128[Index2 + 31:Index2]
xmm1[63:32] = xmm1[Index1 + 31:Index1]
xmm1[31:0] = xmm1[Index0 + 31:Index0]
SQRTPS xmm1,xmm2/m128Compute Square Roots of Packed Single-Precision Floating-Point Values
パックド単精度実数の平方根を求めます。
xmm1[127:96] = Sqrt(xmm2/m128[127:96])
～
xmm1[31:0] = Sqrt(xmm2/m128[31:0])
SQRTSS xmm1,xmm2/m32Compute Square Roots of Scalar Single-Precision Floating-Point Values
スカラー単精度実数の平方根を求めます。
xmm1[31:0] = Sqrt(xmm2/m32[31:0])
STMXCSR m32Store MXCSR Register State
MXCSRレジスタの内容をストアします。
SUBPS xmm1,xmm2/m128Subtract Packed Single-Precision Floating-Point Values
パックド単精度実数の減算を行います。
xmm1[127:96] = xmm1[127:96] - xmm2/m128[127:96]
～
xmm1[31:0] = xmm1[31:0] - xmm2/m128[31:0]
SUBSS xmm1,xmm2/m32Subtract Scalar Single-Precision Floating-Point Values
スカラー単精度実数の減算を行います。
xmm1[31:0] = xmm1[31:0] - xmm2/m64[31:0]
UCOMISS xmm1,xmm2/m32Unordered Compare Scalar Single-Precision Floating-Point Values and Set EFLAGS
スカラー単精度実数の比較を行い、結果をEFLAGSに反映させます。
一方がNaNのとき、XF、PF、CFの全てが立ちます。
UNPCKHPS xmm1,xmm2/m128Unpack and Interleave High Pakced Single-Precision Floating-Point Values
xmm1及びxmm2/m128からの上位単精度実数をインターリーブします。
xmm1[127:96] = xmm2/m128[127:96]
xmm1[95:64] = xmm1[127:96]
xmm1[63:32] = xmm2/m128[95:64]
xmm1[31:0] = xmm1[95:64]
UNPCKLPS xmm1,xmm2/m128Unpack and Interleave Low Pakced Single-Precision Floating-Point Values
xmm1及びxmm2/m128からの下位単精度実数をインターリーブします。
xmm1[127:96] = xmm2/m128[63:32]
xmm1[95:64] = xmm1[63:32]
xmm1[63:32] = xmm2/m128[31:0]
xmm1[31:0] = xmm1[31:0]
XORPS xmm1,xmm2/m128Bitwise Logical XOR for Single-Precision Floating-Point Values
パックド単精度実数の排他的論理和を取ります。
xmm1[127:0 ] = xmm1[127:0] ^ xmm2/m128[127:0}

SSE2で追加された命令

ADDPD xmm1,xmm2/m128Add Packed Double-Precision Floating-Point Values
パックド倍精度実数の和を求めます。
xmm1[127:64] = xmm1[127:64] + xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] + xmm2/m128[63:0
ADDSD xmm1,xmm2/m64Add Scalar Double-Precision Floating-Point Values
パックド倍精度実数のスカラー和を求めます。
xmm1[63:0] = xmm1[63:0] + xmm2/m64[63:0]
ANDPD xmm1,xmm2/m128Bitwise Logical AND of Packed Double-Precision Floating-Point Values
パックド倍精度実数の論理積を求めます。
xmm1[127:0] = xmm1[127:0] & xmm2/m128[127:0]
ANDNPD xmm1,xmm2/m128Bitwise Logical AND NOT of Packed Double-Precision Floating-Point Values
xmm1を反転させ、xmm2/m128との論理積を求めます。
xmm1[127:0] = !xmm1[127:0] & xmm2/m128[127:0]
CLFLUSH m8Flush Cache Line
32バイト分のキャッシュをフラッシュします。
CMPEQPD xmm1,xmm2/m128
CMPLTPD xmm1,xmm2/m128
CMPLEPD xmm1,xmm2/m128
CMPUNORDPD xmm1,xmm2/m128
CMPNEQPD xmm1,xmm2/m128
CMPNLTPD xmm1,xmm2/m128
CMPNLEPD xmm1,xmm2/m128
CMPORDPD xmm1,xmm2/m128 		Compare Packed Double-Precision Floating-Point Values
パックド倍精度実数の比較を行います。
CMPEQPD : xmm1 == xmm2/m128
CMPLTPD : xmm1 < xmm2/m128
CMPLEPD : xmm1 <= xmm2/m128
CMPUNORDPD : xmm1 == NaN || xmm2/m128 == NaN
CMPNEQPD : xmm1 != xmm2/m128
CMPNLTPD : xmm1 >= xmm2/m128
CMPNLEPD : xmm1 > xmm1/m128
CMPORDPD : xmm1 != NaN && xmm2/m128 != NaN

xmm1[127:64] = Cmp(xmm1[127:64],xmm2/m128[127:64]) ? FFFFFFFFFFFFFFFFh : 0
xmm1[63:0] = Cmp(xmm1[63:0],xmm2/m128[63:0]) ? FFFFFFFFFFFFFFFFh : 0
CMPEQSD xmm1,xmm2/m64
CMPLTSD xmm1,xmm2/m64
CMPLESD xmm1,xmm2/m64
CMPUNORSD xmm1,xmm2/m64
CMPNEQSD xmm1,xmm2/m64
CMPNLTSD xmm1,xmm2/m64
CMPNLESD xmm1,xmm2/m64
CMPORDSD xmm1,xmm2/m64 		Compare Scalar Double-Precision Floating-Point Values
スカラー倍精度実数の比較を行います。
CMPEQSD : xmm1 == xmm2/m64
CMPLTSD : xmm1 < xmm2/m64
CMPLESD : xmm1 <= xmm2/m64
CMPUNORDSD : xmm1 == NaN || xmm2/m64 == NaN
CMPNEQSD : xmm1 != xmm2/m64
CMPNLTSD : xmm1 >= xmm2/m64
CMPNLESD : xmm1 > xmm1/m64
CMPORDSD : xmm1 != NaN && xmm2/m64 != NaN

xmm1[63:0] = Cmp(xmm1[63:0],xmm2/m64[63:0]) ? FFFFFFFFFFFFFFFFh : 0
COMISD xmm1,xmm2/m64Compare Scalar Ordered Double-Precision Floating-Point Values and Set EFLAGS
スカラー倍精度実数の比較を行い、結果をEFLAGSに反映させます。
CVTDQ2PD xmm1,xmm2/m64Convert Packed Doubleword Integer to Packed Double-Precision Floating-Point Values
パックド符号付き32ビット整数を倍精度実数に変換します。
xmm1[127:64] = Double(xmm2/m64[63:32])
xmm1[63:0] = Double(xmm2/m64[31:0])
CVTDQ2PS xmm1,xmm2/m128Convert Packed Doubleword Integer to Packed Single-Precision Floating-Point Values
パックド符号付き32ビット整数を単精度実数に変換します。
xmm1[127:96] = Double(xmm2/m128[127:96])
～
xmm1[31:0] = Double(xmm2/m128[31:0])
CVTPD2DQ xmm1,xmm2/m128Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
パックド倍精度実数を符号付き32ビット整数に変換します。
xmm1[127:64] = 0
xmm1[63:32] = Int(xmm2/m128[127:64])
xmm1[31:0] = Int(xmm2/m128[63:0])
CVTPD2PI mm,xmm/m128Convert Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
パックド倍精度実数を符号付き32ビット整数に変換し、MMレジスタへ格納します。
mm[63:32] = Int(xmm/m128[127:64])
mm[31:0] = Int(xmm/m128[63:0])
CVTPD2PS xmm1,xmm2/m128Convert Packed Double-Precision Floating-Point Values to Packed Single-Precision Floating-Point Values
パックド倍精度実数を単精度実数へ変換します。
xmm1[127:64] = 0
xmm1[63:32] = Float(xmm2/m128[127:64])
xmm1[31:0] = Float(xmm2/m128[63:0])
CVTPI2PD xmm,mm/m64Convert Packed Doubleword Integers to Packed Double-Precision Floating-Point Values
パックド符号付き32ビット整数を倍精度実数に変換します。
xmm[127:64] = Double(mm/m64[63:32])
xmm[63:0] = Double(mm/m64[31:0])
CVTPS2DQ xmm1,xmm2/m128Convert Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
パックド単精度実数を符号付き32ビット整数に変換します。
xmm1[127:96] = Int(xmm2/m128[127:96])
～
xmm1[31:0] = Int(xmm2/m128[31:0])
CVTPS2PD xmm1,xmm2/m64Convert Packed Single-Precision Floating-Point Values to Packed Double-Precision Floating-Point Values
パックド単精度実数を倍精度実数に変換します。
xmm1[127:64] = Double(xmm2/m64[63:32])
xmm1[63:0] = Double(xmm2/m64[31:0])
CVTSD2SI r32,xmm/m64Convert Scalar Double-Precision Floating-Point Values to Doubleword Integer
スカラー倍精度実数を符号付き32ビット整数に変換し、汎用レジスタへ格納します。
r32[31:0] = Int(xmm/m64[63:0])
CVTPSD2SS xmm1,xmm2/m64Convert Packed Scalar Double-Precision Floating-Point Values to Packed Scalar Single-Precision Floating-Point Values
スカラー倍精度実数を単精度実数に変換します。
xmm1[31:0] = Float(xmm2/m64[63:0])
CVTSI2SD xmm,r/m32Convert Doubleword Integers to Scalar Double-Precision Floating-Point Value
符号付き32ビット整数を倍精度実数に変換します。
xmm[63:0] = Double(r/m32[31:0])
CVTPSS2SD xmm1,xmm2/m32Convert Packed Scalar Single-Precision Floating-Point Value to Packed Scalar Double-Precision Floating-Point Value
スカラー単精度実数を倍精度実数に変換します。
xmm1[63:0] = Double(xmm2/m32[31:0])
CVTTPD2PI mm,xmm/m128Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
パックド倍精度実数を符号付き32ビット整数に丸め、MMレジスタへ格納します。
mm[63:32] = Intt(xmm/m128[127:64])
mm[31:0] = Intt(xmm/m128[63:0])
CVTTPD2DQ xmm1,xmm2/m128Convert with Truncation Packed Double-Precision Floating-Point Values to Packed Doubleword Integers
パックド倍精度実数を符号付き32ビット整数に丸めます。
xmm1[127:64] = 0
xmm1[63:32] = Intt(xmm2/m128[127:64])
xmm1[31:0] = Intt(xmm2/m128[63:0])
CVTTPS2DQ xmm1,xmm2/m128Convert with Truncation Packed Single-Precision Floating-Point Values to Packed Doubleword Integers
パックド単精度実数を符号付き32ビット整数に丸めます。
xmm1[127:96] = Int(xmm2/m128[127:96])
～
xmm1[31:0] = Int(xmm2/m128[31:0])
CVTTSD2SI r32,xmm/m64Convert with Truncation Scalar Double-Precision Floating-Point Values to Doubleword Integer
スカラー倍精度実数を符号付き32ビット整数に丸め、汎用レジスタへ格納します。
r32[31:0] = Int(xmm/m64[63:0])
DIVPD xmm1,xmm2/m128Divide Packed Double-Precision Floating-Point Values
パックド倍精度実数の除算を行います。
xmm1[127:64] = xmm1[127:64] / xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] / xmm2/m128[63:0]
DIVSD xmm1,xmm2/m64Divide Scalar Double-Precision Floating-Point Values
スカラー倍精度実数の除算を行います。
xmm1[63:0] = xmm1[63:0] / xmm2/m64[63:0]
LFENCELoad Fence
ロード動作をシリアル化します。
MASKMOVDQU xmm1,xmm2Sotre Selected Bytes of Double Quadword
xmm2によってマスクされたxmm1のバイトをメモリに書き込みます。
if(xmm2[127]) byte ptr [edi + 120] = xmm1[127:120]
～
if(xmm2[7]) byte ptr [edi] = xmm1[7:0]
MAXPD xmm1,xmm2/m128Return Maximum Packed Double-Precision Floating-Point Values
パックド倍精度実数を比較し、大きいほうを返します。
xmm1[127:64] = Max(xmm1[127:64],xmm2/m128[127:64])
xmm1[63:0] = Max(xmm1[63:0],xmm2/m128[63:0])
MAXSD xmm1,xmm2/m64Return Maximum Scalar Double-Precision Floating-Point Value
スカラー倍精度実数を比較し、大きいほうを返します。
xmm1[63:0] = Max(xmm1[63:0],xmm2/m64[63:0])
MFENCEMemory Fence
ロードとストアをシリアル化します。
MINPD xmm1,xmm2/m128Return Minimum Packed Double-Precision Floating-Point Values
パックド倍精度実数を比較し、小さいほうを返します。
xmm1[127:64] = Min(xmm1[127:64],xmm2/m128[127:64])
xmm1[63:0] = Min(xmm1[63:0],xmm2/m128[63:0])
MINSD xmm1,xmm2/m64Return Minimum Scalar Double-Precision Floating-Point Value
スカラー倍精度実数を比較し、小さいほうを返します。
xmm1[63:0] = Min(xmm1[63:0],xmm2/m64[63:0])
MOVAPD xmm1,xmm2/m128
MOVAPD xmm1/m128,xmm2		Move Aligned Packed Double-Precisin Floating-Point Values
16バイトにアラインされたメモリ領域及びXMMレジスタから、パックド倍精度実数を読み書きします。
xmm1/m128 = xmm2/m128
MOVDQA xmm1,xmm2/m128
MOVDQA xmm1/m128,xmm2		Move Aligned Double Quadword
16バイトにアラインされたメモリ領域及びXMMレジスタから、128ビット整数を読み書きします。
xmm1/m128 = xmm2/m128
MOVDQU xmm1,xmm2/m128
MOVDQA xmm1/m128,xmm2		Move Unaligned Double Quadword
アラインされていないメモリ領域及びXMMレジスタから、128ビット整数を読み書きします。
xmm1/m128 = xmm2/m128
MOVDQ2Q mm,xmmMove Quadword from XMM to MMX Technology Register
XMMレジスタからMMレジスタへクワッドワードをコピーします。
mm[63:0] = xmm[63:0]
MOVHPD xmm,m64
MOVHPD m64,xmm		Move High Paked Double-Precision Floating-Point Value
パックド倍精度実数の上位クワッドワードを読み書きします。
xmm[127:64] = m64[63:0]
m64[63:0] = xmm[127:64]
MOVLPD xmm,m64
MOVLPD m64,xmm		Move Low Packed Double-Precision Floating-Point Value
パック倍精度実数の下位クワッドワードを読み書きします。
xmm[63:0] = m64[63:0]
m64[63:0] = xmm[63:0]
MOVMSKPD r32,xmmExtract Packed Double-Precision Floating-Point Sign Mask
パックド倍精度実数の符号ビットを抽出します。
r32[31:2] = 0
r32[1] = xmm[127]
r32[0] = xmm[63]
MOVNTDQ m128,xmmStore Double Quadword Using Non-Temporal Hint
xmmのダブルクワッドワードをキャッシュを介さずメモリに書き込みます。
m128 = xmm
MOVNTI m32,r32Store Doubleword Using Non-Temporal Hint
r32のダブルワードをキャッシュを介さずメモリに書き込みます。
m32 = r32
MOVNTPD m128,xmmStore Packed Double-Precision Floating-Point Values Using Non-Temporal Hint
パックド倍精度実数をキャッシュを介さずメモリに書き込みます。
m128 = xmm
MOVQ2DQ xmm,mmMove Quadword from MMX Technology to XMM Register
MMレジスタからXMMレジスタへクワッドワードをコピーします。
xmm[127:64] = 0
xmm[63:0] = mm[63:0]
MOVSD xmm1,xmm2/m64Move Scalar Double-Precision Floating-Point Value
XMMレジスタ及びメモリから、XMMレジスタへスカラー倍精度実数をコピーします。
xmm1[127:64] = 0
xmm1[63:0] = xmm2/m64[63:0]
MOVSD m64,xmmMove Scalar Double-Precision Floating-Point Value
XMMレジスタから、メモリへスカラー倍精度実数をコピーします。
m64[63:0] = xmm[63:0]
MOVUPD xmm1,xmm2/m128
MOVUPS xmm1/m128,xmm2		Move Unaligned Packed Double-Precision Floating-Point Values
アラインされていないメモリ領域から、パックド倍精度実数をコピーします。
xmm1 = xmm2/m128
xmm1/m128 = xmm2
MULPD xmm1,xmm2/m128Multiply Packed Double-Precision Floating-Point Values
パックド倍精度実数の乗算を行います。
xmm1[127:64] = xmm1[127:64] * xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] * xmm2/m128[63:0]
MULSD xmm1,xmm2/m64Multiply Scalar Double-Precision Floating-Point Values
スカラー倍精度実数の乗算を行います。
xmm1[63:0] = xmm1[63:0] * xmm2/m64[63:0]
ORPD xmm1,xmm2/m128Bitwise Logical OR of Doulbe-Precision Floating-Point Values
パックド倍精度実数の論理和を求めます。
xmm1[127:0] = xmm1[127:0] | xmm2/m128[127:0]
PADDQ mm1,mm2/m64
PADDQ xmm1,xmm2/m128		Add Packed Quadword Integers
パックド64ビット整数の加算を行います。
mm1[63:0] = mm1[63:0] + mm2/m64[63:0]

xmm1[127:64] = xmm1[127:64] + xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] + xmm2/m128[63:0
PMULUDQ mm1,mm2/m64
PMULUDQ xmm1,xmm2/m128		Multiply Packed Unsigned Doubleword Integers
符号無しパックドダブルワードの積を求めます。
mm1[63:0] = mm1[31:0] * mm2/m64[63:0]

xmm1[127:64] = xmm1[95:64] * xmm2/m128[95:64]
xmm1[63:0] = xmm1[31:0] * xmm2/m128[31:0]
PSHUFD xmm1,xmm2/m128,imm8Shuffle Packed Doublewords
パックドダブルワードの並べ替えを行います。
Index3 = imm8[7:6]*32
Index2 = imm8[5:4]*32
Index1 = imm8[3:2]*32
Index0 = imm8[1:0]*32
xmm1[127:96] = xmm2/m128[Index3 + 31,Index3]
～
xmm1[31:0] = xmm2/m128[Index0 + 31,Index0]
PSHUFHW xmm1,xmm2/m128,imm8Shuffle Packed High Words
パックドワードの上位4ワードの並べ替えを行います。
Index3 = imm8[7:6]*16
Index2 = imm8[5:4]*16
Index1 = imm8[3:2]*16
Index0 = imm8[1:0]*16
xmm1[127:112] = xmm2/m128[Index3 + 15 + 64,Index3 + 64]
～
xmm1[79:64] = xmm2/m128[Index0 + 15 + 64,Index0 + 64]
xmm1[63:0] = xmm2/m128[63:0]
PSHUFLW xmm1,xmm2/m128,imm8Shuffle Packed Low Words
パックドワードの下位4ワードの並べ替えを行います。
Index3 = imm8[7:6]*16
Index2 = imm8[5:4]*16
Index1 = imm8[3:2]*16
Index0 = imm8[1:0]*16
xmm1[127:64] = xmm2/m128[127:64]
xmm1[63:48] = xmm2/m128[Index3 + 15,Index3]
～
xmm1[15:0] = xmm2/m128[Index0 + 15,Index0]
PSLLDQ xmm,imm8Shift Double Quadword Left Logical
ダブルクワッドワードを左シフトします。
xmm = xmm << imm8
PSRLDQ xmm,imm8Shift Double Quadword Right Logical
ダブルクワッドワードを右論理シフトします。
xmm = xmm >> imm8
PSUBQ mm1,mm2/m64
PSUBQ xmm1,xmm2/m128		Subtract Packed Quadword Integers
パックドクワッドワードの差を求めます。
mm1[63:0] = mm1[63:0] - mm2/m64[63:0]

xmm1[127:64] = xmm1[127:64] - xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] - xmm2/m128[63:0]
PUNPCKHQDQ xmm1,xmm2/m128Unpack High Data
xmm1及びxmm2/m128からの上位クワッドワードをインターリーブします。
xmm1[127:64] = xmm2/m128[127:64]
xmm1[63:0] = xmm1[127:64]
PUNPCKLQDQ xmm1,xmm2/m128Unpack Low Data
xmm1及びxmm2/m128からの下位クワッドワードをインターリーブします。
xmm1[127:64] = xmm2/m128[63:0]
xmm1[63:0] = xmm1[63:0]
SHUFPD xmm1,xmm2/m128,imm8Shuffle Packed Double-Precision Floating-Point Values
パックド倍精度実数を並べ替えます。
Index1 = imm8[1]*64
Index0 = imm8[0]*64
xmm1[127:64] = xmm2/m128[Index1 + 63:Index1]
xmm1[63:0] = xmm1[Index0 + 63:Index0]
SQRTPD xmm1,xmm2/m128Compute Square Roots of Packed Double-Precision Floating-Point Values
パックド倍精度実数の平方根を求めます。
xmm1[127:64] = Sqrt(xmm2/m128[127:64])
xmm1[63:0] = Sqrt(xmm2/m128[63:0])
SQRTSD xmm1,xmm2/m64Compute Square Roots of Scalar Double-Precision Floating-Point Values
スカラー倍精度実数の平方根を求めます。
xmm1[63:0] = Sqrt(xmm2/m64[63:0])
SUBPD xmm1,xmm2/m128Subtract Packed Double-Precision Floating-Point Values
パックド倍精度実数の減算を行います。
xmm1[127:64] = xmm1[127:64] - xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] - xmm2/m128[63:0]
SUBSD xmm1,xmm2/m64Subtract Scalar Double-Precision Floating-Point Values
スカラー倍精度実数の減算を行います。
xmm1[63:0] = xmm1[63:0] - xmm2/m64[63:0]
UCOMISD xmm1,xmm2/m64Unordered Compare Scalar Double-Precision Floating-Point Values and Set EFLAGS
スカラー倍精度実数の比較を行い、結果をEFLAGSに反映させます。
一方がNaNのとき、XF、PF、CFの全てが立ちます。
UNPCKHPD xmm1,xmm2/m128Unpack and Interleave High Pakced Double-Precision Floating-Point Values
xmm1及びxmm2/m128からの上位倍精度実数をインターリーブします。
xmm1[127:64] = xmm2/m128[127:64]
xmm1[63:0] = xmm1[127:64]
UNPCKLPD xmm1,xmm2/m128Unpack and Interleave Low Pakced Double-Precision Floating-Point Values
xmm1及びxmm2/m128からの下位倍精度実数をインターリーブします。
xmm1[127:64] = xmm2/m128[63:0]
xmm1[63:0] = xmm1[63:0]
XORPD xmm1,xmm2/m128Bitwise Logical XOR for Double-Precision Floating-Point Values
パックド倍精度実数の排他的論理和を取ります。
xmm1[127:0 ] = xmm1[127:0] ^ xmm2/m128[127:0}

SSE3で追加された命令

ADDSUBPD xmm1,xmm2/m128Packed Double-FP Add/Subtract
パックド倍精度実数の和と差を求めます。
xmm1[127:64] = xmm1[127:64] + xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0] - xmm2/m128[63:0]
ADDSUBPS xmm1,xmm2/m128Packed Single-FP Add/Subtract
パックド倍精度実数の和と差を求めます。
xmm1[127:96] = xmm1[127:96] + xmm2/m128[127:96]
xmm1[95:64] = xmm1[95:64] - xmm2/m128[95:64]
xmm1[63:32] = xmm1[63:32] + xmm2/m128[63:32]
xmm1[31:0] = xmm1[31:0] - xmm2/m128[31:0]
FISTTP m16/m32/m64Store Integer with Truncation
FPUレジスタの内容を符号付き整数に丸めてストアし、レジスタをポップします。
m16/m32/m64 = st(0)
pop st(0)
HADDPD xmm1,xmm2/m128Packed Doube-FP Horizontal Add
パックド倍精度実数の上下クワッドワードの加算を行います。
xmm1[127:64] = xmm2/m128[63:0} + xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0} + xmm1[127:64]
HADDPS xmm1,xmm2/m128Packed Single-FP Horizontal Add
パックド単精度実数の上下ダブルワードの加算を行います。
xmm1[127:96] = xmm2/m128[95:64} + xmm2/m128[127:96]
xmm1[95:64] = xmm2/m128[31:0} + xmm2/m128[63:32]
xmm1[63:32] = xmm1[95:64} + xmm1[127:96]
xmm1[31:0] = xmm1[31:0} + xmm1[63:32]
HSUBPD xmm1,xmm2/m128Packed Doube-FP Horizontal Subtract
パックド倍精度実数の上下クワッドワードの減算を行います。
xmm1[127:64] = xmm2/m128[63:0} - xmm2/m128[127:64]
xmm1[63:0] = xmm1[63:0} - xmm1[127:64]
HSUBPS xmm1,xmm2/m128Packed Single-FP Horizontal Subtract
パックド単精度実数の上下ダブルワードの減算を行います。
xmm1[127:96] = xmm2/m128[95:64} - xmm2/m128[127:96]
xmm1[95:64] = xmm2/m128[31:0} - xmm2/m128[63:32]
xmm1[63:32] = xmm1[95:64} - xmm1[127:96]
xmm1[31:0] = xmm1[31:0} - xmm1[63:32]
LDDQU xmm,memLoad Unaligned Integer 128 bits
アラインされていない領域から、128ビット読み出します。
xmm[127:0] = mem128
MONITOR<>MWAITSetup Monitor Address
Monitor Wait
特権命令です。一般のアプリケーションには関係ありません。
MOVDDUP xmm1,xmm2/m64Move One Double-FP and Duplicate
倍精度実数を複製して格納します。
xmm1[127:64] = xmm1[63:0] = xmm2/m64[63:0]
MOVSHDUP xmm1,xmm2/m128Move Packed Single-FP High and Duplicate
パックド単精度実数の上位ダブルワードを複製して格納します。
xmm1[127:96] = xmm1[95:64] = xmm2/m128[127:96]
xmm1[63:32] = xmm1[31:0] = xmm2/m128[63:32]
MOVSLDUP xmm1,xmm2/m128Move Packed Single-FP Low and Duplicate
パックド単精度実数の下位ダブルワードを複製して格納します。
xmm1[127:96] = xmm1[95:64] = xmm2/m128[95:64]
xmm1[63:32] = xmm1[31:0] = xmm2/m128[31:0]

3DNow!で追加された命令

FEMMSFaster Enter/Exit of the MMX of floating-point state
FPUタグワードを空にします。
MMX/3DNow!命令を使った後は、この命令を実行する必要があります。
PAVGUSB mm1,mm2/m64Average of unsigned packed 8-bit values
符号無し8ビット整数8組の平均を求めます。
mm1[63:56] = (mm1[63:56] + mm2/m64[63:56] + 1)>>1
～
mm1[7:0] = (mm1[7:0] + mm2/m64[7:0] + 1)>>1
PF2ID mm1,mm2/m64Converts packed floating-point operand to packed 32-bit integer
単精度実数を32ビット符号付き整数にして飽和させます。
mm1[63:32] = Sat32s(Int(mm2/m64[63:32]))
mm1[31:0] = Sat32s(Int(mm2/m64[31:0]))
PFACC mm1,mm2/m64Floating-point accumulate
パックド単精度実数の上位と下位の和を求めます。
mm1[63:32] = mm2/m64[31:0] + mm2/m64[63:32]
mm1[31:0] = mm1[31:0] + mm1[63:32]
PFADD mm1,mm2/m64Packed floating-point addition
パックド単精度実数の和を求めます。
mm1[63:32] = mm1[63:32] + mm2/m64[63:32]
mm1[31:0] = mm1[31:0] + mm2/m64[31:0]
PFCMPEQ mm1,mm2/m64Packed floating-point comparison,equal to
パックド単精度実数の等しいかどうかの比較を行います。
mm1[63:32] = mm1[63:32] == mm2/m64[63:32] ? FFFFFFFFh : 0
mm1[31:0] = mm1[32:0] == mm2/m64[32:0] ? FFFFFFFFh : 0
PFCMPGE mm1,mm2/m64Packed floating-point comparison,greater than or equal to
パックド単精度実数の以上かどうか比較を行います。
mm1[63:32] = mm1[63:32] >= mm2/m64[63:32] ? FFFFFFFFh : 0
mm1[31:0] = mm1[32:0] >= mm2/m64[32:0] ? FFFFFFFFh : 0
PFCMPGT mm1,mm2/m64Packed floating-point comparison,greater than
パックド単精度実数のより大きいかどうかの比較を行います。
mm1[63:32] = mm1[63:32] > mm2/m64[63:32] ? FFFFFFFFh : 0
mm1[31:0] = mm1[32:0] > mm2/m64[32:0] ? FFFFFFFFh : 0
PFMAX mm1,mm2/m64Packed floating-point maximum
２つの単精度実数のうち大きいほうを求めます。
mm1[63:32] = Max(mm1[63:32],mm2/m64[63:32])
mm2[31:0] = Max(mm1[31:0],mm2/m64[31:0])
PFMIN mm1,mm2/m64Packed floating-point minimum
２つの単精度実数のうち小さいほうを求めます。
mm1[63:32] = Min(mm1[63:32],mm2/m64[63:32])
mm2[31:0] = Min(mm1[31:0],mm2/m64[31:0])
PFMUL mm1,mm2/m64Packed floating-point multiplication
パックド単精度実数の積を求めます。
mm1[63:32] = mm1[63:32] * mm2/m64[63:32]
mm1[31:0] = mm1[31:0] * mm2/m64[31:0]
PFRCP mm1,mm2/m64Floating-point reciprocal approximation
逆数を求めます。精度は14ビットです。
mm1[63:32] = mm1[31:0] = 1/(mm2/m64[31:0])
PFRCPIT1 mm1,mm2/m64Packed floating-point reciprocal,first iteration step
PFRCPIT2 mm1,mm2/m64Packed floating-point reciprocal/reciprocal square root,second iteration step
PFRSQIT1 mm1,mm2/m64Packed floating-point reciprocal square root,first iteration step
この３つは、Newton-Raphson法により
PFRCP及びPFRSQRT命令の精度を補完するための命令です。
PFRSQRT mm1,mm2/m64Floating-point reciprocal square root approximation
平方根の逆数を求めます。精度は15ビットです。
mm1[63:32] = mm1[31:0] = 1/Sqrt(mm2/m64[31:0])
PFSUB mm1,mm2/m64Packed floating-point subtraction
パックド単精度実数の差を求めます。
mm1[63:32] = mm1[63:32] - mm2/m64[63:32]
mm1[31:0] = mm1[31:0] - mm2/m64[31:0]
PFSUBR mm1,mm2/m64Packed floating-point reverse subtraction
パックド単精度実数の差を求めます。
mm1[63:32] = mm2/m64[63:32] - mm1[63:32]
mm1[31:0] = mm2/m64[31:0] - mm1[31:0]
PI2FD mm1,mm2/m64Packed 32-bit integer to floating-point conversion
パックド32ビット符号付き整数を単精度実数に変換します。
mm1[63:32] = Float(mm2/m64[63:32])
mm1[31:0] = Float(mm2/m64[31:0])
PMULHRW mm1,mm2/m64Multiply signed packed 16-bit values with rounding and store the high 16bits
パックド16ビット符号付き整数の乗算を行い、近似値への丸めを行った上位16ビットを求めます。
mm1[63:48] = (mm1[63:48] * mm2/m64[63:48])/65536
～
mm115:0] = (mm1[15:0] * mm2/m64[15:0])/65536
PREFETCH m8
PREFETCHW m8		Prefech processor cache line int L1 data cache
１次キャッシュに１ライン分のデータを取り込みます。

Enhanced 3DNow!で追加された命令

PF2IW mm1,mm2/m64Packed floating-point to integer word conversion with sign extend
単精度実数を16ビット符号付き整数に変換して飽和させ、32ビットに符号拡張して格納します。
mm1[63:32] = Sat16s(Int(mm2/m64[63:32]))
mm1[31:0] = Sat16s(Int(mm2/m64[31:0]))
PFNACC mm1,mm2/m64Packed floating-point negative accumulate
パックド単精度実数の上位と下位の差を求めます。
mm1[63:32] = mm2/m64[31:0] - mm2/m64[63:32]
mm1[31:0] = mm1[31:0] - mm1[63:32]
PFPNACC mm1,mm2/m64Packed floating-point mixed positive-negative accumulate
パックド単精度実数の上位と下位の和と差を求めます。
mm1[63:32] = mm2/m64[31:0] + mm2/m64[63:32]
mm1[31:0] = mm1[31:0] - mm1[63:32]
PI2FW mm1,mm2/m64Packed 16-bit integer to floating-point conversion
パックド16ビット符号付き整数を、単精度実数に変換します。
mm1[63:32] = Float(mm2/m64[47:32])
mm1[31:0] = Float(mm2/m64[15:0])
PSWAPD mm1,mm2/m64Packed swap doubleword
上位ダブルワードと下位ダブルワードを入れ替えます。
mm1[63:32] = mm2/m64[31:0]
mm1[31:0] = mm2/m64[63:32]
MASKMOVQ mm1,mm2Streaming(chache bypass)store using byte mask
mm1をマスク情報として用い、mm2の内容をキャッシュを介さずメモリに書き込みます。
if(mm1[63]) qword ptr [edi][63:56] = mm2[63:56]
～
if(mm1[7]) qword ptr [edi][7:0] = mm2[7:0]
MOVNTQ m64,mmStreaming(chache bypass)sotre
キャッシュを介さずメモリに書き込みます。
m64 = mm
PAVGB mm1,mm2/m64Packed average of unsigned byte
PAVGUSB命令と同じ。
PAVGW mm1,mm2/m64Packed average of unsigned word
符号無し16ビット整数4組の平均を求めます。
mm1[63:48] = (mm1[63:48] + mm2/m64[63:48])>>1
～
mm1[15:0] = (mm1[15:0] + mm2/m64[15:0])>>1
REXTRW r32,mm,imm8Extract word into integer register
MMレジスタから、imm8で指定したワードを汎用レジスタにコピーします。
r32[31:16] = 0
r32[15:0] = mm[imm8*16 + 15:imm8*16]
PINSRW mm,r32/m16,imm8Insert word from integer register
汎用レジスタの下位16ビット及びメモリから、MMレジスタのimm8で指定したワードへコピーします。
mm[imm8*16 + 15:imm8*16] = r32/m16[15:0]
PMAXSW mm1,mm2/m64Packed maximum signed word
16ビット符号付き整数4組の、大きいほうを求めます。
mm1[63:48] = Max(mm1[63:48],mm2/m64[63:48])
～
mm1[15:0] = Max(mm1[15:0],mm2/m64[15:0])
PMAXUB mm1,mm2/m64Packed maximum signed byte
8ビット符号付き整数8組の、大きいほうを求めます。
mm1[63:56] = Max(mm1[63:56],mm2/m64[63:56])
～
mm1[7:0] = Max(mm1[7:0],mm2/m64[7:0])
PMINSW mm1,mm2/m64Packed minimum signed word
16ビット符号付き整数4組の、小さいほうを求めます。
mm1[63:48] = Min(mm1[63:48],mm2/m64[63:48])
～
mm1[15:0] = Min(mm1[15:0],mm2/m64[15:0])
PMINUB mm1,mm2/m64Packed minimum signed byte
8ビット符号付き整数8組の、小さいほうを求めます。
mm1[63:56] = Min(mm1[63:56],mm2/m64[63:56])
～
mm1[7:0] = Min(mm1[7:0],mm2/m64[7:0])
PMOVMSKB r32,mmMove byte mask to integer register
汎用レジスタへ、MMレジスタの各バイトのマスクビットをコピーします。
r32[31:8] = 0
r32[7] = mm[63]
～
r32[0] = mm[7]
PMULHUW mm1,mm2/m64Packed multiply high unsigned word
パックド16ビット符号無し整数の乗算を行い、積の上位16ビットを求めます。
mm1[63:48] = (mm1[63:48] * mm2/m64[63:48])>>16
～
mm1[15:0] = (mm1[15:0] * mm2/m64[15:0])>>16
PREFETCHNTA m8Move data closer to the processor using the NTA reference
32バイトのデータを１次キャッシュに読み込みます。
PREFETCHT0 m8Move data closer to the processor using the T0 reference
32バイトのデータを１次キャッシュ及び２次キャッシュに読み込みます。
PREFETCHT1 m8Move data closer to the processor using the T1 reference
32バイトのデータを２次キャッシュに読み込みます。
PREFETCHT2 m8Move data closer to the processor using the T2 reference
32バイトのデータを２次キャッシュに読み込みます。
PSADBW mm1,mm2/m64Packed sum of absolute byte differences
8ビット符号付き整数8組の差の絶対値の総和を求めます。
mm1[63:16] = 0
mm1[15:0] = Abs(mm1[7:0] – mm2/m64[7:0]) +
～
　Abs(mm1[63:56] – mm2/m64[63:56])
PSHUFW mm1,mm2/m64,imm8Packed shuffle word
MMレジスタ及びメモリ内の4ワードを並び替えます。
index3 = imm8[7:6] * 16
index2 = imm8[5:4] * 16
index1 = imm8[3:2] * 16
index0 = imm8[1:0] * 16
mm1[63:48] = mm2/m64[index3 + 15:index3]
mm1[47:32] = mm2/m64[index2 + 15:index2]
mm1[31:16] = mm2/m64[index1 + 15:index1]
mm1[15:0] = mm2/m64[index0 + 15:index0]
SFENCEStore fence
ストア操作のシリアル化を行います。