命令の中で出てくるUIMMは、5bit符号なし即値のこと。なお、AltiVec命令に影響を与える/影響される状態レジスタはcr6である。
AltiVecの各命令とほぼ一対一で結びつくC言語用の組み込み関数(intrinsic)がgccなどでは利用できるが、それについてはAppleのページでも参照すること。どうせこのページに書いてある命令を関数にしただけだし、ページを見ても意味がわからない命令はこのページで調べればいい。同じことをいちいちまとめるのも疲れたし…

各命令の種類別リンク

ベクトル算術命令	各バイトサイズ整数と浮動小数の基本的な算術演算。加減算と乗算、小数切捨て命令のみ。
ベクトル複合算術命令	各バイトサイズ整数と浮動小数の複雑な算術演算。おそらくプログラムの高速化に最も貢献する。
型変換ベクトル演算命令	整数を浮動小数に変換したり、整数同士で型変換をするのに使う命令。整数同士の型変換の場合、ベクトル撹拌命令を使う場合もある。
ベクトル論理演算命令	論理演算や各バイトサイズ用の算術/論理シフトを行う命令。選択命令は攪拌命令扱いにしているので、ここにはない。
ベクトル比較命令	各バイトサイズ変数と浮動小数の比較演算命令。特に整数比較は「等しい」「以上」など最小限の命令しかないため、比較対象の順序をうまく変えて扱う必要がある。
ベクトル撹拌命令	SIMD命令セットのボトルネックであるデータ整列演算を行うための命令。わかりにくい命令が多いが、これらをうまく扱えなければSIMD命令セットの真の力は引き出せない(と思う)。
その他の命令	データ転送命令、状態制御命令、ストレージ制御命令など。

ベクトル算術命令

除算命令はベクトル算術命令には存在しない。
また、浮動小数の乗算命令も存在しないので、ベクトル複合算術命令であるvmaddfpを利用すること。

vaddcuw vD, vA, vB: vAとvBで符号なし4byte整数加算×4を実行し、その結果の桁あふれキャリービット×4を、vDに符号なし4byte整数としてそれぞれ格納する。ゆえに、結果は1か0。

vaddfp vD, vA, vB

vAとvBで単精度浮動小数加算×4を実行し、その結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=a0+b0				<=a1+b1				<=a2+b2				<=a3+b3

vaddsbs vD, vA, vB

vAとvBで符号あり1byte整数飽和加算×16を実行し、その結果をvDに格納する。
和の結果が符号つき1byte整数の最大値以上になった場合、127に修正され、同じく符号つき1byte整数の最小値以下になった場合は、-128に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	temp=a0+b0 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	temp=a1+b1 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vaddshs vD, vA, vB

vAとvBで符号あり2byte整数飽和加算×8を実行し、その結果をvDに格納する。
和の結果が符号つき2byte整数の最大値以上になった場合、32767に修正され、同じく符号つき2byte整数の最小値以下になった場合は、-32768に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0+b0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		temp=a1+b1 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vaddsws vD, vA, vB

vAとvBで符号あり4byte整数飽和加算×4を実行し、その結果をvDに格納する。
和の結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0+b0 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				temp=a1+b1 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=...				<=...

vaddubs vD, vA, vB

vAとvBで符号なし1byte整数飽和加算×16を実行し、その結果をvDに格納する。
和の結果が符号なし1byte整数の最大値以上になった場合、255に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	temp=a0+b0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	temp=a1+b1 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vaddubm vD, vA, vB

vAとvBで符号なし1byte整数加算×16を実行し、その結果をvDに格納する。
飽和加算でない通常の加算命令は符号の有無に関わらずこちらを利用する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a0+b0	<=a1+b1	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vadduhs vD, vA, vB

vAとvBで符号なし2byte整数飽和加算×8を実行し、その結果をvDに格納する。
和の結果が符号なし2byte整数の最大値以上になった場合、65535に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0+b0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		temp=a1+b1 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vadduhm vD, vA, vB

vAとvBで符号なし2byte整数加算×8を実行し、その結果をvDに格納する。
飽和加算でない通常の加算命令は符号の有無に関わらずこちらを利用する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a0+b0		<=a1+b1		<=...		<=...		<=...		<=...		<=...		<=...

vadduws vD, vA, vB

vAとvBで符号なし4byte整数飽和加算×4を実行し、その結果をvDに格納する。
和の結果が符号なし4byte整数の最大値以上になった場合、4294967295に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0+b0 if(temp>MAX_UINT) temp=MAX_UINT <=temp				temp=a1+b1 if(temp>MAX_UINT) temp=MAX_UINT <=temp				<=...				<=...

vadduwm vD, vA, vB

vAとvBで符号なし4byte整数加算×4を実行し、その結果をvDに格納する。
飽和加算でない通常の加算命令は符号の有無に関わらずこちらを利用する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=a0+b0				<=a1+b1				<=a2+b2				<=a3+b3

vmulesb vD, vA, vB

vA、vBを1byte符号あり整数×16とする。最上位の1byte同士の乗算結果をvDの最上位2byteに、上から2番目の1byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位8bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a0×b0		<=a2×b2		<=a4×b4		<=...		<=...		<=...		<=...		<=...

vmulesh vD, vA, vB

vA、vBを2byte符号あり整数×8とする。最上位の2byte同士の乗算結果をvDの最上位4byteに、上から2番目の2byte同士の乗算結果をvDの上から1番目の4byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位16bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a0×b0				<=a2×b2				<=a4×b4				<=a6×b6

vmuleub vD, vA, vB

vA、vBを1byte符号なし整数×16とする。最上位の1byte同士の乗算結果をvDの最上位2byteに、上から2番目の1byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位8bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a0×b0		<=a2×b2		<=a4×b4		<=...		<=...		<=...		<=...		<=...

vmuleuh vD, vA, vB

vA、vBを2byte符号なし整数×8とする。最上位の2byte同士の乗算結果をvDの最上位4byteに、上から2番目の2byte同士の乗算結果をvDの上から1番目の4byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位16bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a0×b0				<=a2×b2				<=a4×b4				<=a6×b6

vmulosb vD, vA, vB

vA、vBを1byte符号あり整数×16とする。上から1番目の1byte同士の乗算結果をvDの最上位2byteに、上から3番目の1byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位8bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a1×b1		<=a3×b3		<=a5×b5		<=...		<=...		<=...		<=...		<=...

vmulosh vD, vA, vB

vA、vBを2byte符号あり整数×16とする。上から1番目の2byte同士の乗算結果をvDの最上位4byteに、上から3番目の2byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位16bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a1×b1				<=a3×b3				<=a5×b5				<=a7×b7

vmuloub vD, vA, vB

vA、vBを1byte符号なし整数×16とする。上から1番目の1byte同士の乗算結果をvDの最上位2byteに、上から3番目の1byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位8bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a1×b1		<=a3×b3		<=a5×b5		<=...		<=...		<=...		<=...		<=...

vmulouh vD, vA, vB

vA、vBを2byte符号なし整数×16とする。上から1番目の2byte同士の乗算結果をvDの最上位4byteに、上から3番目の2byte同士の乗算結果をvDの上から1番目の2byteに、というように、1区画とばしで乗算を行い、その結果をvDに入れていく。乗算の際に上位16bitの情報も出力するために、このような仕様になったと思われる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a1×b1				<=a3×b3				<=a5×b5				<=a7×b7

vrfim vD, vB: vBを単精度浮動小数×4とする。vBの小数部を切り捨ててvDへ格納する(?)。

vrfin vD, vB: vBを単精度浮動小数×4とする。vBの小数部を近似し(四捨五入?)、小数部を取り除いてからvDへ格納する。

vrfip vD, vB: vBを単精度浮動小数×4とする。vBに小数部がある場合、それを切り捨てて1加算してから、vDへ格納する(?)。

vrfiz vD, vB: vBを単精度浮動小数×4とする。vBの小数部を切り捨ててvDへ格納する。

vsubcuw vD, vA, vB: vA、vBを4byte符号なし整数×4とする。vAとvBとの減算結果の桁借りボロービットbit×4を、vDに符合なし4byte整数としてそれぞれ格納する。つまり、結果は1か0。

vsubfp vD, vA, vB

vA、vBを単精度浮動小数×4とする。vAとvBとの減算結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=a0-b0				<=a1-b1				<=a2-b2				<=a3-b3

vsubsbs vD, vA, vB

vA、vBを1byte符号つき整数×16とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号つき1byte整数の最大値以上になった場合、127に修正され、同じく符号つき1byte整数の最小値以下になった場合は、-128に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	temp=a0-b0 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	temp=a1-b1 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vsubshs vD, vA, vB

vA、vBを2byte符号つき整数×8とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号つき2byte整数の最大値以上になった場合、32767に修正され、同じく符号つき1byte整数の最小値以下になった場合は、-32768に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0-b0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		temp=a1-b1 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vsubsws vD, vA, vB

vA、vBを4byte符号つき整数×4とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0-b0 if(temp>MIN_INT) temp=MIN_INT if(temp>MAX_INT) temp=MAX_INT <=temp				temp=a1-b1 if(temp>MIN_INT) temp=MIN_INT if(temp>MAX_INT) temp=MAX_INT <=temp				<=...				<=...

vsububm vD, vA, vB

vA、vBを1byte符号なし整数×16とする。vAとvBとの減算結果をvDに格納する。結果的には、符号の有無に関係なく使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=a0-b0	<=a1-b1	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vsububs vD, vA, vB

vA、vBを1byte符号なし整数×16とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号なし1byte整数の最大値以上になった場合、255に修正され、0未満になった場合、0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	temp=a0-b0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	temp=a1-b1 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vsubuhm vD, vA, vB

vA、vBを2byte符号なし整数×8とする。vAとvBとの減算結果をvDに格納する。結果的には、符号の有無に関係なく使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a0-b0		<=a1-b1		<=...		<=...		<=...		<=...		<=...		<=...

vsubuhs vD, vA, vB

vA、vBを2byte符号なし整数×8とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号なし2byte整数の最大値以上になった場合、65535に修正され、0未満になった場合、0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0-b0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		temp=a1-b1 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vsubuwm vD, vA, vB

vA、vBを4byte符号なし整数×4とする。vAとvBとの減算結果をvDに格納する。結果的には、符号の有無に関係なく使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=a0-b0				<=a1-b1				<=a2-b2				<=a3-b3

vsubuws vD, vA, vB

vA、vBを4byte符号なし整数×4とする。vAとvBとの減算結果をvDに格納する。
ただし、結果が符号なし4byte整数の最大値以上になった場合、4294967295に修正され、0未満になった場合、0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0-b0 if(temp>MAX_UINT) temp=MAX_UINT <=temp				temp=a1-b1 if(temp>MAX_UINT) temp=MAX_UINT <=temp				<=...				<=...

ベクトル複合算術命令

複数の算術命令をまとめて実行したり、やや複雑な演算をする命令。

vavgsb vD, vA, vB

vAとvBで符号あり1byte整数加算+1×16を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで、vAとvBの和が負の数の場合は小数切捨て、正の数の場合は小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0+b0+1)/2	<=(a1+b1+1)/2	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vavgsh vD, vA, vB

vAとvBで符号あり2byte整数加算+1×8を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで、vAとvBの和が負の数の場合は小数切捨て、正の数の場合は小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0+b0+1)/2		<=(a1+b1+1)/2		<=...		<=...		<=...		<=...		<=...		<=...

vavgsw vD, vA, vB

vAとvBで符号あり4byte整数加算+1×4を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで、vAとvBの和が負の数の場合は小数切捨て、正の数の場合は小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0+b0+1)/2				<=(a1+b1+1)/2				<=(a2+b2+1)/2				<=(a3+b3+1)/2

vavgub vD, vA, vB

vAとvBで符号なし1byte整数加算+1×16を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0+b0+1)/2	<=(a1+b1+1)/2	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vavguh vD, vA, vB

vAとvBで符号なし2byte整数加算+1×8を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0+b0+1)/2		<=(a1+b1+1)/2		<=...		<=...		<=...		<=...		<=...		<=...

vavguw vD, vA, vB

vAとvBで符号なし4byte整数加算+1×4を実行した結果の値を右へ1bitシフトした値をvDに格納する。ちなみに、1を足すことで小数切り上げとなっている。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0+b0+1)/2				<=(a1+b1+1)/2				<=(a2+b2+1)/2				<=(a3+b3+1)/2

vexptefp vD, vB

vlogefp vD, vB

vmaddfp vD, vA, vC, vB

vA、vC、vBを単精度浮動小数×4とする。vAとvCとの乗算結果にvBを足したものをvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vC	c0				c1				c2				c3
vB	b0				b1				b2				b3
vD	<=a0×c0+b0				<=a1×c1+b1				<=a2×c2+b2				<=a3×c3+b3

vmaxfp vD, vA, vB

vA、vBを単精度浮動小数×4とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0>b0?a0:b0)				<=(a1>b1?a1:b1)				<=(a2>b2?a2:b2)				<=(a3>b3?a3:b3)

vmaxsb vD, vA, vB

vA、vBを1byte符号あり整数×16とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0>b0?a0:b0)	<=(a1>b1?a1:b1)	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vmaxsh vD, vA, vB

vA、vBを2byte符号あり整数×8とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0>b0?a0:b0)		<=(a1>b1?a1:b1)		<=...		<=...		<=...		<=...		<=...		<=...

vmaxsw vD, vA, vB

vA、vBを4byte符号あり整数×4とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0>b0?a0:b0)				<=(a1>b1?a1:b1)				<=(a2>b2?a2:b2)				<=(a3>b3?a3:b3)

vmaxub vD, vA, vB

vA、vBを1byte符号なし整数×16とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0>b0?a0:b0)	<=(a1>b1?a1:b1)	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vmaxuh vD, vA, vB

vA、vBを2byte符号なし整数×8とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0>b0?a0:b0)		<=(a1>b1?a1:b1)		<=...		<=...		<=...		<=...		<=...		<=...

vmaxuw vD, vA, vB

vA、vBを4byte符号なし整数×4とする。vAとvBのどちらか大きい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0>b0?a0:b0)				<=(a1>b1?a1:b1)				<=(a2>b2?a2:b2)				<=(a3>b3?a3:b3)

vmhaddshs vD, vA, vB, vC

vA、vB、vCを2byte符号あり整数×8とする。vAとvBとの乗算結果の上2byteとvCとの和をvDに入れる。ただし、結果が符号つき2byte整数の最大値以上だった場合は32767に修正され、符号つき2byte整数の最小値以下だった場合は-32768に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0		c1		c2		c3		c4		c5		c6		c7
vD	temp=a0×b0/65536+c0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		temp=a1×b1/65536+c1 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vmhraddshs vD, vA, vB, vC

vA、vB、vCを2byte符号あり整数×8とする。vAとvBとの乗算結果と0x4000との和の上2byteとvCとの和をvDに入れる。ただし、結果が符号つき2byte整数の最大値以上だった場合は32767に修正され、符号つき2byte整数の最小値以下だった場合は-32768に修正される。
乗算結果と0x4000との和の処理は、上2byteを取り出す前の1bit繰り上げの処理である。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0		c1		c2		c3		c4		c5		c6		c7
vD	temp=(a0×b0+16384)/65536+c0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		temp=(a1×b1+16384)/65536+c1 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...		<=...		<=...		<=...

vminfp vD, vA, vB

vA、vBを単精度浮動小数×4とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0<b0?a0:b0)				<=(a1<b1?a1:b1)				<=(a2<b2?a2:b2)				<=(a3<b3?a3:b3)

vminsb vD, vA, vB

vA、vBを1byte符号つき整数×16とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0<b0?a0:b0)	<=(a1<b1?a1:b1)	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vminsh vD, vA, vB

vA、vBを2byte符号つき整数×8とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0<b0?a0:b0)		<=(a1<b1?a1:b1)		<=...		<=...		<=...		<=...		<=...		<=...

vminsw vD, vA, vB

vA、vBを4byte符号つき整数×4とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0<b0?a0:b0)				<=(a1<b1?a1:b1)				<=(a2<b2?a2:b2)				<=(a3<b3?a3:b3)

vminub vD, vA, vB

vA、vBを1byte符号なし整数×16とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(a0<b0?a0:b0)	<=(a1<b1?a1:b1)	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vminuh vD, vA, vB

vA、vBを2byte符号なし整数×8とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(a0<b0?a0:b0)		<=(a1<b1?a1:b1)		<=...		<=...		<=...		<=...		<=...		<=...

vminuw vD, vA, vB

vA、vBを4byte符号なし整数×4とする。vAとvBのどちらか小さい方をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=(a0<b0?a0:b0)				<=(a1<b1?a1:b1)				<=(a2<b2?a2:b2)				<=(a3<b3?a3:b3)

vmladduhm vD, vA, vB, vC

vA、vB、vCを2byte符号なし整数×8とする。vAとvBとの乗算結果の下2byteとvCとの和をvDに入れる。この命令は符号のありなしに関わらず使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0		c1		c2		c3		c4		c5		c6		c7
vD	<=a0×b0+c0		<=a1×b1+c1		<=...		<=...		<=...		<=...		<=...		<=...

vmsummbm vD, vA, vB, vC

vA、vBを1byte符号つき整数×16とし、vCを4byte符号つき整数×4とする。vAとvBの乗算結果4つごとに、vCとまとめて足した結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vC	c0				c1				c2				c3
vD	<=a0×b0+a1×b1+a2×b2+a3×b3+c0				<=a4×b4+a5×b5+a6×b6+a7×b7+c1				<=...				<=...

vmsummhm vD, vA, vB, vC

vA、vBを2byte符号つき整数×8とし、vCを4byte符号つき整数×4とする。vAとvBの乗算結果2つごとに、vCとまとめて足した結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0				c1				c2				c3
vD	<=a0×b0+a1×b1+c0				<=a2×b2+a3×b3+c1				<=...				<=...

vmsumshs vD, vA, vB, vC

vA、vBを2byte符号つき整数×8とし、vCを4byte符号つき整数×4とする。vAとvBの乗算結果2つごとに、vCとまとめて足した結果をvDに格納する。
和の結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。 C風に書くとこんな感じ。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0				c1				c2				c3
vD	temp=a0×b0+a1×b1+c0 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				temp=a2×b2+a3×b3+c1 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=...				<=...

vmsumubm vD, vA, vB, vC

vA、vBを1byte符号なし整数×16とし、vCを4byte符号なし整数×4とする。vAとvBの乗算結果4つごとに、vCとまとめて足した結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vC	c0				c1				c2				c3
vD	<=a0×b0+a1×b1+a2×b2+a3×b3+c0				<=a4×b4+a5×b5+a6×b6+a7×b7+c1				<=...				<=...

vmsumuhm vD, vA, vB, vC

vA、vBを2byte符号なし整数×8とし、vCを4byte符号なし整数×4とする。vAとvBの乗算結果2つごとに、vCとまとめて足した結果をvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0				c1				c2				c3
vD	<=a0×b0+a1×b1+c0				<=a2×b2+a3×b3+c1				<=...				<=...

vmsumuhs vD, vA, vB, vC

vA、vBを2byte符号なし整数×8とし、vCを4byte符号なし整数×4とする。vAとvBの乗算結果2つごとに、vCとまとめて足した結果をvDに格納する。
和の結果が符号なし4byte整数の最大値以上になった場合、4294967295に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vC	c0				c1				c2				c3
vD	temp=a0×b0+a1×b1+c0 if(temp>MAX_UINT) temp=MAX_UINT <=temp				temp=a2×b2+a3×b3+c1 if(temp>MAX_UINT) temp=MAX_UINT <=temp				<=...				<=...

vnmsubfp vD, vA, vC, vB

vA、vC、vBを単精度浮動小数×4とする。vAとvCとの乗算結果からvBを引いたものを、さらに符号反転したものをvDに格納する。
結果的に、この命令の処理はvB - vA * vCとなる。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vC	c0				c1				c2				c3
vB	b0				b1				b2				b3
vD	<=-(a0×c0-b0)				<=-(a1×c1-b1)				<=-(a2×c2-b2)				<=-(a3×c3-b3)

vrefp vD, vB

vrsqrtefp vD, vB

vsumsws vD, vA, vB

vA、vBを4byte符号あり整数×4とする。vAの4つの整数と、vBの一番下の4byte整数の総和をvDの一番下の4byteに格納する。このとき、vDの他のbitは全て0にクリアされる。
結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=0				<=0				<=0				temp=a0+a1+a2+a3+b3 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp

vsum2sws vD, vA, vB

vA、vBを4byte符号あり整数×4とする。vAとvBの上2つの4byte整数の総和を、vDの上から1番目の4byteに下2つの4byte整数の総和を、vDの一番下の4byteに格納する。このとき、vDの他のbitは全て0にクリアされる。
結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=0				temp=a0+a1+b0+b1 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=0				temp=a2+a3+b2+b3 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp

vsum4sbs vD, vA, vB

vAを1byte符号あり整数×16、vBを4byte符号あり整数×4とする。vAの1byte整数4つと、vBの4byte整数との総和をvDへ格納する。
結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0				b1				b2				b3
vD	temp=a0+a1+a2+a3+b0 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				temp=a4+a5+a6+a7+b1 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=...				<=...

vsum4shs vD, vA, vB

vAを2byte符号あり整数×8、vBを4byte符号あり整数×4とする。vAの2byte整数2つと、vBの4byte整数との総和をvDへ格納する。
結果が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0				b1				b2				b3
vD	temp=a0+a1+b0 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				temp=a2+a3+b1 if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=...				<=...

vsum4ubs vD, vA, vB

vAを1byte符号なし整数×16、vBを4byte符号なし整数×4とする。vAの1byte整数4つと、vBの4byte整数との総和をvDへ格納する。
ただし、結果が符号なし4byte整数の最大値以上になった場合、4294967295に修正され、0未満になった場合、0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0	a1	a2	a3	a4	a5	a6	a7	a8	a9	a10	a11	a12	a13	a14	a15
vB	b0				b1				b2				b3
vD	temp=a0+a1+a2+a3+b0 if(temp>MAX_UINT) temp=MAX_UINT <=temp				temp=a4+a5+a6+a7+b1 if(temp>MAX_UINT) temp=MAX_UINT <=temp				<=...				<=...

型変換ベクトル演算命令

vcfsx vD, vB, UIMM

vBを符号あり整数×4とし、それを2のUIMM乗で割った値を単精度浮動小数値×4に変換してvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vD	<=(float)a0/2^UIMM				<=(float)a1/2^UIMM				<=...				<=...

vcfux vD, vB, UIMM

vBを符号なし整数×4とし、それを2のUIMM乗で割った値を単精度浮動小数値×4に変換してvDに格納する。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vD	<=(float)a0/2^UIMM				<=(float)a1/2^UIMM				<=...				<=...

vctsxs vD, vB, UIMM

vBを単精度浮動小数×4とし、それを2のUIMM乗で割った値を符号つき4byte整数×4に変換してvDに格納する。
変換した値が符号つき4byte整数の最大値以上になった場合、2147483647に修正され、同じく符号つき4byte整数の最小値以下になった場合は、-2147483648に修正されてvDに格納される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vD	temp=(signed int)(a0/2^UIMM) if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				temp=(signed int)(a1/2^UIMM) if(temp>MAX_INT) temp=MAX_INT if(temp<MIN_INT) temp=MIN_INT <=temp				<=...				<=...

vctuxs vD, vB, UIMM

vBを単精度浮動小数×4とし、それを2のUIMM乗で割った値を符号なし4byte整数×4に変換してvDに格納する。
変換した値が符号なし4byte整数の最大値以上になった場合、4294967295に修正されてvDに格納される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vD	temp=(unsigned int)(a0/2^UIMM) if(temp>MAX_UINT) temp=MAX_UINT if(temp<0) temp=0 <=temp				temp=(unsigned int)(a1/2^UIMM) if(temp>MAX_UINT) temp=MAX_UINT if(temp<0) temp=0 <=temp				<=...				<=...

vpkpx vD, vA, vB

vAとvBを4byteで分けて4区画にする。vDの上8byteにはvA、下8byteにはvBが対応し、元レジスタの4byteデータを2byteに圧縮してvDへ格納する。
厳密には、4byte入力の上から7つめのbitが、2byte出力の最上位bitとなり、入力の上から1byte目を3bit右シフトした値が出力の上1 ~ 5bit目までの値となり、入力の上から2byte目を3bit右シフトした値が出力の上6 ~ 11bit目までの値となり、入力の上から3byte目を3bit右シフトした値が出力の上12 ~ 16bit目までの値となる。 C風に書くとこんな感じ。

	temp = vA << 16 | vB;
	for(k = 0; k < 8; k++){
		pix = ( (unsigned long*)temp)[k];
		
		( (unsigned short*)vD)[k] = ( (pix >> 24) & 1) | ( (pix >> 16) & 0x1f) | ( (pix >> 8) & 0x1f) | (pix & 0x1f);
	}

vpkshss vD, vA, vB

vA、vBを2byte符号つき整数とする。各区画の2byte整数を1byte符号つき整数に変換して、それをvDに1byte符号つき整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号つき1byte整数の最大値以上になった場合、127に修正され、同じく符号つき1byte整数の最小値以下になった場合は、-128に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	temp=b0 if(temp<MIN_SCHAR) temp=MIN_SCHAR if(temp>MAX_SCHAR) temp=MAX_SCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vpkshus vD, vA, vB

vA、vBを2byte符号つき整数とする。各区画の2byte整数を1byte符号なし整数に変換して、それをvDに1byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号なし1byte整数の最大値以上になった場合、255に修正され、0未満の値だった場合は0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0 if(temp<0) temp=0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	temp=b0 if(temp<0) temp=0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vpkswss vD, vA, vB

vA、vBを4byte符号つき整数とする。各区画の4byte整数を2byte符号つき整数に変換して、それをvDに2byte符号つき整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号つき2byte整数の最大値以上になった場合、32767に修正され、同じく符号つき2byte整数の最小値以下になった場合は、-32768に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...		temp=b0 if(temp<MIN_SHRT) temp=MIN_SHRT if(temp>MAX_SHRT) temp=MAX_SHRT <=temp		<=...		<=...		<=...

vpkswus vD, vA, vB

vA、vBを4byte符号つき整数とする。各区画の4byte整数を2byte符号なし整数に変換して、それをvDに2byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号なし2byte整数の最大値以上になった場合、65535に修正され、0未満の場合は0に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0 if(temp<0) temp=0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...		temp=b0 if(temp<0) temp=0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...

vpkuhum vD, vA, vB

vA、vBを2byte符号なし整数とする。各区画の2byte整数を1byte符号なし整数に変換して、それをvDに1byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
値を丸める必要がないのであれば、符号がある場合にも使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=a0	<=...	<=...	<=...	<=...	<=...	<=...	<=...	<=b0	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vpkuhus vD, vA, vB

vA、vBを2byte符号なし整数とする。各区画の2byte整数を1byte符号なし整数に変換して、それをvDに1byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号なし1byte整数の最大値以上になった場合、255に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0		a1		a2		a3		a4		a5		a6		a7
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	temp=a0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...	temp=b0 if(temp>MAX_UCHAR) temp=MAX_UCHAR <=temp	<=...	<=...	<=...	<=...	<=...	<=...	<=...

vpkuwum vD, vA, vB

vA、vBを4byte符号なし整数とする。各区画の4byte整数を2byte符号なし整数に変換して、それをvDに2byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
値を丸める必要がないのであれば、符号がある場合にも使える。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	<=a0		<=...		<=...		<=...		<=b0		<=...		<=...		<=...

vpkuwus vD, vA, vB

vA、vBを4byte符号なし整数とする。各区画の4byte整数を2byte符号なし整数に変換して、それをvDに2byte符号なし整数として格納する。vDの上8byteにvA、下8byteにvBの変換値を格納する。
なお、格納する値が符号なし2byte整数の最大値以上になった場合、65535に修正される。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vA	a0				a1				a2				a3
vB	b0				b1				b2				b3
vD	temp=a0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...		temp=b0 if(temp>MAX_USHRT) temp=MAX_USHRT <=temp		<=...		<=...		<=...

vupkhpx vD, vB

vBを2byteで区切り、8区間に分ける。vBを上から順に、値の上1bitを1byteに符号拡張してvDの上1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとする。
このようにして、vDに4つの拡張したデータをセットする。
この命令の挙動は以下の通り。

	for(k = 0; k < 4; k++){
		alpha = ( (short*)vB)[k] >> 15;
		red = ( ( (short*)vB)[k] >> 10) & 0x1f;
		green = ( ( (short*)vB)[k] >> 5) & 0x1f;
		blue = ( (short*)vB)[k] & 0x1f;
		
		( (long*)vD)[k] = ( (char)alpha << 24) | ( (char)red << 16) | ( (char)green << 8) | (char)blue;
	}

vupkhsb vD, vB

vBを符号つき1byte整数×16とする。vBの上の1byteから順番に、2byte符号拡張しながらvDの先頭から順に格納していく。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(short)b0		<=(short)b1		<=...		<=...		<=...		<=...		<=...		<=...

vupkhsh vD, vB

vBを符号つき2byte整数×8とする。vBの上の2byteから順番に、vDの先頭から順に4byte符号拡張しながら格納していく。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(int)b0				<=(int)b1				<=(int)b2				<=(int)b3

vupklpx vD, vB

vBを2byteで区切り、8区間に分ける。vBを、上4区画を飛ばして8byte目から、値の上1bitを1byteに符号拡張してvDの上1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとし、 vBの次の5bitを1byteに符号なし拡張してvDの次の1byteとする。
このようにして、vDに4つの拡張したデータをセットする。
この命令の挙動は以下の通り。

	for(k = 0; k < 4; k++){
		alpha = ( (short*)vB)[k] >> 15;
		red = ( ( (short*)vB)[k] >> 10) & 0x1f;
		green = ( ( (short*)vB)[k] >> 5) & 0x1f;
		blue = ( (short*)vB)[k] & 0x1f;
		
		( (long*)vD)[k + 4] = ( (char)alpha << 24) | ( (char)red << 16) | ( (char)green << 8) | (char)blue;
	}

vupklsb vD, vB

vBを符号つき1byte整数×16とする。vBの上から8byte目から順番に、2byte符号拡張しながらvDの先頭から順に格納していく。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vB	b0	b1	b2	b3	b4	b5	b6	b7	b8	b9	b10	b11	b12	b13	b14	b15
vD	<=(short)b8		<=(short)b9		<=...		<=...		<=...		<=...		<=...		<=...

vupklsh vD, vB

vBを符号つき2byte整数×8とする。vBの上の4byte目から順番に、vDの先頭から順に4byte符号拡張しながら格納していく。

レジスタ	バイトインデックス
レジスタ	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
vB	b0		b1		b2		b3		b4		b5		b6		b7
vD	<=(int)b4				<=(int)b5				<=(int)b6				<=(int)b7

ベクトル論理演算命令

SHBは4bitの符号なし値。

vand vD, vA, vB: vAとvBの論理積をvDに格納する。

vandc vD, vA, vB: vAとvBの否定との論理積をvDに格納する。

vnor vD, vA, vB: vAとvBとの論理和の否定をvDに格納する。

vor vD, vA, vB: vAとvBとの論理和をvDに格納する。

vrlb vD, vA, vB: vAとvBを1byteに分けて16区画にする。各vAの値をvBの値ぶんだけ左回転シフトした値をvDに格納する。

vrlh vD, vA, vB: vAとvBを2byteに分けて8区画にする。各vAの値をvBの値ぶんだけ左回転シフトした値をvDに格納する。

vrlw vD, vA, vB: vAとvBを4byteに分けて4区画にする。各vAの値をvBの値ぶんだけ左回転シフトした値をvDに格納する。

vslb vD, vA, vB: vBとvAを1byteに分け、16区画にする。vBの下3bit分だけvAの値をシフトしてvDへ格納する。

vslh vD, vA, vB: vA、vBを2byteに分け、8区画にする。vBの下4bitの値ぶんだけ、vAを左シフトした値をvDへ格納する。

vslh vD, vA, vB: vA、vBを4byteに分け、4区画にする。vBの下5bitの値ぶんだけ、vAを左シフトした値をvDへ格納する。

vsrab vD, vA, vB: vA、vBを1byteに分け、16区画にする。vBの下3bitの値ぶんだけ、vAを算術右シフトした値をvDへ格納する。

vsrah vD, vA, vB: vA、vBを2byteに分け、8区画にする。vBの下4bitの値ぶんだけ、vAを算術右シフトした値をvDへ格納する。

vsraw vD, vA, vB: vA、vBを4byteに分け、4区画にする。vBの下5bitの値ぶんだけ、vAを算術右シフトした値をvDへ格納する。

vsrb vD, vA, vB: vA、vBを1byteに分け、16区画にする。vBの下3bitの値ぶんだけ、vAを論理右シフトした値をvDへ格納する。

vsrh vD, vA, vB: vA、vBを2byteに分け、8区画にする。vBの下4bitの値ぶんだけ、vAを論理右シフトした値をvDへ格納する。

vsrw vD, vA, vB: vA、vBを4byteに分け、4区画にする。vBの下5bitの値ぶんだけ、vAを論理右シフトした値をvDへ格納する。

vxor vD, vA, vB: vAとvBとの排他的論理和をvDに格納する。

ベクトル比較命令

ベクトル比較命令は、Rc(Record bit)の値が1の場合(要するに命令に"."をつけるだけ)、状態レジスタcr6に比較結果を出力する。
その内容は、

下から何bit目か	3	2	1
ベクトル比較命令	1の場合:比較した全要素が条件成立	0	1の場合:比較した全要素が条件不成立
ベクトル領域比較命令	0	0	1の場合:vcmpbfp命令の実行結果が0だった 0の場合:vcmpbfp命令の実行結果が一部0でなかった

となる。

vcmpbfp(.) vD, vA, vB

vAとvBで単精度浮動小数×4の比較を行い、その結果をvDに、4byte整数として格納する。
vA側の値がvB側の値より大きい場合、vDの格納先の最上bitが1に、vA側の値がvB側の値を符号反転した値より小さい場合、vDの格納先の上から1bit目が1になる。
命令に.をつけた場合、cr6にはvAの内容が全てvB ~ -1 * vBの領域内かどうかが入れられる。
この命令の挙動は以下の通り。

	for(k = 0; k < 4; k++){
		lesseq = ((float*)vA)[k] <= ((float*)vB)[k];
		greatereq = ((float*)vA)[k] >= -((float*)vB)[k];
		
		((long*)vD)[k] = (~lesseq << 31) | (~greatereq << 30);
	}

vcmpeqfp(.) vD, vA, vB

vAとvBで単精度浮動小数×4の比較を行う。結果、値が等しいなら0xffffffffを、でなければ0x00000000を、vDの対応する領域に格納する。
命令に.をつけた場合、cr6にはvAとvBの内容が全て等しかったか、全て等しくなかったかどうかが入れられる。
この命令の挙動は以下の通り。

	for(k = 0; k < 4; k++){
		((long*)vD)[k] = ((float*)vA)[k] == ((float*)vB)[k] ? 0xffffffff : 0x0;
	}

vcmpequb(.) vD, vA, vB: vAとvBで符号なし(実質符号ありでもこの命令で動く)1byte整数×16の比較を行う。結果、値�