diff options
Diffstat (limited to 'test')
| -rw-r--r-- | test/Makefile | 4 | ||||
| -rw-r--r-- | test/avx10/bf16.txt | 210 | ||||
| -rw-r--r-- | test/avx10/comp.txt | 17 | ||||
| -rw-r--r-- | test/avx10/convert.txt | 176 | ||||
| -rw-r--r-- | test/avx10/misc.txt | 167 | ||||
| -rw-r--r-- | test/avx10/new-ymm.txt (renamed from test/target/avx10.txt) | 0 | ||||
| -rw-r--r-- | test/avx10/old.txt | 657 | ||||
| -rw-r--r-- | test/avx10_test.cpp | 24 | ||||
| -rw-r--r-- | test/test_by_xed.cpp | 6 | ||||
| -rw-r--r-- | test/test_by_xed.py | 199 | ||||
| -rwxr-xr-x | test/test_by_xed.sh | 5 |
11 files changed, 1413 insertions, 52 deletions
diff --git a/test/Makefile b/test/Makefile index ca2f0bb..336dcaf 100644 --- a/test/Makefile +++ b/test/Makefile @@ -60,9 +60,9 @@ apx: apx.cpp $(XBYAK_INC) avx10_test: avx10_test.cpp $(XBYAK_INC) $(CXX) $(CFLAGS) avx10_test.cpp -o $@ -DXBYAK64 -TEST_FILES=avx10.txt misc.txt +TEST_FILES=old.txt new-ymm.txt bf16.txt comp.txt convert.txt xed_test: - @for target in $(addprefix target/, $(TEST_FILES)); do ./test_by_xed.sh $$target; done + @for target in $(addprefix avx10/, $(TEST_FILES)); do ./test_by_xed.sh $$target; done test_nm: normalize_prefix $(TARGET) $(MAKE) -C ../gen diff --git a/test/avx10/bf16.txt b/test/avx10/bf16.txt new file mode 100644 index 0000000..c544e02 --- /dev/null +++ b/test/avx10/bf16.txt @@ -0,0 +1,210 @@ +vaddnepbf16(xm1, xm2, xm3); +vaddnepbf16(ym1|k1, ym2, ptr[rax+128]); +vaddnepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vaddnepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vdivnepbf16(xm1, xm2, xm3); +vdivnepbf16(ym1|k1, ym2, ptr[rax+128]); +vdivnepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vdivnepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vmaxpbf16(xm1, xm2, xm3); +vmaxpbf16(ym1|k1, ym2, ptr[rax+128]); +vmaxpbf16(ym1|k1, ym2, ptr_b[rax+128]); +vmaxpbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vminpbf16(xm1, xm2, xm3); +vminpbf16(ym1|k1, ym2, ptr[rax+128]); +vminpbf16(ym1|k1, ym2, ptr_b[rax+128]); +vminpbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vmulnepbf16(xm1, xm2, xm3); +vmulnepbf16(ym1|k1, ym2, ptr[rax+128]); +vmulnepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vmulnepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vscalefpbf16(xm1, xm2, xm3); +vscalefpbf16(ym1|k1, ym2, ptr[rax+128]); +vscalefpbf16(ym1|k1, ym2, ptr_b[rax+128]); +vscalefpbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vsubnepbf16(xm1, xm2, xm3); +vsubnepbf16(ym1|k1, ym2, ptr[rax+128]); +vsubnepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vsubnepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); +// madd +vfmadd132nepbf16(xm1, xm2, xm3); +vfmadd132nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmadd132nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmadd132nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfmadd213nepbf16(xm1, xm2, xm3); +vfmadd213nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmadd213nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmadd213nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfmadd231nepbf16(xm1, xm2, xm3); +vfmadd231nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmadd231nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmadd231nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); +// nmadd +vfnmadd132nepbf16(xm1, xm2, xm3); +vfnmadd132nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmadd132nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmadd132nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfnmadd213nepbf16(xm1, xm2, xm3); +vfnmadd213nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmadd213nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmadd213nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfnmadd231nepbf16(xm1, xm2, xm3); +vfnmadd231nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmadd231nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmadd231nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); +// msub +vfmsub132nepbf16(xm1, xm2, xm3); +vfmsub132nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmsub132nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmsub132nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfmsub213nepbf16(xm1, xm2, xm3); +vfmsub213nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmsub213nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmsub213nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfmsub231nepbf16(xm1, xm2, xm3); +vfmsub231nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfmsub231nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfmsub231nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); +// nmsub +vfnmsub132nepbf16(xm1, xm2, xm3); +vfnmsub132nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmsub132nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmsub132nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfnmsub213nepbf16(xm1, xm2, xm3); +vfnmsub213nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmsub213nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmsub213nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vfnmsub231nepbf16(xm1, xm2, xm3); +vfnmsub231nepbf16(ym1|k1, ym2, ptr[rax+128]); +vfnmsub231nepbf16(ym1|k1, ym2, ptr_b[rax+128]); +vfnmsub231nepbf16(zm1|k2|T_z, zm2, ptr_b[rax+128]); + +vcmppbf16(k1, xm5, xm4, 5); +vcmppbf16(k2, ym5, ym4, 6); +vcmppbf16(k3, ym15, ptr_b[rax+128], 7); +vcmppbf16(k4, zm30, zm20, 8); +vcmppbf16(k5, zm1, ptr[rax+128], 9); +vcmppbf16(k6, zm10, ptr_b[rax+128], 10); + +vfpclasspbf16(k1, xm4, 5); +vfpclasspbf16(k2|k5, ym4, 6); +vfpclasspbf16(k3|k5, zm20, 7); +vfpclasspbf16(k3|k5, xword[rax+128], 8); +vfpclasspbf16(k3, xword_b[rax+128], 9); +vfpclasspbf16(k5|k5, yword[rax+128], 10); +vfpclasspbf16(k6|k5, yword_b[rax+128], 11); +vfpclasspbf16(k7|k5, zword[rax+128], 12); +vfpclasspbf16(k7|k5, zword_b[rax+128], 13); + +vcomsbf16(xm2, xm3); +vcomsbf16(xm2, ptr[rax+128]); + +vgetexppbf16(xm1|k3, xmm2); +vgetexppbf16(xm1|k3, ptr[rax+128]); +vgetexppbf16(xm1|k3, ptr_b[rax+128]); + +vgetexppbf16(ym1|k3, ymm2); +vgetexppbf16(ym1|k3, ptr[rax+128]); +vgetexppbf16(ym1|k3, ptr_b[rax+128]); + +vgetexppbf16(zm1|k3, zmm2); +vgetexppbf16(zm1|k3, ptr[rax+128]); +vgetexppbf16(zm1|k3, ptr_b[rax+128]); + +vgetmantpbf16(xm1|k3, xmm2, 3); +vgetmantpbf16(xm1|k3, ptr[rax+128], 5); +vgetmantpbf16(xm1|k3, ptr_b[rax+128], 9); + +vgetmantpbf16(ym1|k3, ymm2, 3); +vgetmantpbf16(ym1|k3, ptr[rax+128], 5); +vgetmantpbf16(ym1|k3, ptr_b[rax+128], 9); + +vgetmantpbf16(zm1|k3, zmm2, 3); +vgetmantpbf16(zm1|k3, ptr[rax+128], 5); +vgetmantpbf16(zm1|k3, ptr_b[rax+128], 9); + +vrcppbf16(xm1|k5, xm2); +vrcppbf16(xm1|k5, ptr[rcx+128]); +vrcppbf16(xm1|k5, ptr_b[rcx+128]); + +vrcppbf16(ym1|k5, ym2); +vrcppbf16(ym1|k5, ptr[rcx+128]); +vrcppbf16(ym1|k5, ptr_b[rcx+128]); + +vrcppbf16(zm1|k5, zm2); +vrcppbf16(zm1|k5, ptr[rcx+128]); +vrcppbf16(zm1|k5, ptr_b[rcx+128]); + +vreducenepbf16(xm1|k4, xm2, 1); +vreducenepbf16(xm1|k4, ptr[rax+128], 1); +vreducenepbf16(xm1|k4, ptr_b[rax+128], 1); + +vreducenepbf16(ym1|k4, ym2, 1); +vreducenepbf16(ym1|k4, ptr[rax+128], 1); +vreducenepbf16(ym1|k4, ptr_b[rax+128], 1); + +vreducenepbf16(zm1|k4, zm2, 1); +vreducenepbf16(zm1|k4, ptr[rax+128], 1); +vreducenepbf16(zm1|k4, ptr_b[rax+128], 1); + +vrndscalenepbf16(xm1|k4, xm2, 1); +vrndscalenepbf16(xm1|k4, ptr[rax+128], 1); +vrndscalenepbf16(xm1|k4, ptr_b[rax+128], 1); + +vrndscalenepbf16(ym1|k4, ym2, 1); +vrndscalenepbf16(ym1|k4, ptr[rax+128], 1); +vrndscalenepbf16(ym1|k4, ptr_b[rax+128], 1); + +vrndscalenepbf16(zm1|k4, zm2, 1); +vrndscalenepbf16(zm1|k4, ptr[rax+128], 1); +vrndscalenepbf16(zm1|k4, ptr_b[rax+128], 1); + +vrsqrtpbf16(xm1|k5, xm2); +vrsqrtpbf16(xm1|k5, ptr[rcx+128]); +vrsqrtpbf16(xm1|k5, ptr_b[rcx+128]); + +vrsqrtpbf16(ym1|k5, ym2); +vrsqrtpbf16(ym1|k5, ptr[rcx+128]); +vrsqrtpbf16(ym1|k5, ptr_b[rcx+128]); + +vrsqrtpbf16(zm1|k5, zm2); +vrsqrtpbf16(zm1|k5, ptr[rcx+128]); +vrsqrtpbf16(zm1|k5, ptr_b[rcx+128]); + +vscalefpbf16(xm1|k5, xm5, xm2); +vscalefpbf16(xm1|k5, xm5, ptr[rcx+128]); +vscalefpbf16(xm1|k5, xm5, ptr_b[rcx+128]); + +vscalefpbf16(ym1|k5, ym9, ym2); +vscalefpbf16(ym1|k5, ym9, ptr[rcx+128]); +vscalefpbf16(ym1|k5, ym9, ptr_b[rcx+128]); + +vscalefpbf16(zm1|k5, zm30, zm2); +vscalefpbf16(zm1|k5, zm30, ptr[rcx+128]); +vscalefpbf16(zm1|k5, zm30, ptr_b[rcx+128]); + +vsqrtnepbf16(xm5|k3, xmm4); +vsqrtnepbf16(xm5|k3, ptr[rax+128]); +vsqrtnepbf16(xm5|k3, ptr_b[rax+128]); + +vsqrtnepbf16(ym5|k3, ymm4); +vsqrtnepbf16(ym5|k3, ptr[rax+128]); +vsqrtnepbf16(ym5|k3, ptr_b[rax+128]); + +vsqrtnepbf16(zm5|k3, zmm4); +vsqrtnepbf16(zm5|k3, ptr[rax+128]); +vsqrtnepbf16(zm5|k3, ptr_b[rax+128]); diff --git a/test/avx10/comp.txt b/test/avx10/comp.txt new file mode 100644 index 0000000..bfc883e --- /dev/null +++ b/test/avx10/comp.txt @@ -0,0 +1,17 @@ +vcomxsd(xm1, xm2|T_sae); +vcomxsd(xm1, ptr[rax+128]); + +vcomxsh(xm1, xm2|T_sae); +vcomxsh(xm1, ptr[rax+128]); + +vcomxss(xm1, xm2|T_sae); +vcomxss(xm1, ptr[rax+128]); + +vucomxsd(xm1, xm2|T_sae); +vucomxsd(xm1, ptr[rax+128]); + +vucomxsh(xm1, xm2|T_sae); +vucomxsh(xm1, ptr[rax+128]); + +vucomxss(xm1, xm2|T_sae); +vucomxss(xm1, ptr[rax+128]); diff --git a/test/avx10/convert.txt b/test/avx10/convert.txt new file mode 100644 index 0000000..836fcca --- /dev/null +++ b/test/avx10/convert.txt @@ -0,0 +1,176 @@ +vcvt2ps2phx(xm1|k5, xm2, xm3); +vcvt2ps2phx(xm1|k5, xm2, ptr[rax+128]); +vcvt2ps2phx(xm1|k5, xm2, ptr_b[rax+128]); + +vcvt2ps2phx(ym1|k5, ym2, ym3); +vcvt2ps2phx(ym1|k5, ym2, ptr[rax+128]); +vcvt2ps2phx(ym1|k5, ym2, ptr_b[rax+128]); + +vcvt2ps2phx(zm1|k5, zm2, zm3); +vcvt2ps2phx(zm1|k5, zm2, ptr[rax+128]); +vcvt2ps2phx(zm1|k5, zm2, ptr_b[rax+128]); + +// vcvtbiasph2hf8 +vcvtbiasph2bf8(xm1|k2, xm3, xm5); +vcvtbiasph2bf8(xm1|k2, xm3, ptr[rax+128]); +vcvtbiasph2bf8(xm1|k2, xm3, ptr_b[rax+128]); + +vcvtbiasph2bf8(xm1|k2, ym3, ym5); +vcvtbiasph2bf8(xm1|k2, ym3, ptr[rax+128]); +vcvtbiasph2bf8(xm1|k2, ym3, ptr_b[rax+128]); + +vcvtbiasph2bf8(ym1|k2, zm3, zm5); +vcvtbiasph2bf8(ym1|k2, zm3, ptr[rax+128]); +vcvtbiasph2bf8(ym1|k2, zm3, ptr_b[rax+128]); + +// vcvtbiasph2bf8s +vcvtbiasph2bf8s(xm1|k2, xm3, xm5); +vcvtbiasph2bf8s(xm1|k2, xm3, ptr[rax+128]); +vcvtbiasph2bf8s(xm1|k2, xm3, ptr_b[rax+128]); + +vcvtbiasph2bf8s(xm1|k2, ym3, ym5); +vcvtbiasph2bf8s(xm1|k2, ym3, ptr[rax+128]); +vcvtbiasph2bf8s(xm1|k2, ym3, ptr_b[rax+128]); + +vcvtbiasph2bf8s(ym1|k2, zm3, zm5); +vcvtbiasph2bf8s(ym1|k2, zm3, ptr[rax+128]); +vcvtbiasph2bf8s(ym1|k2, zm3, ptr_b[rax+128]); + +// vcvtbiasph2hf8 +vcvtbiasph2hf8(xm1|k2, xm3, xm5); +vcvtbiasph2hf8(xm1|k2, xm3, ptr[rax+128]); +vcvtbiasph2hf8(xm1|k2, xm3, ptr_b[rax+128]); + +vcvtbiasph2hf8(xm1|k2, ym3, ym5); +vcvtbiasph2hf8(xm1|k2, ym3, ptr[rax+128]); +vcvtbiasph2hf8(xm1|k2, ym3, ptr_b[rax+128]); + +vcvtbiasph2hf8(ym1|k2, zm3, zm5); +vcvtbiasph2hf8(ym1|k2, zm3, ptr[rax+128]); +vcvtbiasph2hf8(ym1|k2, zm3, ptr_b[rax+128]); + +// vcvtbiasph2hf8s +vcvtbiasph2hf8s(xm1|k2, xm3, xm5); +vcvtbiasph2hf8s(xm1|k2, xm3, ptr[rax+128]); +vcvtbiasph2hf8s(xm1|k2, xm3, ptr_b[rax+128]); + +vcvtbiasph2hf8s(xm1|k2, ym3, ym5); +vcvtbiasph2hf8s(xm1|k2, ym3, ptr[rax+128]); +vcvtbiasph2hf8s(xm1|k2, ym3, ptr_b[rax+128]); + +vcvtbiasph2hf8s(ym1|k2, zm3, zm5); +vcvtbiasph2hf8s(ym1|k2, zm3, ptr[rax+128]); +vcvtbiasph2hf8s(ym1|k2, zm3, ptr_b[rax+128]); + +vcvthf82ph(xm1|k5|T_z, xm2); +vcvthf82ph(xm1|k5|T_z, ptr[rax+128]); + +vcvthf82ph(ym1|k5|T_z, xm2); +vcvthf82ph(ym1|k5|T_z, ptr[rax+128]); + +vcvthf82ph(zm1|k5|T_z, ym2); +vcvthf82ph(zm1|k5|T_z, ptr[rax+128]); + +// +vcvtne2ph2bf8(xm1|k4|T_z, xm2, xm3); +vcvtne2ph2bf8(xm1|k4, xm2, ptr[rax+128]); +vcvtne2ph2bf8(xm1|T_z, xm2, ptr_b[rax+128]); + +vcvtne2ph2bf8(ym1|k4|T_z, ym2, ym3); +vcvtne2ph2bf8(ym1|k4, ym2, ptr[rax+128]); +vcvtne2ph2bf8(ym1|T_z, ym2, ptr_b[rax+128]); + +vcvtne2ph2bf8(zm1|k4|T_z, zm2, zm3); +vcvtne2ph2bf8(zm1|k4, zm2, ptr[rax+128]); +vcvtne2ph2bf8(zm1|T_z, zm2, ptr_b[rax+128]); + +// +vcvtne2ph2bf8s(xm1|k4|T_z, xm2, xm3); +vcvtne2ph2bf8s(xm1|k4, xm2, ptr[rax+128]); +vcvtne2ph2bf8s(xm1|T_z, xm2, ptr_b[rax+128]); + +vcvtne2ph2bf8s(ym1|k4|T_z, ym2, ym3); +vcvtne2ph2bf8s(ym1|k4, ym2, ptr[rax+128]); +vcvtne2ph2bf8s(ym1|T_z, ym2, ptr_b[rax+128]); + +vcvtne2ph2bf8s(zm1|k4|T_z, zm2, zm3); +vcvtne2ph2bf8s(zm1|k4, zm2, ptr[rax+128]); +vcvtne2ph2bf8s(zm1|T_z, zm2, ptr_b[rax+128]); + +// +vcvtne2ph2hf8(xm1|k4|T_z, xm2, xm3); +vcvtne2ph2hf8(xm1|k4, xm2, ptr[rax+128]); +vcvtne2ph2hf8(xm1|T_z, xm2, ptr_b[rax+128]); + +vcvtne2ph2hf8(ym1|k4|T_z, ym2, ym3); +vcvtne2ph2hf8(ym1|k4, ym2, ptr[rax+128]); +vcvtne2ph2hf8(ym1|T_z, ym2, ptr_b[rax+128]); + +vcvtne2ph2hf8(zm1|k4|T_z, zm2, zm3); +vcvtne2ph2hf8(zm1|k4, zm2, ptr[rax+128]); +vcvtne2ph2hf8(zm1|T_z, zm2, ptr_b[rax+128]); + +// +vcvtne2ph2hf8s(xm1|k4|T_z, xm2, xm3); +vcvtne2ph2hf8s(xm1|k4, xm2, ptr[rax+128]); +vcvtne2ph2hf8s(xm1|T_z, xm2, ptr_b[rax+128]); + +vcvtne2ph2hf8s(ym1|k4|T_z, ym2, ym3); +vcvtne2ph2hf8s(ym1|k4, ym2, ptr[rax+128]); +vcvtne2ph2hf8s(ym1|T_z, ym2, ptr_b[rax+128]); + +vcvtne2ph2hf8s(zm1|k4|T_z, zm2, zm3); +vcvtne2ph2hf8s(zm1|k4, zm2, ptr[rax+128]); +vcvtne2ph2hf8s(zm1|T_z, zm2, ptr_b[rax+128]); + +// vcvtneph2bf8 +vcvtneph2bf8(xmm1|k2|T_z, xmm2); +vcvtneph2bf8(xmm1|k2|T_z, xword [rax+128]); +vcvtneph2bf8(xmm1|k2|T_z, xword_b[rax+128]); + +vcvtneph2bf8(xmm1|k2|T_z, ymm2); +vcvtneph2bf8(xmm1|k2|T_z, yword[rax+128]); +vcvtneph2bf8(xmm1|k2|T_z, yword_b[rax+128]); + +vcvtneph2bf8(ymm1|k2|T_z, zmm2); +vcvtneph2bf8(ymm1|k2|T_z, zword[rax+128]); +vcvtneph2bf8(ymm1|k2|T_z, zword_b[rax+128]); + +// vcvtneph2bf8s +vcvtneph2bf8s(xmm1|k2|T_z, xmm2); +vcvtneph2bf8s(xmm1|k2|T_z, xword [rax+128]); +vcvtneph2bf8s(xmm1|k2|T_z, xword_b[rax+128]); + +vcvtneph2bf8s(xmm1|k2|T_z, ymm2); +vcvtneph2bf8s(xmm1|k2|T_z, yword[rax+128]); +vcvtneph2bf8s(xmm1|k2|T_z, yword_b[rax+128]); + +vcvtneph2bf8s(ymm1|k2|T_z, zmm2); +vcvtneph2bf8s(ymm1|k2|T_z, zword[rax+128]); +vcvtneph2bf8s(ymm1|k2|T_z, zword_b[rax+128]); + +// vcvtneph2hf8 +vcvtneph2hf8(xmm1|k2|T_z, xmm2); +vcvtneph2hf8(xmm1|k2|T_z, xword [rax+128]); +vcvtneph2hf8(xmm1|k2|T_z, xword_b[rax+128]); + +vcvtneph2hf8(xmm1|k2|T_z, ymm2); +vcvtneph2hf8(xmm1|k2|T_z, yword[rax+128]); +vcvtneph2hf8(xmm1|k2|T_z, yword_b[rax+128]); + +vcvtneph2hf8(ymm1|k2|T_z, zmm2); +vcvtneph2hf8(ymm1|k2|T_z, zword[rax+128]); +vcvtneph2hf8(ymm1|k2|T_z, zword_b[rax+128]); + +// vcvtneph2hf8s +vcvtneph2hf8s(xmm1|k2|T_z, xmm2); +vcvtneph2hf8s(xmm1|k2|T_z, xword [rax+128]); +vcvtneph2hf8s(xmm1|k2|T_z, xword_b[rax+128]); + +vcvtneph2hf8s(xmm1|k2|T_z, ymm2); +vcvtneph2hf8s(xmm1|k2|T_z, yword[rax+128]); +vcvtneph2hf8s(xmm1|k2|T_z, yword_b[rax+128]); + +vcvtneph2hf8s(ymm1|k2|T_z, zmm2); +vcvtneph2hf8s(ymm1|k2|T_z, zword[rax+128]); +vcvtneph2hf8s(ymm1|k2|T_z, zword_b[rax+128]); diff --git a/test/avx10/misc.txt b/test/avx10/misc.txt new file mode 100644 index 0000000..9464d03 --- /dev/null +++ b/test/avx10/misc.txt @@ -0,0 +1,167 @@ +vdpphps(xm1, xm2, xm3); +vdpphps(xm1, xm2, ptr[rax+128]); +vdpphps(xm1, xm2, ptr_b[rax+128]); + +vdpphps(ym1, ym2, ym3); +vdpphps(ym1, ym2, ptr[rax+128]); +vdpphps(ym1, ym2, ptr_b[rax+128]); + +vdpphps(zm1, zm2, zm3); +vdpphps(zm1, zm2, ptr[rax+128]); +vdpphps(zm1, zm2, ptr_b[rax+128]); +// +vmpsadbw(xm1, xm3, xm15, 3); +vmpsadbw(xm1|T_z, xm4, ptr[rax+128], 5); + +vmpsadbw(ym1|k4, ym3, ym15, 3); +vmpsadbw(ym1, ym4, ptr[rax+128], 5); + +vmpsadbw(zm1|k4, zm3, zm15, 3); +vmpsadbw(zm1, zm4, ptr[rax+128], 5); +// +vpdpbssd(xm1, xm2, xm3); +vpdpbssd(xm1, xm2, ptr[rax+128]); +vpdpbssd(xm1, xm2, ptr_b[rax+128]); + +vpdpbssd(ym1, ym2, ym3); +vpdpbssd(ym1, ym2, ptr[rax+128]); +vpdpbssd(ym1, ym2, ptr_b[rax+128]); + +vpdpbssd(zm1, zm2, zm3); +vpdpbssd(zm1, zm2, ptr[rax+128]); +vpdpbssd(zm1, zm2, ptr_b[rax+128]); +// +vpdpbssds(xm1, xm2, xm3); +vpdpbssds(xm1, xm2, ptr[rax+128]); +vpdpbssds(xm1, xm2, ptr_b[rax+128]); + +vpdpbssds(ym1, ym2, ym3); +vpdpbssds(ym1, ym2, ptr[rax+128]); +vpdpbssds(ym1, ym2, ptr_b[rax+128]); + +vpdpbssds(zm1, zm2, zm3); +vpdpbssds(zm1, zm2, ptr[rax+128]); +vpdpbssds(zm1, zm2, ptr_b[rax+128]); +// +vpdpbsud(xm1, xm2, xm3); +vpdpbsud(xm1, xm2, ptr[rax+128]); +vpdpbsud(xm1, xm2, ptr_b[rax+128]); + +vpdpbsud(ym1, ym2, ym3); +vpdpbsud(ym1, ym2, ptr[rax+128]); +vpdpbsud(ym1, ym2, ptr_b[rax+128]); + +vpdpbsud(zm1, zm2, zm3); +vpdpbsud(zm1, zm2, ptr[rax+128]); +vpdpbsud(zm1, zm2, ptr_b[rax+128]); +// +vpdpbsuds(xm1, xm2, xm3); +vpdpbsuds(xm1, xm2, ptr[rax+128]); +vpdpbsuds(xm1, xm2, ptr_b[rax+128]); + +vpdpbsuds(ym1, ym2, ym3); +vpdpbsuds(ym1, ym2, ptr[rax+128]); +vpdpbsuds(ym1, ym2, ptr_b[rax+128]); + +vpdpbsuds(zm1, zm2, zm3); +vpdpbsuds(zm1, zm2, ptr[rax+128]); +vpdpbsuds(zm1, zm2, ptr_b[rax+128]); + +// +vpdpbuud(xm1, xm2, xm3); +vpdpbuud(xm1, xm2, ptr[rax+128]); +vpdpbuud(xm1, xm2, ptr_b[rax+128]); + +vpdpbuud(ym1, ym2, ym3); +vpdpbuud(ym1, ym2, ptr[rax+128]); +vpdpbuud(ym1, ym2, ptr_b[rax+128]); + +vpdpbuud(zm1, zm2, zm3); +vpdpbuud(zm1, zm2, ptr[rax+128]); +vpdpbuud(zm1, zm2, ptr_b[rax+128]); +// +vpdpbuuds(xm1, xm2, xm3); +vpdpbuuds(xm1, xm2, ptr[rax+128]); +vpdpbuuds(xm1, xm2, ptr_b[rax+128]); + +vpdpbuuds(ym1, ym2, ym3); +vpdpbuuds(ym1, ym2, ptr[rax+128]); +vpdpbuuds(ym1, ym2, ptr_b[rax+128]); + +vpdpbuuds(zm1, zm2, zm3); +vpdpbuuds(zm1, zm2, ptr[rax+128]); +vpdpbuuds(zm1, zm2, ptr_b[rax+128]); + +// +vpdpwsud(xm1, xm2, xm3); +vpdpwsud(xm1, xm2, ptr[rax+128]); +vpdpwsud(xm1, xm2, ptr_b[rax+128]); + +vpdpwsud(ym1, ym2, ym3); +vpdpwsud(ym1, ym2, ptr[rax+128]); +vpdpwsud(ym1, ym2, ptr_b[rax+128]); + +vpdpwsud(zm1, zm2, zm3); +vpdpwsud(zm1, zm2, ptr[rax+128]); +vpdpwsud(zm1, zm2, ptr_b[rax+128]); +// +vpdpwsuds(xm1, xm2, xm3); +vpdpwsuds(xm1, xm2, ptr[rax+128]); +vpdpwsuds(xm1, xm2, ptr_b[rax+128]); + +vpdpwsuds(ym1, ym2, ym3); +vpdpwsuds(ym1, ym2, ptr[rax+128]); +vpdpwsuds(ym1, ym2, ptr_b[rax+128]); + +vpdpwsuds(zm1, zm2, zm3); +vpdpwsuds(zm1, zm2, ptr[rax+128]); +vpdpwsuds(zm1, zm2, ptr_b[rax+128]); +// +vpdpwsud(xm1, xm2, xm3); +vpdpwsud(xm1, xm2, ptr[rax+128]); +vpdpwsud(xm1, xm2, ptr_b[rax+128]); + +vpdpwsud(ym1, ym2, ym3); +vpdpwsud(ym1, ym2, ptr[rax+128]); +vpdpwsud(ym1, ym2, ptr_b[rax+128]); + +vpdpwsud(zm1, zm2, zm3); +vpdpwsud(zm1, zm2, ptr[rax+128]); +vpdpwsud(zm1, zm2, ptr_b[rax+128]); +// +vpdpwsuds(xm1, xm2, xm3); +vpdpwsuds(xm1, xm2, ptr[rax+128]); +vpdpwsuds(xm1, xm2, ptr_b[rax+128]); + +vpdpwsuds(ym1, ym2, ym3); +vpdpwsuds(ym1, ym2, ptr[rax+128]); +vpdpwsuds(ym1, ym2, ptr_b[rax+128]); + +vpdpwsuds(zm1, zm2, zm3); +vpdpwsuds(zm1, zm2, ptr[rax+128]); +vpdpwsuds(zm1, zm2, ptr_b[rax+128]); + +// +vpdpwuud(xm1, xm2, xm3); +vpdpwuud(xm1, xm2, ptr[rax+128]); +vpdpwuud(xm1, xm2, ptr_b[rax+128]); + +vpdpwuud(ym1, ym2, ym3); +vpdpwuud(ym1, ym2, ptr[rax+128]); +vpdpwuud(ym1, ym2, ptr_b[rax+128]); + +vpdpwuud(zm1, zm2, zm3); +vpdpwuud(zm1, zm2, ptr[rax+128]); +vpdpwuud(zm1, zm2, ptr_b[rax+128]); +// +vpdpwuuds(xm1, xm2, xm3); +vpdpwuuds(xm1, xm2, ptr[rax+128]); +vpdpwuuds(xm1, xm2, ptr_b[rax+128]); + +vpdpwuuds(ym1, ym2, ym3); +vpdpwuuds(ym1, ym2, ptr[rax+128]); +vpdpwuuds(ym1, ym2, ptr_b[rax+128]); + +vpdpwuuds(zm1, zm2, zm3); +vpdpwuuds(zm1, zm2, ptr[rax+128]); +vpdpwuuds(zm1, zm2, ptr_b[rax+128]); diff --git a/test/target/avx10.txt b/test/avx10/new-ymm.txt index 8ee52ca..8ee52ca 100644 --- a/test/target/avx10.txt +++ b/test/avx10/new-ymm.txt diff --git a/test/avx10/old.txt b/test/avx10/old.txt new file mode 100644 index 0000000..9e4f097 --- /dev/null +++ b/test/avx10/old.txt @@ -0,0 +1,657 @@ +v4fmaddps(zmm1, zmm8, ptr [rdx + 64]); +v4fmaddss(xmm15, xmm8, ptr [rax + 64]); +v4fnmaddps(zmm5 | k5, zmm2, ptr [rcx + 0x80]); +v4fnmaddss(xmm31, xmm2, ptr [rsp + 0x80]); +vp4dpwssd(zmm23 | k7 | T_z, zmm1, ptr [rax + 64]); +vp4dpwssds(zmm10 | k4, zmm3, ptr [rsp + rax * 4 + 64]); +vaesdec(xmm20, xmm30, ptr [rcx + 64]); +vaesdec(ymm1, ymm2, ptr [rcx + 64]); +vaesdec(zmm1, zmm2, ptr [rcx + 64]); +vaesdeclast(xmm20, xmm30, ptr [rax + 64]); +vaesdeclast(ymm20, ymm30, ptr [rax + 64]); +vaesdeclast(zmm20, zmm30, ptr [rax + 64]); +vaesenc(xmm20, xmm30, ptr [rcx + 64]); +vaesenc(ymm1, ymm2, ptr [rcx + 64]); +vaesenc(zmm1, zmm2, ptr [rcx + 64]); +vaesenclast(xmm20, xmm30, ptr [rax + 64]); +vaesenclast(ymm20, ymm30, ptr [rax + 64]); +vaesenclast(zmm20, zmm30, ptr [rax + 64]); +vpclmulqdq(xmm2, xmm3, ptr [rax + 64], 3); +vpclmulqdq(ymm2, ymm3, ptr [rax + 64], 3); +vpclmulqdq(zmm2, zmm3, ptr [rax + 64], 3); +vpclmulqdq(xmm20, xmm3, ptr [rax + 64], 3); +vpclmulqdq(ymm20, ymm3, ptr [rax + 64], 3); +vpclmulqdq(zmm20, zmm3, ptr [rax + 64], 3); +vpcompressb(ptr[rax + 64], xmm1); +vpcompressb(xmm30 | k5, xmm1); +vpcompressb(ptr[rax + 64], ymm1); +vpcompressb(ymm30 | k3 |T_z, ymm1); +vpcompressb(ptr[rax + 64], zmm1); +vpcompressb(zmm30 | k2 |T_z, zmm1); +vpcompressw(ptr[rax + 64], xmm1); +vpcompressw(xmm30 | k5, xmm1); +vpcompressw(ptr[rax + 64], ymm1); +vpcompressw(ymm30 | k3 |T_z, ymm1); +vpcompressw(ptr[rax + 64], zmm1); +vpcompressw(zmm30 | k2 |T_z, zmm1); +vpshldw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshldw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshldw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshldd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshldd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshldd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshldq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshldq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshldq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshldvw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshldvw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshldvw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshldvd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshldvd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshldvd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshldvq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshldvq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshldvq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshrdw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshrdw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshrdw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshrdd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshrdd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshrdd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshrdq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40], 5); +vpshrdq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40], 5); +vpshrdq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40], 5); +vpshrdvw(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshrdvw(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshrdvw(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshrdvd(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshrdvd(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshrdvd(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshrdvq(xmm5|k3|T_z, xmm2, ptr [rax + 0x40]); +vpshrdvq(ymm5|k3|T_z, ymm2, ptr [rax + 0x40]); +vpshrdvq(zmm5|k3|T_z, zmm2, ptr [rax + 0x40]); +vpshrdd(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40], 5); +vpshrdd(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40], 5); +vpshrdd(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40], 5); +vpshrdq(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40], 5); +vpshrdq(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40], 5); +vpshrdq(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40], 5); +vpshrdvd(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40]); +vpshrdvd(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40]); +vpshrdvd(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40]); +vpshrdvq(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40]); +vpshrdvq(ymm5|k3|T_z, ymm2, ptr_b [rax + 0x40]); +vpshrdvq(zmm5|k3|T_z, zmm2, ptr_b [rax + 0x40]); +vpopcntb(xmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntb(ymm5|k3|T_z, ptr [rax + 0x40]); +vpopcntb(zmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntw(xmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntw(ymm5|k3|T_z, ptr [rax + 0x40]); +vpopcntw(zmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntd(xmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntd(ymm5|k3|T_z, ptr [rax + 0x40]); +vpopcntd(zmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntd(xmm5|k3|T_z, ptr_b [rax + 0x40]); +vpopcntd(ymm5|k3|T_z, ptr_b [rax + 0x40]); +vpopcntd(zmm5|k3|T_z, ptr_b [rax + 0x40]); +vpopcntq(xmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntq(ymm5|k3|T_z, ptr [rax + 0x40]); +vpopcntq(zmm5|k3|T_z, ptr [rax + 0x40]); +vpopcntq(xmm5|k3|T_z, ptr_b [rax + 0x40]); +vpopcntq(ymm5|k3|T_z, ptr_b [rax + 0x40]); +vpopcntq(zmm5|k3|T_z, ptr_b [rax + 0x40]); +vpdpbusd(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]); +vpdpbusd(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]); +vpdpbusd(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]); +vpdpbusd(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]); +vpdpbusd(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]); +vpdpbusd(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]); +vpdpbusds(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]); +vpdpbusds(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]); +vpdpbusds(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]); +vpdpbusds(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]); +vpdpbusds(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]); +vpdpbusds(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]); +vpdpwssd(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]); +vpdpwssd(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]); +vpdpwssd(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]); +vpdpwssd(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]); +vpdpwssd(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]); +vpdpwssd(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]); +vpdpwssds(xmm5|k3|T_z, xmm20, ptr [rax + 0x40]); +vpdpwssds(ymm5|k3|T_z, ymm20, ptr [rax + 0x40]); +vpdpwssds(zmm5|k3|T_z, zmm20, ptr [rax + 0x40]); +vpdpwssds(xmm5|k3|T_z, xmm20, ptr_b [rax + 0x40]); +vpdpwssds(ymm5|k3|T_z, ymm20, ptr_b [rax + 0x40]); +vpdpwssds(zmm5|k3|T_z, zmm20, ptr_b [rax + 0x40]); +vpexpandb(xmm5|k3|T_z, xmm30); +vpexpandb(ymm5|k3|T_z, ymm30); +vpexpandb(zmm5|k3|T_z, zmm30); +vpexpandb(xmm5|k3|T_z, ptr [rax + 0x40]); +vpexpandb(ymm5|k3|T_z, ptr [rax + 0x40]); +vpexpandb(zmm5|k3|T_z, ptr [rax + 0x40]); +vpexpandw(xmm5|k3|T_z, xmm30); +vpexpandw(ymm5|k3|T_z, ymm30); +vpexpandw(zmm5|k3|T_z, zmm30); +vpexpandw(xmm5|k3|T_z, ptr [rax + 0x40]); +vpexpandw(ymm5|k3|T_z, ptr [rax + 0x40]); +vpexpandw(zmm5|k3|T_z, ptr [rax + 0x40]); +vpshufbitqmb(k1|k2, xmm2, ptr [rax + 0x40]); +vpshufbitqmb(k1|k2, ymm2, ptr [rax + 0x40]); +vpshufbitqmb(k1|k2, zmm2, ptr [rax + 0x40]); +gf2p8affineinvqb(xmm1, xmm2, 3); +gf2p8affineinvqb(xmm1, ptr [rax + 0x40], 3); +vgf2p8affineinvqb(xmm1, xmm5, xmm2, 3); +vgf2p8affineinvqb(ymm1, ymm5, ymm2, 3); +vgf2p8affineinvqb(xmm1, xmm5, ptr [rax + 0x40], 3); +vgf2p8affineinvqb(ymm1, ymm5, ptr [rax + 0x40], 3); +vgf2p8affineinvqb(xmm30, xmm31, xmm4, 5); +vgf2p8affineinvqb(ymm30, ymm31, ymm4, 5); +vgf2p8affineinvqb(zmm30, zmm31, zmm4, 5); +vgf2p8affineinvqb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40], 5); +vgf2p8affineinvqb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40], 5); +vgf2p8affineinvqb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40], 5); +vgf2p8affineinvqb(xmm30|k1|T_z, xmm5, ptr_b [rax + 0x40], 5); +vgf2p8affineinvqb(ymm30|k1|T_z, ymm5, ptr_b [rax + 0x40], 5); +vgf2p8affineinvqb(zmm30|k1|T_z, zmm5, ptr_b [rax + 0x40], 5); +gf2p8affineqb(xmm1, xmm2, 3); +gf2p8affineqb(xmm1, ptr [rax + 0x40], 3); +vgf2p8affineqb(xmm1, xmm5, xmm2, 3); +vgf2p8affineqb(ymm1, ymm5, ymm2, 3); +vgf2p8affineqb(xmm1, xmm5, ptr [rax + 0x40], 3); +vgf2p8affineqb(ymm1, ymm5, ptr [rax + 0x40], 3); +vgf2p8affineqb(xmm30, xmm31, xmm4, 5); +vgf2p8affineqb(ymm30, ymm31, ymm4, 5); +vgf2p8affineqb(zmm30, zmm31, zmm4, 5); +vgf2p8affineqb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40], 5); +vgf2p8affineqb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40], 5); +vgf2p8affineqb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40], 5); +vgf2p8affineqb(xmm30|k1|T_z, xmm5, ptr_b [rax + 0x40], 5); +vgf2p8affineqb(ymm30|k1|T_z, ymm5, ptr_b [rax + 0x40], 5); +vgf2p8affineqb(zmm30|k1|T_z, zmm5, ptr_b [rax + 0x40], 5); +gf2p8mulb(xmm1, xmm2); +gf2p8mulb(xmm1, ptr [rax + 0x40]); +vgf2p8mulb(xmm1, xmm5, xmm2); +vgf2p8mulb(ymm1, ymm5, ymm2); +vgf2p8mulb(xmm1, xmm5, ptr [rax + 0x40]); +vgf2p8mulb(ymm1, ymm5, ptr [rax + 0x40]); +vgf2p8mulb(xmm30, xmm31, xmm4); +vgf2p8mulb(ymm30, ymm31, ymm4); +vgf2p8mulb(zmm30, zmm31, zmm4); +vgf2p8mulb(xmm30|k1|T_z, xmm5, ptr [rax + 0x40]); +vgf2p8mulb(ymm30|k1|T_z, ymm5, ptr [rax + 0x40]); +vgf2p8mulb(zmm30|k1|T_z, zmm5, ptr [rax + 0x40]); +vcvtne2ps2bf16(xmm0 | k1, xmm1, ptr [rax + 64]); +vcvtne2ps2bf16(ymm0 | k1 | T_z, ymm0, ptr [rax + 64]); +vcvtne2ps2bf16(zmm0 | k1, zmm1, ptr [rax + 64]); +vcvtneps2bf16(xmm0, xword [rax + 64]); +vcvtneps2bf16(xmm0 | k1, yword [rax + 64]); +vcvtneps2bf16(ymm0 | k1, zword [rax + 64]); +vcvtneps2bf16(ymm0 | k1, ptr [rax + 64]); +vdpbf16ps(xmm0 | k1, xmm1, ptr [rax + 64]); +vdpbf16ps(ymm0 | k1, ymm1, ptr [rax + 64]); +vdpbf16ps(zmm0 | k1, zmm1, ptr [rax + 64]); +ldtilecfg(ptr[rax + rcx * 4 + 64]); +sttilecfg(ptr[rsp + rax * 8 + 128]); +tileloadd(tmm3, ptr[rdi + rdx * 2 + 8]); +tileloaddt1(tmm4, ptr[r8 + r9 + 32]); +tilerelease(); +tilestored(ptr[r10 + r11 * 2 + 32], tmm2); +tilezero(tmm7); +tdpbssd(tmm1, tmm2, tmm3); +tdpbsud(tmm2, tmm3, tmm4); +tdpbusd(tmm3, tmm4, tmm5); +tdpbuud(tmm4, tmm5, tmm6); +tdpbf16ps(tmm5, tmm6, tmm7); +tileloadd(tmm1, ptr[r8+r8]); +tileloadd(tmm1, ptr[rax+rcx*4]); +tileloadd(tmm1, ptr[r8+r9*1+0x40]); +vaddph(zmm0, zmm1, ptr[rax+64]); +vaddph(ymm0, ymm1, ptr[rax+64]); +vaddph(xmm0, xmm1, ptr[rax+64]); +vaddph(zmm0, zmm1, ptr_b[rax+64]); +vaddph(ymm0, ymm1, ptr_b[rax+64]); +vaddph(xmm0, xmm1, ptr_b[rax+64]); +vaddsh(xmm0, xmm15, ptr[rax+64]); +vaddsh(xmm0|k5|T_z|T_rd_sae, xmm15, xmm3); +vcmpph(k1, xm15, ptr[rax+64], 1); +vcmpph(k2, ym15, ptr[rax+64], 2); +vcmpph(k3, zm15, ptr[rax+64], 3); +vcmpph(k1, xm15, ptr_b[rax+64], 1); +vcmpph(k2, ym15, ptr_b[rax+64], 2); +vcmpph(k3, zm15, ptr_b[rax+64], 3); +vcmpsh(k1, xm15, ptr[rax+64], 1); +vcmpsh(k3|k5, xmm1, xmm25|T_sae, 4); +vcomish(xmm1, ptr[rax+64]); +vcomish(xmm1|T_sae, xmm15); +vucomish(xmm1, ptr [rax+0x40]); +vucomish(xmm1|T_sae, xmm15); +vfmaddsub213ph(xmm1, xmm2, ptr [rax+0x40]); +vfmaddsub213ph(xmm1, xmm2, ptr_b [rax+0x40]); +vfmaddsub213ph(xmm1|k3, xmm2, xmm5); +vfmaddsub213ph(ymm1, ymm2, ptr [rax+0x40]); +vfmaddsub213ph(ymm1, ymm2, ptr_b[rax+0x40]); +vfmaddsub213ph(ymm1|k3, ymm2, ymm5); +vfmaddsub213ph(zmm1, zmm2, ptr [rax+0x40]); +vfmaddsub213ph(zmm1, zmm2, ptr_b [rax+0x40]); +vfmaddsub213ph(zmm1|T_ru_sae, zmm2, zmm5); +vfmsubadd132ph(xmm1, xmm2, ptr [rax+0x40]); +vfmsubadd132ph(xmm1, xmm2, ptr_b [rax+0x40]); +vfmsubadd132ph(ymm1, ymm2, ptr [rax+0x40]); +vfmsubadd132ph(ymm1, ymm2, ptr_b [rax+0x40]); +vfmsubadd132ph(zmm1, zmm2, ptr [rax+0x40]); +vfmsubadd132ph(zmm1, zmm2, ptr_b [rax+0x40]); +vfmsubadd132ph(zmm1|T_ru_sae, zmm2, zmm5); +vfmadd132ph(xmm1, xmm2, ptr [rax+0x40]); +vfmadd132ph(xmm1, xmm2, ptr_b [rax+0x40]); +vfmadd132ph(ymm1, ymm2, ptr [rax+0x40]); +vfmadd132ph(ymm1, ymm2, ptr_b [rax+0x40]); +vfmadd132ph(zmm1, zmm2, ptr [rax+0x40]); +vfmadd132ph(zmm1, zmm2, ptr_b [rax+0x40]); +vfmadd132ph(zmm1|T_rd_sae, zmm2, zmm5); +vfmsub231ph(xmm1, xmm2, ptr [rax+0x40]); +vfmsub231ph(xmm1, xmm2, ptr_b [rax+0x40]); +vfmsub231ph(ymm1, ymm2, ptr [rax+0x40]); +vfmsub231ph(ymm1, ymm2, ptr_b [rax+0x40]); +vfmsub231ph(zmm1, zmm2, ptr [rax+0x40]); +vfmsub231ph(zmm1, zmm2, ptr_b [rax+0x40]); +vfmsub231ph(zmm1|T_rd_sae, zmm2, zmm5); +vfnmsub231ph(xmm1, xmm2, ptr [rax+0x40]); +vfnmsub231ph(ymm1, ymm2, ptr_b [rax+0x40]); +vfnmsub231ph(zmm1, zmm2, ptr_b [rax+0x40]); +vfnmsub231ph(zmm1|T_rd_sae, zmm2, zmm5); +vfmadd132sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vfmadd132sh(xmm1, xmm2, ptr [rax+0x40]); +vfnmadd132sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vfnmadd132sh(xmm1, xmm2, ptr [rax+0x40]); +vfmsub132sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vfmsub132sh(xmm1, xmm2, ptr [rax+0x40]); +vfnmsub132sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vfnmsub132sh(xmm1, xmm2, ptr [rax+0x40]); +vfcmaddcph(xmm1|k1|T_z, xmm2, ptr [rax+0x40]); +vfcmaddcph(ymm1|k1|T_z, ymm2, ptr [rax+0x40]); +vfcmaddcph(zmm1|k1, zmm2, ptr [rax+0x40]); +vfcmaddcph(zmm1|k1|T_rd_sae, zmm2, zmm5); +vfcmaddcph(xmm1|k1|T_z, xmm2, ptr_b [rax+0x40]); +vfcmaddcph(ymm1|k1|T_z, ymm2, ptr_b [rax+0x40]); +vfcmaddcph(zmm1|k1|T_z, zmm2, ptr_b [rax+0x40]); +vfmaddcph(xm1, xm2, ptr[rax+0x40]); +vfmaddcph(ym1|k1|T_z, ym2, ptr_b[rax+0x40]); +vfmaddcph(zm1, zm2, ptr_b[rax+0x40]); +vfcmulcph(xmm1, xmm2, ptr [rax+0x40]); +vfcmulcph(ymm1|k1|T_z, ymm2, ptr_b [rax+0x40]); +vfcmulcph(zmm1, zmm2, ptr_b [rax+0x40]); +vfmulcph(xmm1, xmm2, ptr [rax+0x40]); +vfmulcph(ymm1|k1|T_z, ymm2, ptr_b [rax+0x40]); +vfmulcph(zmm1, zmm2, ptr_b [rax+0x40]); +vrcpph(xmm1, ptr [rax+0x40]); +vrcpph(xmm1, ptr_b [rax+0x40]); +vrcpph(ymm1, ptr [rax+0x40]); +vrcpph(ymm1, ptr_b [rax+0x40]); +vrcpph(zmm1, ptr [rax+0x40]); +vrcpph(zmm1, ptr_b [rax+0x40]); +vrcpsh(xmm1, xmm3, ptr [rax+0x40]); +vrsqrtph(xmm1, ptr [rax+0x40]); +vrsqrtph(xmm1, ptr_b [rax+0x40]); +vrsqrtph(ymm2, ptr [rax+0x40]); +vrsqrtph(ymm2, ptr_b [rax+0x40]); +vrsqrtph(zmm2, ptr [rax+0x40]); +vrsqrtph(zmm2, ptr_b [rax+0x40]); +vrsqrtsh(xmm1|k5|T_z, xmm7, ptr [rax+0x40]); +vsqrtph(xmm1|k4|T_z, ptr [rax+0x40]); +vsqrtph(xmm1|k4|T_z, ptr_b [rax+0x40]); +vsqrtph(ymm1|k4|T_z, ptr_b [rax+0x40]); +vsqrtph(zmm1|k4|T_z, ptr [rax+0x40]); +vsqrtph(zmm1|k4|T_z, ptr_b [rax+0x40]); +vsqrtsh(xmm1|k4|T_z, xmm5, ptr [rax+0x40]); +vsqrtsh(xmm1|k4|T_z|T_rd_sae, xmm5, xmm7); +vscalefph(xmm1, xmm5, ptr [rax+0x40]); +vscalefph(xmm1, xmm5, ptr_b [rax+0x40]); +vscalefph(ymm1, ymm5, ptr [rax+0x40]); +vscalefph(ymm1, ymm5, ptr_b [rax+0x40]); +vscalefph(zmm1, zmm5, ptr [rax+0x40]); +vscalefph(zmm1, zmm5, ptr_b [rax+0x40]); +vscalefph(zmm1|k1|T_z|T_rd_sae, zmm5, zmm7); +vscalefsh(xmm1, xmm5, ptr [rax+0x40]); +vscalefsh(xmm1|k1|T_z|T_rd_sae, xmm5, xmm7); +vreduceph(xmm1, ptr [rax+0x40], 0x1); +vreduceph(xmm1, ptr_b [rax+0x40], 0x2); +vreduceph(ymm1, ptr [rax+0x40], 0x3); +vreduceph(ymm1, ptr_b [rax+0x40], 0x4); +vreduceph(zmm1, ptr [rax+0x40], 0x5); +vreduceph(zmm1, ptr_b [rax+0x40], 0x6); +vreduceph(zmm1|k1|T_z|T_sae, zmm5, 0x7); +vreducesh(xmm1, xmm3, ptr [rax+0x40], 0x1); +vreducesh(xmm1|k1|T_z|T_sae, xmm5, xmm4, 0x2); +vrndscaleph(xmm1, ptr [rax+0x40], 0x1); +vrndscaleph(xmm1, ptr_b [rax+0x40], 0x2); +vrndscaleph(ymm1, ptr [rax+0x40], 0x3); +vrndscaleph(ymm1, ptr_b [rax+0x40], 0x4); +vrndscaleph(zmm1, ptr [rax+0x40], 0x5); +vrndscaleph(zmm1, ptr_b [rax+0x40], 0x6); +vrndscaleph(zmm1|k1|T_z|T_sae, zmm5, 0x7); +vrndscalesh(xmm1, xmm3, ptr [rax+0x40], 0x1); +vrndscalesh(xmm1|k1|T_z|T_sae, xmm5, xmm4, 0x2); +vfpclassph(k1, xword [rax+0x40], 0x1); +vfpclassph(k1, xword_b[rax+0x40], 0x2); +vfpclassph(k1, yword [rax+0x40], 0x3); +vfpclassph(k1, yword_b[rax+0x40], 0x4); +vfpclassph(k1, zword [rax+0x40], 0x5); +vfpclassph(k1, zword_b[rax+0x40], 0x6); +vfpclasssh(k1|k2, xmm3, 0x5); +vfpclasssh(k1|k2, ptr [rax+0x40], 0x5); +vgetexpph(xmm1, ptr [rax+0x40]); +vgetexpph(ymm1, ptr_b [rax+0x40]); +vgetexpph(zmm1, ptr [rax+0x40]); +vgetexpph(zmm1|k1|T_z|T_sae, zmm5); +vgetexpsh(xmm1, xmm5, ptr [rax+0x40]); +vgetexpsh(xmm1|k1|T_z|T_sae, xmm3, xmm5); +vgetmantph(xmm1, ptr [rax+0x40], 0x1); +vgetmantph(ymm1, ptr_b [rax+0x40], 0x2); +vgetmantph(zmm1, ptr [rax+0x40], 0x3); +vgetmantph(zmm1|k1|T_z|T_sae, zmm5, 0x4); +vgetmantsh(xmm1, xmm5, ptr [rax+0x40], 0x5); +vgetmantsh(xmm1|k1|T_z|T_sae, xmm3, xmm5, 0x6); +vmovsh(xmm1|k1|T_z, ptr [rax+0x40]); +vmovsh(ptr [rax+0x40]|k1, xmm1); +vmovsh(xmm1|k2|T_z, xmm3, xmm5); +vmovw(xmm1, r13d); +vmovw(xmm3, ptr [rax+0x40]); +vmovw(r9d, xmm1); +vmovw(ptr [rax+0x40], xmm7); +vcvtsd2sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vcvtsd2sh(xmm1, xmm2, ptr [rax+0x40]); +vcvtsh2sd(xmm1|k1|T_z|T_sae, xmm2, xmm3); +vcvtsh2sd(xmm1, xmm2, ptr [rax+0x40]); +vcvtsh2ss(xmm1|k1|T_z|T_sae, xmm2, xmm3); +vcvtsh2ss(xmm1, xmm2, ptr [rax+0x40]); +vcvtss2sh(xmm1|k1|T_z|T_rd_sae, xmm2, xmm3); +vcvtss2sh(xmm1, xmm2, ptr [rax+0x40]); +vcvtsh2si(edx|T_rd_sae, xmm1); +vcvtsh2si(edx, ptr [rax+0x40]); +vcvtsh2si(rdx|T_rd_sae, xmm1); +vcvtsh2si(r8, ptr [rax+0x40]); +vcvtph2dq(xmm1, xmm5); +vcvtph2dq(xmm1, ptr [rax+0x40]); +vcvtph2dq(xmm1, ptr_b [rax+0x40]); +vcvtph2dq(ymm1|k2|T_z, xmm5); +vcvtph2dq(ymm1, ptr [rax+0x40]); +vcvtph2dq(ymm1, ptr_b [rax+0x40]); +vcvtph2dq(zmm1|k5|T_z|T_rd_sae, ymm3); +vcvtph2dq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2dq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtph2psx(xmm1, xmm5); +vcvtph2psx(xmm1, ptr [rax+0x40]); +vcvtph2psx(xmm1, ptr_b [rax+0x40]); +vcvtph2psx(ymm1|k2|T_z, xmm5); +vcvtph2psx(ymm1, ptr [rax+0x40]); +vcvtph2psx(ymm1, ptr_b [rax+0x40]); +vcvtph2psx(zmm1|k5|T_z|T_sae, ymm3); +vcvtph2psx(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2psx(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtph2udq(xmm1, xmm5); +vcvtph2udq(xmm1, ptr [rax+0x40]); +vcvtph2udq(xmm1, ptr_b [rax+0x40]); +vcvtph2udq(ymm1|k2|T_z, xmm5); +vcvtph2udq(ymm1, ptr [rax+0x40]); +vcvtph2udq(ymm1, ptr_b [rax+0x40]); +vcvtph2udq(zmm1|k5|T_z|T_rd_sae, ymm3); +vcvtph2udq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2udq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvttph2dq(xmm1, xmm5); +vcvttph2dq(xmm1, ptr [rax+0x40]); +vcvttph2dq(xmm1, ptr_b [rax+0x40]); +vcvttph2dq(ymm1|k2|T_z, xmm5); +vcvttph2dq(ymm1, ptr [rax+0x40]); +vcvttph2dq(ymm1, ptr_b [rax+0x40]); +vcvttph2dq(zmm1|k5|T_z|T_sae, ymm3); +vcvttph2dq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvttph2dq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvttph2udq(xmm1, xmm5); +vcvttph2udq(xmm1, ptr [rax+0x40]); +vcvttph2udq(xmm1, ptr_b [rax+0x40]); +vcvttph2udq(ymm1|k2|T_z, xmm5); +vcvttph2udq(ymm1, ptr [rax+0x40]); +vcvttph2udq(ymm1, ptr_b [rax+0x40]); +vcvttph2udq(zmm1|k5|T_z|T_sae, ymm3); +vcvttph2udq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvttph2udq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtph2pd(xmm1, xmm5); +vcvtph2pd(xmm1, ptr [rax+0x40]); +vcvtph2pd(xmm1, ptr_b [rax+0x40]); +vcvtph2pd(ymm1|k2|T_z, xmm5); +vcvtph2pd(ymm1, ptr [rax+0x40]); +vcvtph2pd(ymm1, ptr_b [rax+0x40]); +vcvtph2pd(zmm1|k5|T_z|T_sae, xmm3); +vcvtph2pd(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2pd(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtph2qq(xmm1, xmm5); +vcvtph2qq(xmm1, ptr [rax+0x40]); +vcvtph2qq(xmm1, ptr_b [rax+0x40]); +vcvtph2qq(ymm1|k2|T_z, xmm5); +vcvtph2qq(ymm1, ptr [rax+0x40]); +vcvtph2qq(ymm1, ptr_b [rax+0x40]); +vcvtph2qq(zmm1|k5|T_z|T_rd_sae, xmm3); +vcvtph2qq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2qq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtph2uqq(xmm1, xmm5); +vcvtph2uqq(xmm1, ptr [rax+0x40]); +vcvtph2uqq(xmm1, ptr_b [rax+0x40]); +vcvtph2uqq(ymm1|k2|T_z, xmm5); +vcvtph2uqq(ymm1, ptr [rax+0x40]); +vcvtph2uqq(ymm1, ptr_b [rax+0x40]); +vcvtph2uqq(zmm1|k5|T_z|T_rd_sae, xmm3); +vcvtph2uqq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvtph2uqq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvttph2uqq(xmm1, xmm5); +vcvttph2uqq(xmm1, ptr [rax+0x40]); +vcvttph2uqq(xmm1, ptr_b [rax+0x40]); +vcvttph2uqq(ymm1|k2|T_z, xmm5); +vcvttph2uqq(ymm1, ptr [rax+0x40]); +vcvttph2uqq(ymm1, ptr_b [rax+0x40]); +vcvttph2uqq(zmm1|k5|T_z|T_sae, xmm3); +vcvttph2uqq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvttph2uqq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtdq2ph(xmm1, xmm5); +vcvtdq2ph(xmm1, xword [rax+0x40]); +vcvtdq2ph(xmm1, xword_b [rax+0x40]); +vcvtdq2ph(xmm1, yword [rax+0x40]); +vcvtdq2ph(xmm1, yword_b [rax+0x40]); +vcvtdq2ph(ymm1|k2|T_z|T_rd_sae, zmm5); +vcvtdq2ph(ymm1, ptr [rax+0x40]); +vcvtdq2ph(ymm1, ptr_b [rax+0x40]); +vcvtps2phx(xmm1, xmm5); +vcvtps2phx(xmm1, xword [rax+0x40]); +vcvtps2phx(xmm1, xword_b [rax+0x40]); +vcvtps2phx(xmm1, yword [rax+0x40]); +vcvtps2phx(xmm1, yword_b [rax+0x40]); +vcvtps2phx(ymm1|k2|T_z|T_rd_sae, zmm5); +vcvtps2phx(ymm1, ptr [rax+0x40]); +vcvtps2phx(ymm1, ptr_b [rax+0x40]); +vcvtudq2ph(xmm1, xmm5); +vcvtudq2ph(xmm1, xword [rax+0x40]); +vcvtudq2ph(xmm1, xword_b [rax+0x40]); +vcvtudq2ph(xmm1, yword [rax+0x40]); +vcvtudq2ph(xmm1, yword_b [rax+0x40]); +vcvtudq2ph(ymm1|k2|T_z|T_rd_sae, zmm5); +vcvtudq2ph(ymm1, ptr [rax+0x40]); +vcvtudq2ph(ymm1, ptr_b [rax+0x40]); +vcvtpd2ph(xmm1, xmm5); +vcvtpd2ph(xmm1, ymm5); +vcvtpd2ph(xmm1|k2|T_z|T_rd_sae, zmm5); +vcvtpd2ph(xmm1, xword [rax+0x40]); +vcvtpd2ph(xmm1, xword_b [rax+0x40]); +vcvtpd2ph(xmm1, yword [rax+0x40]); +vcvtpd2ph(xmm1, yword_b [rax+0x40]); +vcvtpd2ph(xmm1, zword [rax+0x40]); +vcvtpd2ph(xmm1, zword_b [rax+0x40]); +vcvtqq2ph(xmm1, xmm5); +vcvtqq2ph(xmm1, ymm5); +vcvtqq2ph(xmm1|k2|T_z|T_rd_sae, zmm5); +vcvtqq2ph(xmm1, xword [rax+0x40]); +vcvtqq2ph(xmm1, xword_b [rax+0x40]); +vcvtqq2ph(xmm1, yword [rax+0x40]); +vcvtqq2ph(xmm1, yword_b [rax+0x40]); +vcvtqq2ph(xmm1, zword [rax+0x40]); +vcvtqq2ph(xmm1, zword_b [rax+0x40]); +vcvtuqq2ph(xmm1, xmm5); +vcvtuqq2ph(xmm1, ymm5); +vcvtuqq2ph(xmm1|k2|T_z|T_rd_sae, zmm5); +vcvtuqq2ph(xmm1, xword [rax+0x40]); +vcvtuqq2ph(xmm1, xword_b [rax+0x40]); +vcvtuqq2ph(xmm1, yword [rax+0x40]); +vcvtuqq2ph(xmm1, yword_b [rax+0x40]); +vcvtuqq2ph(xmm1, zword [rax+0x40]); +vcvtuqq2ph(xmm1, zword_b [rax+0x40]); +vcvtph2uw(xmm1, xmm5); +vcvtph2uw(xmm1, ptr [rax+0x40]); +vcvtph2uw(xmm1, ptr_b [rax+0x40]); +vcvtph2uw(ymm1, ptr [rax+0x40]); +vcvtph2uw(ymm1, ptr_b [rax+0x40]); +vcvtph2uw(zmm1|k2|T_z|T_rd_sae, zmm5); +vcvtph2uw(zmm1, ptr [rax+0x40]); +vcvtph2uw(zmm1, ptr_b [rax+0x40]); +vcvtph2w(xmm1, xmm5); +vcvtph2w(xmm1, ptr [rax+0x40]); +vcvtph2w(xmm1, ptr_b [rax+0x40]); +vcvtph2w(ymm1, ptr [rax+0x40]); +vcvtph2w(ymm1, ptr_b [rax+0x40]); +vcvtph2w(zmm1|k2|T_z|T_rd_sae, zmm5); +vcvtph2w(zmm1, ptr [rax+0x40]); +vcvtph2w(zmm1, ptr_b [rax+0x40]); +vcvttph2uw(xmm1, xmm5); +vcvttph2uw(xmm1, ptr [rax+0x40]); +vcvttph2uw(xmm1, ptr_b [rax+0x40]); +vcvttph2uw(ymm1, ptr [rax+0x40]); +vcvttph2uw(ymm1, ptr_b [rax+0x40]); +vcvttph2uw(zmm1|k2|T_z|T_sae, zmm5); +vcvttph2uw(zmm1, ptr [rax+0x40]); +vcvttph2uw(zmm1, ptr_b [rax+0x40]); +vcvttph2w(xmm1, xmm5); +vcvttph2w(xmm1, ptr [rax+0x40]); +vcvttph2w(xmm1, ptr_b [rax+0x40]); +vcvttph2w(ymm1, ptr [rax+0x40]); +vcvttph2w(ymm1, ptr_b [rax+0x40]); +vcvttph2w(zmm1|k2|T_z|T_sae, zmm5); +vcvttph2w(zmm1, ptr [rax+0x40]); +vcvttph2w(zmm1, ptr_b [rax+0x40]); +vcvtuw2ph(xmm1, xmm5); +vcvtuw2ph(xmm1, ptr [rax+0x40]); +vcvtuw2ph(xmm1, ptr_b [rax+0x40]); +vcvtuw2ph(ymm1, ptr [rax+0x40]); +vcvtuw2ph(ymm1, ptr_b [rax+0x40]); +vcvtuw2ph(zmm1|k2|T_z|T_rd_sae, zmm5); +vcvtuw2ph(zmm1, ptr [rax+0x40]); +vcvtuw2ph(zmm1, ptr_b [rax+0x40]); +vcvtw2ph(xmm1, xmm5); +vcvtw2ph(xmm1, ptr [rax+0x40]); +vcvtw2ph(xmm1, ptr_b [rax+0x40]); +vcvtw2ph(ymm1, ptr [rax+0x40]); +vcvtw2ph(ymm1, ptr_b [rax+0x40]); +vcvtw2ph(zmm1|k2|T_z|T_rd_sae, zmm5); +vcvtw2ph(zmm1, ptr [rax+0x40]); +vcvtw2ph(zmm1, ptr_b [rax+0x40]); +vcvtps2ph(xmm1, xmm2, 0x1); +vcvtps2ph(ptr [rax+0x40], xmm2, 0x2); +vcvtps2ph(xmm1, ymm2, 0x3); +vcvtps2ph(ptr [rax+0x40], ymm2, 0x4); +vcvtps2ph(xmm1|k1|T_z, xmm2, 0x5); +vcvtps2ph(ptr [rax+0x40]|k1, xmm3, 0x6); +vcvtps2ph(xmm1|k2, ymm4, 0x7); +vcvtps2ph(ptr [rax+0x40]|k2, ymm5, 0x8); +vcvtps2ph(ymm1|k2|T_sae, zmm5, 0x9); +vcvtps2ph(ptr [rax+0x40]|k5, zmm4, 0xa); +vcvtsh2usi(ecx|T_rd_sae, xmm1); +vcvtsh2usi(eax, ptr [rax+0x40]); +vcvtsh2usi(r9|T_rd_sae, xmm1); +vcvtsh2usi(r13, ptr [rax+0x40]); +vcvttsh2si(ecx|T_sae, xmm1); +vcvttsh2si(eax, ptr [rax+0x40]); +vcvttsh2si(r9|T_sae, xmm1); +vcvttsh2si(r13, ptr [rax+0x40]); +vcvttsh2usi(ecx|T_sae, xmm1); +vcvttsh2usi(eax, ptr [rax+0x40]); +vcvttsh2usi(r9|T_sae, xmm1); +vcvttsh2usi(r13, ptr [rax+0x40]); +vcvttph2qq(xmm1, xmm5); +vcvttph2qq(xmm1, ptr [rax+0x40]); +vcvttph2qq(xmm1, ptr_b [rax+0x40]); +vcvttph2qq(ymm1|k2|T_z, xmm5); +vcvttph2qq(ymm1, ptr [rax+0x40]); +vcvttph2qq(ymm1, ptr_b [rax+0x40]); +vcvttph2qq(zmm1|k5|T_z|T_sae, xmm3); +vcvttph2qq(zmm1|k5|T_z, ptr [rax+0x40]); +vcvttph2qq(zmm1|k5|T_z, ptr_b [rax+0x40]); +vcvtsi2sh(xmm1|T_rd_sae, xmm2, eax); +vcvtsi2sh(xmm1, xmm2, dword [rax+0x40]); +vcvtsi2sh(xmm1|T_rd_sae, xmm2, r9); +vcvtsi2sh(xmm1, xmm2, qword [rax+0x40]); +vcvtusi2sh(xmm1|T_rd_sae, xmm2, eax); +vcvtusi2sh(xmm1, xmm2, dword [rax+0x40]); +vcvtusi2sh(xmm1|T_rd_sae, xmm2, r9); +vcvtusi2sh(xmm1, xmm2, qword [rax+0x40]); +aadd(ptr[rax], ecx); +aadd(ptr[eax], ecx); +aadd(ptr[rax], r10); +aand(ptr[rax], ecx); +aand(ptr[eax], ecx); +aand(ptr[rax], r10); +aor(ptr[rax], ecx); +aor(ptr[eax], ecx); +aor(ptr[rax], r10); +axor(ptr[rax], ecx); +axor(ptr[eax], ecx); +axor(ptr[rax], r10); +cmpbexadd(ptr[rax+r10*4], rcx, rdx); +cmpbxadd(ptr[rax+r10*4], rcx, rdx); +cmplexadd(ptr[rax+r10*4], rcx, rdx); +cmplxadd(ptr[rax+r10*4], rcx, rdx); +cmpnbexadd(ptr[rax+r10*4], rcx, rdx); +cmpnbxadd(ptr[rax+r10*4], rcx, rdx); +cmpnlexadd(ptr[rax+r10*4], rcx, rdx); +cmpnlxadd(ptr[rax+r10*4], rcx, rdx); +cmpnoxadd(ptr[rax+r10*4], rcx, rdx); +cmpnpxadd(ptr[rax+r10*4], rcx, rdx); +cmpnsxadd(ptr[rax+r10*4], rcx, rdx); +cmpnzxadd(ptr[rax+r10*4], rcx, rdx); +cmpoxadd(ptr[rax+r10*4], rcx, rdx); +cmppxadd(ptr[rax+r10*4], rcx, rdx); +cmpsxadd(ptr[rax+r10*4], rcx, rdx); +cmpzxadd(ptr[rax+r10*4], rcx, rdx); +vsha512msg1(ymm3, xmm5); +vsha512msg2(ymm9, ymm10); +vsha512rnds2(ymm1, ymm3, xmm2); +vsm3msg1(xmm1, xmm2, xmm3); +vsm3msg1(xmm1, xmm2, ptr [rax]); +vsm3msg2(xmm5, xmm7, xmm3); +vsm3msg2(xmm5, xmm6, ptr [rax]); +vsm3rnds2(xmm5, xmm7, xmm3, 0x12); +vsm3rnds2(xmm5, xmm7, ptr [rcx], 0x34); +vsm4key4(xmm1, xmm2, xmm3); +vsm4key4(xmm1, xmm2, ptr [rdx]); +vsm4rnds4(xmm1, xmm2, xmm3); +vsm4rnds4(xmm5, xmm6, ptr [rcx+rax*4]); +vpdpbssd(xmm1, xmm2, xmm3); +vpdpbssd(ymm1, ymm2, ptr [rax]); +vpdpbssds(xmm1, xmm2, xmm3); +vpdpbssds(ymm1, ymm2, ptr [rax]); +vpdpbsud(xmm1, xmm2, xmm3); +vpdpbsud(ymm1, ymm2, ptr [rax]); +vpdpbsuds(xmm1, xmm2, xmm3); +vpdpbsuds(ymm1, ymm2, ptr [rax]); +vpdpbuud(xmm1, xmm2, xmm3); +vpdpbuud(ymm1, ymm2, ptr [rax]); +vpdpbuuds(xmm1, xmm2, xmm3); +vpdpbuuds(ymm1, ymm2, ptr [rax]); +vpdpwsud(xmm1, xmm2, xmm3); +vpdpwsud(ymm1, ymm2, ptr [rax]); +vpdpwsuds(xmm1, xmm2, xmm3); +vpdpwsuds(ymm1, ymm2, ptr [rax]); +vpdpwusd(xmm1, xmm2, xmm3); +vpdpwusd(ymm1, ymm2, ptr [rax]); +vpdpwusds(xmm1, xmm2, xmm3); +vpdpwusds(ymm1, ymm2, ptr [rax]); +vpdpwuud(xmm1, xmm2, xmm3); +vpdpwuud(ymm1, ymm2, ptr [rax]); +vpdpwuuds(xmm1, xmm2, xmm3); +vpdpwuuds(ymm1, ymm2, ptr [rax]); diff --git a/test/avx10_test.cpp b/test/avx10_test.cpp index 9a4a848..5f742fe 100644 --- a/test/avx10_test.cpp +++ b/test/avx10_test.cpp @@ -228,3 +228,27 @@ CYBOZU_TEST_AUTO(ymm_with_sae) CYBOZU_TEST_EQUAL(c.getSize(), n); CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n); } + +CYBOZU_TEST_AUTO(vmpsadbw) +{ + struct Code : Xbyak::CodeGenerator { + Code() + { + setDefaultEncoding(); + vmpsadbw(xm1, xm3, xm15, 3); // vex(avx) + vmpsadbw(ym1, ym3, ptr[rax+128], 3); // vex(avx2) + setDefaultEncoding(VexEncoding, EvexEncoding); + vmpsadbw(ym1, ym3, ym15, 3); // evex(avx10.2) + vmpsadbw(ym1, ym3, ptr[rax+128], 3); // evex(avx10.2) + } + } c; + const uint8_t tbl[] = { + 0xc4, 0xc3, 0x61, 0x42, 0xcf, 0x03, + 0xc4, 0xe3, 0x65, 0x42, 0x88, 0x80, 0x00, 0x00, 0x00, 0x03, + 0x62, 0xd3, 0x66, 0x28, 0x42, 0xcf, 0x03, + 0x62, 0xf3, 0x66, 0x28, 0x42, 0x48, 0x04, 0x03, + }; + const size_t n = sizeof(tbl) / sizeof(tbl[0]); + CYBOZU_TEST_EQUAL(c.getSize(), n); + CYBOZU_TEST_EQUAL_ARRAY(c.getCode(), tbl, n); +} diff --git a/test/test_by_xed.cpp b/test/test_by_xed.cpp index 08dc8af..ddac779 100644 --- a/test/test_by_xed.cpp +++ b/test/test_by_xed.cpp @@ -1,10 +1,14 @@ #include <stdio.h> #include <xbyak/xbyak.h> +using namespace Xbyak; + struct Code : Xbyak::CodeGenerator { Code() + : Xbyak::CodeGenerator(4096*8) { -#include "cpp.txt" + setDefaultEncoding(VexEncoding, EvexEncoding); +#include "tmp.cpp" } }; diff --git a/test/test_by_xed.py b/test/test_by_xed.py index f24d7f6..afd77d8 100644 --- a/test/test_by_xed.py +++ b/test/test_by_xed.py @@ -7,6 +7,25 @@ class Reg: self.name = s def __str__(self): return self.name + def __eq__(self, rhs): + return self.name == rhs.name + def __lt__(self, rhs): + return self.name < rhs.name + +g_xmmTbl = ''' +xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 +xmm8 xmm9 xmm10 xmm11 xmm12 xmm13 xmm14 xmm15 +xmm16 xmm17 xmm18 xmm19 xmm20 xmm21 xmm22 xmm23 +xmm24 xmm25 xmm26 xmm27 xmm28 xmm29 xmm30 xmm31 +ymm0 ymm1 ymm2 ymm3 ymm4 ymm5 ymm6 ymm7 +ymm8 ymm9 ymm10 ymm11 ymm12 ymm13 ymm14 ymm15 +ymm16 ymm17 ymm18 ymm19 ymm20 ymm21 ymm22 ymm23 +ymm24 ymm25 ymm26 ymm27 ymm28 ymm29 ymm30 ymm31 +zmm0 zmm1 zmm2 zmm3 zmm4 zmm5 zmm6 zmm7 +zmm8 zmm9 zmm10 zmm11 zmm12 zmm13 zmm14 zmm15 +zmm16 zmm17 zmm18 zmm19 zmm20 zmm21 zmm22 zmm23 +zmm24 zmm25 zmm26 zmm27 zmm28 zmm29 zmm30 zmm31 +'''.split() g_regTbl = ''' eax ecx edx ebx esp ebp esi edi @@ -22,49 +41,53 @@ r16w r17w r18w r19w r20w r21w r22w r23w r24w r25w r26w r27w r28w r29w r30w r31w r8b r9b r10b r11b r12b r13b r14b r15b r16b r17b r18b r19b r20b r21b r22b r23b r24b r25b r26b r27b r28b r29b r30b r31b spl bpl sil dil -xmm0 xmm1 xmm2 xmm3 xmm4 xmm5 xmm6 xmm7 -xmm8 xmm9 xmm10 xmm11 xmm12 xmm13 xmm14 xmm15 -xmm16 xmm17 xmm18 xmm19 xmm20 xmm21 xmm22 xmm23 -xmm24 xmm25 xmm26 xmm27 xmm28 xmm29 xmm30 xmm31 -ymm0 ymm1 ymm2 ymm3 ymm4 ymm5 ymm6 ymm7 -ymm8 ymm9 ymm10 ymm11 ymm12 ymm13 ymm14 ymm15 -ymm16 ymm17 ymm18 ymm19 ymm20 ymm21 ymm22 ymm23 -ymm24 ymm25 ymm26 ymm27 ymm28 ymm29 ymm30 ymm31 -zmm0 zmm1 zmm2 zmm3 zmm4 zmm5 zmm6 zmm7 -zmm8 zmm9 zmm10 zmm11 zmm12 zmm13 zmm14 zmm15 -zmm16 zmm17 zmm18 zmm19 zmm20 zmm21 zmm22 zmm23 -zmm24 zmm25 zmm26 zmm27 zmm28 zmm29 zmm30 zmm31 -'''.split() +tmm0 tmm1 tmm2 tmm3 tmm4 tmm5 tmm6 tmm7 +'''.split()+g_xmmTbl # define global constants for e in g_regTbl: globals()[e] = Reg(e) +g_maskTbl = [k1, k2, k3, k4, k5, k6, k7] + g_replaceCharTbl = '{}();|,' g_replaceChar = str.maketrans(g_replaceCharTbl, ' '*len(g_replaceCharTbl)) g_sizeTbl = ['byte', 'word', 'dword', 'qword', 'xword', 'yword', 'zword'] -g_attrTbl = ['T_sae', 'T_rn_sae', 'T_rd_sae', 'T_ru_sae', 'T_rz_sae'] #, 'T_z'] -g_attrXedTbl = ['sae', 'rne-sae', 'rd-sae', 'ru-sae', 'rz-sae'] +g_xedSizeTbl = ['xmmword', 'ymmword', 'zmmword'] +g_attrTbl = ['T_sae', 'T_rn_sae', 'T_rd_sae', 'T_ru_sae', 'T_rz_sae', 'T_z'] +g_attrXedTbl = ['sae', 'rne-sae', 'rd-sae', 'ru-sae', 'rz-sae', 'z'] class Attr: def __init__(self, s): self.name = s def __str__(self): return self.name + def __eq__(self, rhs): + return self.name == rhs.name + def __lt__(self, rhs): + return self.name < rhs.name for e in g_attrTbl: globals()[e] = Attr(e) +def newReg(s): + if type(s) == str: + return Reg(s) + return s + class Memory: - def __init__(self, size=0, base=None, index=None, scale=0, disp=0): + def __init__(self, size=0, base=None, index=None, scale=0, disp=0, broadcast=False): self.size = size - self.base = base - self.index = index + self.base = newReg(base) + self.index = newReg(index) self.scale = scale self.disp = disp + self.broadcast = broadcast def __str__(self): s = 'ptr' if self.size == 0 else g_sizeTbl[int(math.log2(self.size))] + if self.broadcast: + s += '_b' s += ' [' needPlus = False if self.base: @@ -84,47 +107,72 @@ class Memory: s += ']' return s - def __eq__(self, rhs): - return str(self) == str(rhs) + # xbyak uses ptr if it is automatically detected, so xword == ptr is true + if self.broadcast != rhs.broadcast: return False +# if not self.broadcast and 0 < self.size <= 8 and 0 < rhs.size <= 8 and self.size != rhs.size: return False + if not self.broadcast and self.size > 0 and rhs.size > 0 and self.size != rhs.size: return False + r = self.base == rhs.base and self.index == rhs.index and self.scale == rhs.scale and self.disp == rhs.disp + return r + +def parseBroadcast(s): + if '_b' in s: + return (s.replace('_b', ''), True) + r = re.search(r'({1to\d+})', s) + if not r: + return (s, False) + return (s.replace(r.group(1), ''), True) -def parseMemory(s): - sizeTbl = { - 'byte': 1, 'word': 2, 'dword': 4, 'qword': 8, - 'xword': 16, 'yword': 32, 'zword': 64 - } +def parseMemory(s, broadcast=False): + org_s = s s = s.replace(' ', '').lower() - # Parse size size = 0 + base = index = None + scale = 0 + disp = 0 + + if not broadcast: + (s, broadcast) = parseBroadcast(s) + + # Parse size for i in range(len(g_sizeTbl)): w = g_sizeTbl[i] if s.startswith(w): size = 1<<i s = s[len(w):] + break + + if size == 0: + for i in range(len(g_xedSizeTbl)): + w = g_xedSizeTbl[i] + if s.startswith(w): + size = 1<<(i+4) + s = s[len(w):] + break # Remove 'ptr' if present if s.startswith('ptr'): s = s[3:] + if s.startswith('_b'): + broadcast = True + s = s[2:] + # Extract the content inside brackets r = re.match(r'\[(.*)\]', s) if not r: - raise ValueError(f'bad format {s=}') + raise ValueError(f'bad format {org_s=}') # Parse components elems = re.findall(r'([a-z0-9]+)(?:\*([0-9]+))?|([+-])', r.group(1)) - base = index = None - scale = 0 - disp = 0 - for i, e in enumerate(elems): if e[2]: # This is a '+' or '-' sign continue - if e[0].isalpha(): + if e[0] in g_regTbl: if base is None and (not e[1] or int(e[1]) == 1): base = e[0] elif index is None: @@ -137,25 +185,58 @@ def parseMemory(s): b = 16 if e[0].startswith('0x') else 10 disp += sign * int(e[0], b) - return Memory(size, base, index, scale, disp) + return Memory(size, base, index, scale, disp, broadcast) class Nmemonic: def __init__(self, name, args=[], attrs=[]): self.name = name self.args = args - self.attrs = attrs + self.attrs = attrs.sort() def __str__(self): s = f'{self.name}(' for i in range(len(self.args)): if i > 0: s += ', ' s += str(self.args[i]) - for e in self.attrs: - s += f'|{e}' + if i == 0 and self.attrs: + for e in self.attrs: + s += f'|{e}' s += ');' return s + def __eq__(self, rhs): + return self.name == rhs.name and self.args == rhs.args and self.attrs == rhs.attrs def parseNmemonic(s): + args = [] + attrs = [] + + # remove Xbyak::{Evex,Vex}Encoding + r = re.search(r'(,[^,]*Encoding)', s) + if r: + s = s.replace(r.group(1), '') + + (s, broadcast) = parseBroadcast(s) + + # replace xm0 with xmm0 + while True: + r = re.search(r'([xyz])m(\d\d?)', s) + if not r: + break + s = s.replace(r.group(0), r.group(1) + 'mm' + r.group(2)) + + # check 'zmm0{k7}' + r = re.search(r'({k[1-7]})', s) + if r: + idx = int(r.group(1)[2]) + attrs.append(g_maskTbl[idx-1]) + s = s.replace(r.group(1), '') + # check 'zmm0|k7' + r = re.search(r'(\|\s*k[1-7])', s) + if r: + idx = int(r.group(1)[-1]) + attrs.append(g_maskTbl[idx-1]) + s = s.replace(r.group(1), '') + s = s.translate(g_replaceChar) # reconstruct memory string @@ -168,13 +249,12 @@ def parseNmemonic(s): inMemory = False else: v.append(e) - if e in g_sizeTbl or e == 'ptr': + if e in g_sizeTbl or e in g_xedSizeTbl or e.startswith('ptr'): v[-1] += ' ' # to avoid 'byteptr' - inMemory = True + if ']' not in v[-1]: + inMemory = True name = v[0] - args = [] - attrs = [] for e in v[1:]: if e.startswith('0x'): args.append(int(e, 16)) @@ -185,9 +265,12 @@ def parseNmemonic(s): elif e in g_attrXedTbl: attrs.append(Attr(g_attrTbl[g_attrXedTbl.index(e)])) elif e in g_regTbl: - args.append(e) + args.append(Reg(e)) + # xed special format : xmm8+3 + elif e[:-2] in g_xmmTbl and e.endswith('+3'): + args.append(Reg(e[:-2])) else: - args.append(parseMemory(e)) + args.append(parseMemory(e, broadcast)) return Nmemonic(name, args, attrs) def loadFile(name): @@ -195,7 +278,7 @@ def loadFile(name): r = [] for line in f.read().split('\n'): if line: - if line[0] == '#': + if line[0] == '#' or line.startswith('//'): continue r.append(line) return r @@ -209,19 +292,27 @@ def removeExtraInfo(s): def run(cppText, xedText): cpp = loadFile(cppText) xed = loadFile(xedText) - for i in range(len(cpp)): + n = len(cpp) + if n != len(xed): + raise Exception(f'different line {n} {len(xed)}') + + for i in range(n): line1 = cpp[i] line2 = removeExtraInfo(xed[i]) m1 = parseNmemonic(line1) m2 = parseNmemonic(line2) - assertEqualStr(m1, m2, f'{i}') - print('run ok') + assertEqual(m1, m2, f'{i+1}') + print('run ok', n) def assertEqualStr(a, b, msg=None): if str(a) != str(b): raise Exception(f'assert fail {msg}:', str(a), str(b)) +def assertEqual(a, b, msg=None): + if a != b: + raise Exception(f'assert fail {msg}:', str(a), str(b)) + def MemoryTest(): tbl = [ (Memory(0, rax), 'ptr [rax]'), @@ -231,18 +322,23 @@ def MemoryTest(): (Memory(8, None, rcx, 4), 'qword [rcx*4]'), (Memory(8, rax, None, 0, 5), 'qword [rax+0x5]'), (Memory(8, None, None, 0, 255), 'qword [0xff]'), + (Memory(0, r8, r9, 1, 32), 'ptr [r8+r9+0x20]'), ] for (m, expected) in tbl: assertEqualStr(m, expected) + assertEqual(Memory(16, rax), Memory(0, rax)) + def parseMemoryTest(): print('parseMemoryTest') tbl = [ ('[]', Memory()), ('[rax]', Memory(0, rax)), ('ptr[rax]', Memory(0, rax)), + ('ptr_b[rax]', Memory(0, rax, broadcast=True)), ('dword[rbx]', Memory(4, rbx)), ('xword ptr[rcx]', Memory(16, rcx)), + ('xmmword ptr[rcx]', Memory(16, rcx)), ('xword ptr[rdx*8]', Memory(16, None, rdx, 8)), ('[12345]', Memory(0, None, None, 0, 12345)), ('[0x12345]', Memory(0, None, None, 0, 0x12345)), @@ -262,10 +358,19 @@ def parseNmemonicTest(): ('mov(rax, ptr [rcx + rdx * 8 ] );', Nmemonic('mov', [rax, Memory(0, rcx, rdx, 8)])), ('vcmppd(k1, ymm2, ymm3 |T_sae, 3);', Nmemonic('vcmppd', [k1, ymm2, ymm3, 3], [T_sae])), ('vcmppd k1{sae}, ymm2, ymm3, 0x3', Nmemonic('vcmppd', [k1, ymm2, ymm3, 3], [T_sae])), + ('v4fmaddps zmm1, zmm8+3, xmmword ptr [rdx+0x40]', Nmemonic('v4fmaddps', [zmm1, zmm8, Memory(16, rdx, None, 0, 0x40)])), + ('vp4dpwssd zmm23{k7}{z}, zmm1+3, xmmword ptr [rax+0x40]', Nmemonic('vp4dpwssd', [zmm23, zmm1, Memory(16, rax, None, 0, 0x40)], [k7, T_z])), + ('v4fnmaddps(zmm5 | k5, zmm2, ptr [rcx + 0x80]);', Nmemonic('v4fnmaddps', [zmm5, zmm2, Memory(0, rcx, None, 0, 0x80)], [k5])), + ('vpcompressw(zmm30 | k2 |T_z, zmm1);', Nmemonic('vpcompressw', [zmm30, zmm1], [k2, T_z])), + ('vpcompressw zmm30{k2}{z}, zmm1', Nmemonic('vpcompressw', [zmm30, zmm1], [k2, T_z])), + ('vpshldw(xmm9|k3|T_z, xmm2, ptr [rax + 0x40], 5);', Nmemonic('vpshldw', [xmm9, xmm2, Memory(0, rax, None, 0, 0x40), 5], [k3, T_z])), + ('vpshrdd(xmm5|k3|T_z, xmm2, ptr_b [rax + 0x40], 5);', Nmemonic('vpshrdd', [xmm5, xmm2, Memory(0, rax, None, 0, 0x40, True), 5], [k3, T_z])), + ('vpshrdd xmm5{k3}{z}, xmm2, dword ptr [rax+0x40]{1to4}, 0x5', Nmemonic('vpshrdd', [xmm5, xmm2, Memory(0, rax, None, 0, 0x40, True), 5], [k3, T_z])), + ('vcmpph(k1, xm15, ptr[rax+64], 1);', Nmemonic('vcmpph', [k1, xm15, Memory(0, rax, None, 0, 64), 1])), ] for (s, expected) in tbl: e = parseNmemonic(s) - assertEqualStr(e, expected) + assertEqual(e, expected) def test(): print('test start') diff --git a/test/test_by_xed.sh b/test/test_by_xed.sh index 6d820bd..905b8a0 100755 --- a/test/test_by_xed.sh +++ b/test/test_by_xed.sh @@ -4,6 +4,7 @@ set -e XED=${XED:=xed} CXX=${CXX:=g++} PYTHON=${PYTHON:=python3} +echo $XED if [ $# -ne 1 ]; then echo "./test_by_xed.sh <xbyak-cpp>" @@ -15,9 +16,9 @@ TARGET=$1 CFLAGS="-Wall -Wextra -I ../" echo "test:" $TARGET -cp $TARGET cpp.txt +cp $TARGET tmp.cpp $CXX $CFLAGS test_by_xed.cpp -o test_by_xed ./test_by_xed $XED -64 -ir bin > out.txt -$PYTHON test_by_xed.py cpp.txt out.txt +$PYTHON test_by_xed.py $TARGET out.txt |