aboutsummaryrefslogtreecommitdiff
path: root/gdb/testsuite
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/testsuite')
-rw-r--r--gdb/testsuite/gdb.reverse/i386-avx-reverse.c326
-rw-r--r--gdb/testsuite/gdb.reverse/i386-avx-reverse.exp499
2 files changed, 824 insertions, 1 deletions
diff --git a/gdb/testsuite/gdb.reverse/i386-avx-reverse.c b/gdb/testsuite/gdb.reverse/i386-avx-reverse.c
index f559d69..a3d6427 100644
--- a/gdb/testsuite/gdb.reverse/i386-avx-reverse.c
+++ b/gdb/testsuite/gdb.reverse/i386-avx-reverse.c
@@ -30,6 +30,18 @@ char global_buf1[] = {0, 0, 0, 0, 0, 0, 0, 0,
char *dyn_buf0;
char *dyn_buf1;
+ /* Zero memory regions again, so that future tests can update them
+ without worry. */
+void
+reset_buffers ()
+{
+ for (int i = 0; i < 32; i++)
+ {
+ global_buf1[i] = 0;
+ dyn_buf1[i] = 0;
+ }
+}
+
int
vmov_test ()
{
@@ -168,6 +180,22 @@ vmov_test ()
asm volatile ("vmovapd %%xmm0, %0" : : "m"(*dyn_buf1));
asm volatile ("vmovaps %%ymm15, %0" : : "m"(*dyn_buf1));
+ /* Testing vmov[hl|lh]ps and vmov[h|l]pd. */
+ asm volatile ("vmovhlps %xmm1, %xmm8, %xmm0");
+ asm volatile ("vmovhlps %xmm1, %xmm2, %xmm15");
+ asm volatile ("vmovlhps %xmm1, %xmm8, %xmm0");
+ asm volatile ("vmovlhps %xmm1, %xmm2, %xmm15");
+
+ asm volatile ("vmovhps %0, %%xmm1, %%xmm0" : : "m"(buf0));
+ asm volatile ("vmovhps %%xmm0, %0" : "=m" (buf1));
+ asm volatile ("vmovhpd %0, %%xmm1, %%xmm15" : : "m"(global_buf0));
+ asm volatile ("vmovhpd %%xmm15, %0" : "=m" (global_buf1));
+ asm volatile ("vmovlpd %0, %%xmm1, %%xmm15" : : "m"(*dyn_buf0));
+ asm volatile ("vmovlpd %%xmm15, %0" : "=m" (*dyn_buf1));
+
+ asm volatile ("vmovddup %xmm1, %xmm15");
+ asm volatile ("vmovddup %ymm2, %ymm0");
+
/* We have a return statement to deal with
epilogue in different compilers. */
return 0; /* end vmov_test */
@@ -245,7 +273,7 @@ vpunpck_test ()
return 0; /* end vpunpck_test */
}
-/* Test if we can record vpbroadcast instructions. */
+/* Test if we can record vpbroadcast and vbroadcast instructions. */
int
vpbroadcast_test ()
{
@@ -268,6 +296,14 @@ vpbroadcast_test ()
asm volatile ("vpbroadcastq %xmm1, %ymm0");
asm volatile ("vpbroadcastq %xmm1, %ymm15");
+ asm volatile ("vbroadcastss %xmm1, %xmm0");
+ asm volatile ("vbroadcastss %xmm1, %ymm15");
+ asm volatile ("vbroadcastss %0, %%ymm0" : : "m" (global_buf0));
+ asm volatile ("vbroadcastss %0, %%xmm15": : "m" (dyn_buf0));
+ asm volatile ("vbroadcastsd %xmm1, %ymm0");
+ asm volatile ("vbroadcastsd %0, %%ymm15": : "m" (global_buf0));
+ asm volatile ("vbroadcastf128 %0, %%ymm0" : : "m" (dyn_buf0));
+
/* We have a return statement to deal with
epilogue in different compilers. */
return 0; /* end vpbroadcast_test */
@@ -372,6 +408,7 @@ arith_test ()
/* Using GDB, load these values onto registers for testing.
ymm0.v8_float = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5}
ymm1.v8_float = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5}
+ ymm2.v2_int128 = {0x0, 0x0}
ymm15.v2_int128 = {0x0, 0x0}
this way it's easy to confirm we're undoing things correctly. */
asm volatile ("vaddps %xmm0, %xmm1, %xmm15");
@@ -416,6 +453,26 @@ arith_test ()
asm volatile ("vmaxss %xmm0, %xmm1, %xmm15");
asm volatile ("vmaxsd %xmm0, %xmm1, %xmm15");
+ /* Some sanity checks for other arithmetic instructions. */
+ asm volatile ("vpaddb %xmm0, %xmm1, %xmm2");
+ asm volatile ("vpaddw %xmm0, %xmm1, %xmm15");
+ asm volatile ("vpaddd %ymm0, %ymm1, %ymm2");
+ asm volatile ("vpaddq %ymm0, %ymm1, %ymm15");
+
+ asm volatile ("vpmullw %xmm0, %xmm1, %xmm2");
+ asm volatile ("vpmulld %xmm0, %xmm1, %xmm15");
+ asm volatile ("vpmulhw %ymm0, %ymm1, %ymm2");
+ asm volatile ("vpmulhuw %ymm0, %ymm1, %ymm15");
+ asm volatile ("vpmuludq %ymm0, %ymm1, %ymm15");
+
+ asm volatile ("vxorps %xmm0, %xmm1, %xmm2");
+ asm volatile ("vxorpd %ymm0, %ymm1, %ymm2");
+ asm volatile ("vpand %xmm0, %xmm1, %xmm15");
+ asm volatile ("vpandn %ymm0, %ymm1, %ymm15");
+
+ asm volatile ("vpsadbw %xmm0, %xmm1, %xmm2");
+ asm volatile ("vpsadbw %ymm0, %ymm1, %ymm15");
+
return 0; /* end arith_test */
}
@@ -450,6 +507,264 @@ vaddsubps_test ()
}
+/* Test record shifting instructions. */
+int
+shift_test ()
+{
+ /* start shift_test. */
+ /* Using GDB, load these values onto registers for testing.
+ ymm0.v2_int128 = {0, 0}
+ ymm1.v16_int16 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
+ xmm2.uint128 = 1
+ ymm15.v2_int128 = {0x0, 0x0}
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vpsllw $1, %xmm1, %xmm0");
+ asm volatile ("vpsllw %xmm2, %ymm1, %ymm0");
+ asm volatile ("vpslld $3, %ymm1, %ymm15");
+ asm volatile ("vpslld %xmm2, %xmm1, %xmm15");
+ asm volatile ("vpsllq $5, %xmm1, %xmm15");
+ asm volatile ("vpsllq %xmm2, %ymm1, %ymm15");
+
+ asm volatile ("vpsraw $1, %xmm1, %xmm0");
+ asm volatile ("vpsraw %xmm2, %ymm1, %ymm0");
+ asm volatile ("vpsrad $3, %ymm1, %ymm15");
+ asm volatile ("vpsrad %xmm2, %xmm1, %xmm15");
+
+ asm volatile ("vpsrlw $1, %xmm1, %xmm0");
+ asm volatile ("vpsrlw %xmm2, %ymm1, %ymm0");
+ asm volatile ("vpsrld $3, %ymm1, %ymm15");
+ asm volatile ("vpsrld %xmm2, %xmm1, %xmm15");
+ asm volatile ("vpsrlq $5, %xmm1, %xmm15");
+ asm volatile ("vpsrlq %xmm2, %ymm1, %ymm15");
+
+ /* The dq version is treated separately in the manual, so
+ we test it separately just to be sure. */
+ asm volatile ("vpslldq $1, %xmm1, %xmm0");
+ asm volatile ("vpslldq $2, %ymm1, %ymm0");
+ asm volatile ("vpslldq $3, %xmm1, %xmm15");
+ asm volatile ("vpslldq $4, %ymm1, %ymm15");
+
+ asm volatile ("vpsrldq $1, %xmm1, %xmm0");
+ asm volatile ("vpsrldq $2, %ymm1, %ymm0");
+ asm volatile ("vpsrldq $3, %xmm1, %xmm15");
+ asm volatile ("vpsrldq $4, %ymm1, %ymm15");
+
+ return 0; /* end shift_test */
+}
+
+int
+shuffle_test ()
+{
+ /* start shuffle_test. */
+ /* Using GDB, load these values onto registers for testing.
+ ymm0.v2_int128 = {0, 0}
+ ymm1.v16_int16 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
+ ymm2.v16_int15 = {17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}
+ ymm15.v2_int128 = {0x0, 0x0}
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vpshufb %xmm1, %xmm2, %xmm0");
+ asm volatile ("vpshufb %ymm1, %ymm2, %ymm15");
+ asm volatile ("vpshufd $1, %ymm2, %ymm0");
+ asm volatile ("vpshufd $2, %xmm2, %xmm15");
+
+ asm volatile ("vpshufhw $3, %xmm2, %xmm0");
+ asm volatile ("vpshufhw $4, %ymm2, %ymm15");
+ asm volatile ("vpshuflw $5, %ymm2, %ymm0");
+ asm volatile ("vpshuflw $6, %xmm2, %xmm15");
+
+ asm volatile ("vshufps $1, %xmm1, %xmm2, %xmm0");
+ asm volatile ("vshufps $2, %ymm1, %ymm2, %ymm15");
+ asm volatile ("vshufpd $4, %ymm1, %ymm2, %ymm0");
+ asm volatile ("vshufpd $8, %xmm1, %xmm2, %xmm15");
+
+ return 0; /* end shuffle_test */
+}
+
+int
+permute_test ()
+{
+ /* start permute_test. */
+ /* Using GDB, load these values onto registers for testing.
+ ymm0.v2_int128 = {0, 0}
+ ymm1.v16_int16 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
+ ymm2.v16_int16 = {17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}
+ ymm15.v2_int128 = {0x0, 0x0}
+ eax = 0
+ this way it's easy to confirm we're undoing things correctly. */
+ asm volatile ("vperm2f128 $1, %ymm1, %ymm2, %ymm0");
+ asm volatile ("vperm2f128 $0, %ymm1, %ymm2, %ymm15");
+ asm volatile ("vperm2i128 $1, %ymm2, %ymm1, %ymm0");
+ asm volatile ("vperm2i128 $0, %ymm2, %ymm1, %ymm15");
+
+ asm volatile ("vpermd %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpermd %ymm1, %ymm2, %ymm15");
+ asm volatile ("vpermq $1, %ymm1, %ymm0");
+ asm volatile ("vpermq $0, %ymm2, %ymm15");
+
+ asm volatile ("vpermilpd %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpermilpd %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpermilpd $1, %ymm2, %ymm15");
+ asm volatile ("vpermilpd $0, %xmm2, %xmm0");
+ asm volatile ("vpermilps %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpermilps %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpermilps $1, %ymm2, %ymm15");
+ asm volatile ("vpermilps $0, %xmm2, %xmm0");
+
+ asm volatile ("vpermpd $0, %ymm1, %ymm15");
+ asm volatile ("vpermpd $0, %ymm2, %ymm0");
+ asm volatile ("vpermps %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpermps %ymm1, %ymm2, %ymm15");
+
+ return 0; /* end permute_test */
+}
+
+int
+extract_insert_test ()
+{
+ /* start extract_insert_test. */
+ /* Using GDB, load these values onto registers for testing.
+ ymm0.v2_int128 = {0, 0}
+ ymm1.v16_int16 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
+ xmm2.uint128 = 0xcafe
+ ymm15.v2_int128 = {0x0, 0x0}
+ eax = 0
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vinserti128 $1, %xmm2, %ymm1, %ymm0");
+ asm volatile ("vinsertf128 $0, %xmm2, %ymm1, %ymm15");
+ asm volatile ("vextracti128 $1, %ymm1, %xmm0");
+ asm volatile ("vextractf128 $0, %ymm1, %xmm15");
+ asm volatile ("vinsertps $16, %xmm2, %xmm1, %xmm0");
+ asm volatile ("vextractps $0, %xmm2, %rax");
+
+ asm volatile ("vpextrb $5, %xmm1, %rax");
+ asm volatile ("vpextrb $4, %%xmm1, %0" : "=m" (global_buf1));
+ asm volatile ("vpextrd $3, %xmm1, %eax");
+ asm volatile ("vpextrd $2, %%xmm1, %0" : "=m" (global_buf1));
+ asm volatile ("vpextrq $1, %xmm1, %rax");
+ asm volatile ("vpextrq $0, %%xmm1, %0" : "=m" (global_buf1));
+
+ asm volatile ("vpinsrb $3, %rax, %xmm2, %xmm0");
+ asm volatile ("vpinsrw $2, %eax, %xmm2, %xmm15");
+ asm volatile ("vpinsrd $1, %eax, %xmm2, %xmm0");
+ asm volatile ("vpinsrq $0, %rax, %xmm2, %xmm15");
+
+ /* vpextrw has completely different mechanics to other vpextr
+ instructions, so separate them for ease of testing later. */
+ asm volatile ("vpextrw $1, %xmm1, %eax");
+ asm volatile ("vpextrw $1, %%xmm1, %0" : "=m" (global_buf1));
+
+ return 0; /* end extract_insert_test */
+}
+
+int
+blend_test ()
+{
+ /* start blend_test. */
+ /* Using GDB, load these values onto registers for testing.
+ ymm0.v2_int128 = {0, 0}
+ ymm1.v16_int16 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
+ ymm2.v16_int16 = {17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}
+ ymm15.v2_int128 = {0x0, 0x0}
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vblendps $5, %xmm1, %xmm2, %xmm0");
+ asm volatile ("vblendpd $10, %ymm1, %ymm2, %ymm15");
+ asm volatile ("vblendvps %ymm15, %ymm1, %ymm2, %ymm0");
+ asm volatile ("vblendvpd %xmm0, %xmm1, %xmm2, %xmm15");
+
+ asm volatile ("vpblendw $94, %ymm1, %ymm2, %ymm15");
+ asm volatile ("vpblendw $47, %xmm1, %xmm2, %xmm0");
+ asm volatile ("vpblendd $22, %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpblendd $11, %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpblendvb %xmm0, %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpblendvb %ymm0, %ymm1, %ymm2, %ymm0");
+
+ return 0; /* end blend_test */
+}
+
+int
+compare_test ()
+{
+ /* start compare_test. */
+ /* Using GDB, load these values onto registers for testing.
+ xmm0.v4_float = {0, 1.5, 2, 0}
+ xmm1.v4_float = {0, 1, 2.5, -1}
+ xmm15.v4_float = {-1, -2, 10, 100}
+ eflags = 2
+ eflags can't be set to some values, if we set it to 0, it'll
+ be reset to 2, so set it to that directly to make results less
+ confusing.
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vcomisd %xmm0, %xmm1");
+ asm volatile ("vcomiss %xmm15, %xmm1");
+ asm volatile ("vucomiss %xmm1, %xmm15");
+ asm volatile ("vucomisd %xmm15, %xmm0");
+
+ return 0; /* end compare_test */
+}
+
+int
+pack_test ()
+{
+ /* start pack_test. */
+ /* Using GDB, load these values onto registers for testing.
+ xmm0.v4_float = {0, 1.5, 2, 0}
+ xmm1.v4_float = {0, 1, 2.5, -1}
+ xmm2.v4_float = {0, 1, 2.5, -1}
+ xmm15.v4_float = {-1, -2, 10, 100}
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vpacksswb %xmm1, %xmm2, %xmm0");
+ asm volatile ("vpacksswb %ymm1, %ymm2, %ymm15");
+ asm volatile ("vpackssdw %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpackssdw %ymm1, %ymm2, %ymm0");
+ asm volatile ("vpackuswb %xmm1, %xmm2, %xmm0");
+ asm volatile ("vpackuswb %ymm1, %ymm2, %ymm15");
+ asm volatile ("vpackusdw %xmm1, %xmm2, %xmm15");
+ asm volatile ("vpackusdw %ymm1, %ymm2, %ymm0");
+
+ return 0; /* end pack_test */
+}
+
+int
+convert_test ()
+{
+ /* start convert_test. */
+ /* Using GDB, load these values onto registers for testing.
+ xmm0.v2_int128 = {0, 0}
+ xmm1.v4_float = {0, 1, 2.5, 10}
+ xmm15.v2_int128 = {0, 0}
+ ecx = -1
+ ebx = 0
+ this way it's easy to confirm we're undoing things correctly. */
+
+ asm volatile ("vcvtdq2ps %xmm1, %xmm0");
+ asm volatile ("vcvtdq2pd %xmm1, %xmm15");
+
+ asm volatile ("vcvtps2dq %xmm1, %xmm15");
+ asm volatile ("vcvtps2pd %xmm1, %xmm0");
+ asm volatile ("vcvtpd2ps %xmm1, %xmm15");
+ asm volatile ("vcvtpd2dq %xmm1, %xmm0");
+
+ asm volatile ("vcvtsd2si %xmm1, %rbx");
+ asm volatile ("vcvtsd2ss %xmm0, %xmm1, %xmm15");
+ asm volatile ("vcvtsi2sd %rcx, %xmm1, %xmm0");
+ asm volatile ("vcvtsi2ss %rcx, %xmm1, %xmm15");
+ asm volatile ("vcvtss2sd %xmm15, %xmm1, %xmm0");
+ asm volatile ("vcvtss2si %xmm1, %rbx");
+
+ asm volatile ("vcvttpd2dq %xmm1, %xmm0");
+ asm volatile ("vcvttps2dq %xmm1, %xmm15");
+ asm volatile ("vcvttsd2si %xmm0, %rbx");
+ asm volatile ("vcvttss2si %xmm1, %ecx");
+
+ return 0; /* end convert_test */
+}
+
/* This include is used to allocate the dynamic buffer and have
the pointers aligned to a 32-bit boundary, so we can test instructions
that require aligned memory. */
@@ -473,6 +788,7 @@ main ()
asm volatile ("vmovq %0, %%xmm15": : "m" (global_buf1));
vmov_test ();
+ reset_buffers ();
vpunpck_test ();
vpbroadcast_test ();
vzeroupper_test ();
@@ -482,5 +798,13 @@ main ()
arith_test ();
vaddsubpd_test ();
vaddsubps_test ();
+ shift_test ();
+ shuffle_test ();
+ permute_test ();
+ extract_insert_test ();
+ blend_test ();
+ compare_test ();
+ pack_test ();
+ convert_test ();
return 0; /* end of main */
}
diff --git a/gdb/testsuite/gdb.reverse/i386-avx-reverse.exp b/gdb/testsuite/gdb.reverse/i386-avx-reverse.exp
index fbcff49..7e75542 100644
--- a/gdb/testsuite/gdb.reverse/i386-avx-reverse.exp
+++ b/gdb/testsuite/gdb.reverse/i386-avx-reverse.exp
@@ -149,6 +149,33 @@ global decimal
if {[record_full_function "vmov"] == true} {
# Now execute backwards, checking all instructions.
+ test_one_register "vmovddup" "ymm0" \
+ "0x3736353433323130c004000000000000, 0x0"
+ test_one_register "vmovddup" "ymm15" \
+ "0x2726252423222120, 0x0"
+ test_one_memory "vmovlpd" "dyn_buf1" \
+ "\\\{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x28" \
+ true
+ test_one_register "vmovlpd" "ymm15" \
+ "0x1716151413121110c004000000000000, 0x0"
+ test_one_memory "vmovhpd" "global_buf1" \
+ "\\\{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x18"
+ test_one_register "vmovhpd" "ymm15" \
+ "0xc004000000000000c004000000000000, 0x0"
+ test_one_memory "vmovhps" "buf1" \
+ "\\\{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x38"
+ test_one_register "vmovhps" "ymm0" \
+ "0xc004000000000000c004000000000000, 0x0"
+
+ test_one_register "vmovlhps" "ymm15" \
+ "0x0, 0x0"
+ test_one_register "vmovlhps" "ymm0" \
+ "0x0, 0x0"
+ test_one_register "vmovhlps" "ymm15" \
+ "0x2f2e2d2c2b2a29280000000000000000, 0x2f2e2d2c2b2a29282726252423222120"
+ test_one_register "vmovhlps" "ymm0" \
+ "0x2f2e2d2c2b2a29282726252423222120, 0x0"
+
# Explicitly test for the start of the array, since the value repeats.
test_one_memory "vmovaps" "dyn_buf1" \
"\\\{0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28" true
@@ -365,6 +392,24 @@ gdb_test_no_output "set \$xmm1.v2_int64 = {0x1716151413121110, 0x1f1e1d1c1b1a191
"set xmm1 for vpbroadcast"
gdb_test_no_output "set \$ymm15.v2_int128 = {0x0, 0x0}" "set xmm15 for vpbroadcast"
if {[record_full_function "vpbroadcast"] == true} {
+ test_one_register "vbroadcastf128" "ymm0" \
+ "0x17161514131211101716151413121110, 0x17161514131211101716151413121110"
+ test_one_register "vbroadcastsd" "ymm15" \
+ "0x404060004040600040406000404060, 0x0"
+ test_one_register "vbroadcastsd" "ymm0" \
+ "0x13121110131211101312111013121110, 0x13121110131211101312111013121110"
+
+ test_one_register "vbroadcastss" "ymm15" \
+ "0x13121110131211101312111013121110, 0x13121110131211101312111013121110" \
+ "broadcast from memory"
+ test_one_register "vbroadcastss" "ymm0" \
+ "0x13121110131211101312111013121110, 0x0" \
+ "broadcast from memory"
+ test_one_register "vbroadcastss" "ymm15" \
+ "0x17161514131211101716151413121110, 0x17161514131211101716151413121110"
+ test_one_register "vbroadcastss" "ymm0" \
+ "0x17161514131211101716151413121110, 0x17161514131211101716151413121110"
+
test_one_register "vpbroadcastq" "ymm15" "0x13121110131211101312111013121110, 0x0"
test_one_register "vpbroadcastq" "ymm0" "0x13121110131211101312111013121110, 0x0"
@@ -527,9 +572,43 @@ gdb_test_no_output \
"set \$ymm0.v8_float = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5}"
gdb_test_no_output \
"set \$ymm1.v8_float = {0, 1, 2, 3, 4, 5, 6, 7}"
+gdb_test_no_output "set \$ymm2.v2_int128 = {0,0}"
gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}"
if {[record_full_function "arith"] == true} {
+ test_one_register "vpsadbw" "ymm15" \
+ "0x20000000200000004000003f000000, 0x100000001000000010000000100000"
+ test_one_register "vpsadbw" "ymm2" \
+ "0x20000000200000004000003f000000, 0x100000001000000010000000100000"
+ test_one_register "vpandn" "ymm15" \
+ "0x40400000400000003f80000000000000, 0x0"
+ test_one_register "vpand" "ymm15" \
+ "0x10080000000000000000000000000000, 0x10649c00000000001044480000000000"
+ test_one_register "vxorpd" "ymm2" \
+ "0x20000000200000004000003f000000, 0x0"
+ test_one_register "vxorps" "ymm2" \
+ "0x10280000100800000fd0000000000000, 0x10740000106400001054000010440000"
+
+ test_one_register "vpmuludq" "ymm15" \
+ "0x10280000100800000fd0000000000000, 0x10740000106400001054000010440000"
+ test_one_register "vpmulhuw" "ymm15" \
+ "0x0, 0x0"
+ test_one_register "vpmulhw" "ymm2" \
+ "0x18000000000000002000000000000000, 0x0"
+ test_one_register "vpmulld" "ymm15" \
+ "0x80a00000802000007f4000003f000000, 0x81d00000819000008150000081100000"
+ test_one_register "vpmullw" "ymm2" \
+ "0x80a00000802000007f4000003f000000, 0x81d00000819000008150000081100000"
+
+ test_one_register "vpaddq" "ymm15" \
+ "0x80a00000802000007f4000003f000000, 0x0"
+ test_one_register "vpaddd" "ymm2" \
+ "0x80a00000802000007e4000003f000000, 0x0"
+ test_one_register "vpaddw" "ymm15" \
+ "0x40400000400000003fc000003f000000, 0x0"
+ test_one_register "vpaddb" "ymm2" \
+ "0x0, 0x0"
+
test_one_register "vmaxsd" "ymm15" \
"0x40400000400000003f8000003f000000, 0x0" "ymm operation: "
test_one_register "vmaxss" "ymm15" \
@@ -696,3 +775,423 @@ if {[record_full_function "vaddsubps"] == true} {
}
gdb_test "finish" "Run till exit from.*vaddsubps_test.*" \
"leaving vaddsubps"
+
+# Preparation and testing shifting instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for shift"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}" \
+ "set ymm1 for shift"
+gdb_test_no_output "set \$xmm2.uint128 = 1" "set ymm2 for shift"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" "set ymm15 for shift"
+
+if {[record_full_function "shift"] == true} {
+ test_one_register "vpsrldq" "ymm15" \
+ "0x80007000600050004000300, 0x0" \
+ "High ymm register: "
+ test_one_register "vpsrldq" "ymm15" \
+ "0x60005000400030002000100000000, 0xe000d000c000b000a000900000000" \
+ "High xmm register: "
+ test_one_register "vpsrldq" "ymm0" \
+ "0x800070006000500040003000200, 0x0" \
+ "Low ymm register: "
+ test_one_register "vpsrldq" "ymm0" \
+ "0x70006000500040003000200010000, 0xf000e000d000c000b000a00090000" \
+ "Low xmm register: "
+
+ test_one_register "vpslldq" "ymm15" \
+ "0x7000600050004000300020001000000, 0x0" \
+ "High ymm register: "
+ test_one_register "vpslldq" "ymm15" \
+ "0x40003800300020002000180010000, 0x80007800700060006000580050004" \
+ "High xmm register: "
+ test_one_register "vpslldq" "ymm0" \
+ "0x8000700060005000400030002000100, 0x0" \
+ "Low ymm register: "
+ test_one_register "vpslldq" "ymm0" \
+ "0x40003000300020002000100010000, 0x80007000700060006000500050004" \
+ "Low xmm register: "
+
+ test_one_register "vpsrlq" "ymm15" \
+ "0x4000380030000000200018001000, 0x0" \
+ "from register: "
+ test_one_register "vpsrlq" "ymm15" \
+ "0x40003000300020002000100010000, 0x0" \
+ "from constant: "
+ test_one_register "vpsrld" "ymm15" \
+ "0x100000000c0000000800000004000, 0x200010001c0010001800100014001" \
+ "from register: "
+ test_one_register "vpsrld" "ymm15" \
+ "0x40003000300020002000100010000, 0x0" \
+ "from constant: "
+ test_one_register "vpsrlw" "ymm0" \
+ "0x40003000300020002000100010000, 0x0" \
+ "from register: "
+ test_one_register "vpsrlw" "ymm0" \
+ "0x40003000300020002000100010000, 0x80007000700060006000500050004" \
+ "from constant: "
+
+ test_one_register "vpsrad" "ymm15" \
+ "0x100000000c0000000800000004000, 0x200010001c0010001800100014001" \
+ "from register: "
+ test_one_register "vpsrad" "ymm15" \
+ "0x10000e000c000a0008000600040002, 0x20001e001c001a0018001600140012" \
+ "from constant: "
+ test_one_register "vpsraw" "ymm0" \
+ "0x40003000300020002000100010000, 0x0" \
+ "from register: "
+ test_one_register "vpsraw" "ymm0" \
+ "0x10000e000c000a0008000600040002, 0x20001e001c001a0018001600140012" \
+ "from constant: "
+
+ test_one_register "vpsllq" "ymm15" \
+ "0x10000e000c000a00080006000400020, 0x0" \
+ "from register: "
+ test_one_register "vpsllq" "ymm15" \
+ "0x10000e000c000a0008000600040002, 0x0" \
+ "from constant: "
+ test_one_register "vpslld" "ymm15" \
+ "0x400038003000280020001800100008, 0x800078007000680060005800500048" \
+ "from register: "
+ test_one_register "vpslld" "ymm15" "0x0, 0x0" "from constant: "
+ test_one_register "vpsllw" "ymm0" \
+ "0x10000e000c000a0008000600040002, 0x0" \
+ "from register: "
+ test_one_register "vpsllw" "ymm0" "0x0, 0x0" "from constant: "
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for shift_test"
+} else {
+ untested "couldn't run shift tests"
+}
+gdb_test "finish" "Run till exit from.*shift_test.*" \
+ "leaving shift"
+
+# Preparation and testing shuffling instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for shuffle"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}" \
+ "set ymm1 for shuffle"
+gdb_test_no_output "set \$ymm2.v16_int16 = {17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}" \
+ "set ymm2 for shuffle"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" "set ymm15 for shuffle"
+
+if {[record_full_function "shuffle"] == true} {
+ test_one_register "vshufpd" "ymm15" \
+ "0x20001000200010012001100160015, 0xa0009000a0009001a0019001e001d" \
+ "high register: "
+ test_one_register "vshufpd" "ymm0" \
+ "0x20001000200010012001100140013, 0x0" \
+ "low register: "
+ test_one_register "vshufps" "ymm15" \
+ "0x180017001600150011001100120013, 0x0" \
+ "high register: "
+ test_one_register "vshufps" "ymm0" \
+ "0x180017001600150011001100120012, 0x20001f001e001d00190019001a001a" \
+ "low register: "
+
+ test_one_register "vpshuflw" "ymm15" \
+ "0x150015001600150014001300120011, 0x1d001d001e001d001c001b001a0019" \
+ "high register: "
+ test_one_register "vpshuflw" "ymm0" \
+ "0x150015001500180014001300120011, 0x0" \
+ "low register: "
+ test_one_register "vpshufhw" "ymm15" \
+ "0x120011001200110012001100160015, 0x0" \
+ "high register: "
+ test_one_register "vpshufhw" "ymm0" \
+ "0x120011001200110012001100140013, 0x1a0019001a0019001a0019001c001b" \
+ "low register: "
+
+ test_one_register "vpshufd" "ymm15" \
+ "0x11151100111411001113110011121100, 0x1919190019201900191f1900191e1900" \
+ "high register: "
+ test_one_register "vpshufd" "ymm0" \
+ "0x11151100111411001113110011121100, 0x0" \
+ "low register: "
+ test_one_register "vpshufb" "ymm15" "0x0, 0x0" "high register: "
+ test_one_register "vpshufb" "ymm0" "0x0, 0x0" "low register: "
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for shuffle_test"
+} else {
+ untested "couldn't run shuffle tests"
+}
+gdb_test "finish" "Run till exit from.*shuffle_test.*" \
+ "leaving shuffle"
+
+# Preparation and testing permute instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for permute"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}" \
+ "set ymm1 for permute"
+gdb_test_no_output "set \$ymm2.v16_int16 = {17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32}" \
+ "set ymm2 for permute"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" "set ymm15 for permute"
+
+if {[record_full_function "permute"] == true} {
+ test_one_register "vpermps" "ymm15" \
+ "0x40003000200010004000300020001, 0x40003000200010004000300020001"
+ test_one_register "vpermps" "ymm0" \
+ "0x140013001200110014001300120011, 0x140013001200110014001300120011"
+ test_one_register "vpermpd" "ymm0" \
+ "0x120011001200110012001100120011, 0x0"
+ test_one_register "vpermpd" "ymm15" \
+ "0x120011001200110012001100140013, 0x1a0019001a0019001a0019001c001b"
+
+ test_one_register "vpermilps" "ymm0" \
+ "0x180017001400130018001700140013, 0x20001f001c001b0020001f001c001b" \
+ "register version"
+ test_one_register "vpermilps" "ymm15" \
+ "0x180017001400130018001700140013, 0x0" \
+ "register version"
+ test_one_register "vpermilps" "ymm15" \
+ "0x140013001200110018001700160015, 0x1c001b001a0019001c001b001a0019" \
+ "immediate version"
+ test_one_register "vpermilps" "ymm0" \
+ "0x140013001200110014001300120011, 0x0" \
+ "immediate version"
+
+ test_one_register "vpermilpd" "ymm0" \
+ "0x140013001200110014001300120011, 0x1c001b001a0019001c001b001a0019" \
+ "register version"
+ test_one_register "vpermilpd" "ymm15" \
+ "0x140013001200110014001300120011, 0x0" \
+ "register version"
+ test_one_register "vpermilpd" "ymm15" \
+ "0x140013001200110014001300120011, 0x140013001200110014001300120011" \
+ "immediate version"
+ test_one_register "vpermilpd" "ymm0" \
+ "0x40003000200010008000700060005, 0x40003000200010004000300020001" \
+ "immediate version"
+
+ test_one_register "vpermq" "ymm15" \
+ "0x10000f000c000b0008000700040003, 0x10000f000c000b0008000700040003"
+ test_one_register "vpermq" "ymm0" \
+ "0x10000f000c000b0008000700040003, 0x10000f000c000b0008000700040003"
+ test_one_register "vpermd" "ymm15" \
+ "0x80007000600050004000300020001, 0x80007000600050004000300020001"
+ test_one_register "vpermd" "ymm0" \
+ "0x10000f000e000d000c000b000a0009, 0x80007000600050004000300020001"
+
+ test_one_register "vperm2i128" "ymm15" \
+ "0x180017001600150014001300120011, 0x180017001600150014001300120011"
+ test_one_register "vperm2i128" "ymm0" \
+ "0x20001f001e001d001c001b001a0019, 0x180017001600150014001300120011"
+ test_one_register "vperm2f128" "ymm15" "0x0, 0x0"
+ test_one_register "vperm2f128" "ymm0" "0x0, 0x0"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for permute_test"
+} else {
+ untested "couldn't run permute tests"
+}
+gdb_test "finish" "Run till exit from.*permute_test.*" \
+ "leaving permute"
+
+# Preparation and testing extract_insert instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for extract_insert"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}" \
+ "set ymm1 for extract_insert"
+gdb_test_no_output "set \$xmm2.uint128 = 0xcafe" \
+ "set ymm2 for extract_insert"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" "set ymm15 for extract_insert"
+gdb_test_no_output "set \$rax = 0" "set eax for extract_insert"
+
+if {[record_full_function "extract_insert"] == true} {
+ test_one_memory "vpextrw" "global_buf1" \
+ "\\\{0x1, 0x0, 0x2, 0x0, 0x3, 0x0, 0x4, 0x0 <repeats 25 times>"
+ test_one_general_register "vpextrw" "rax" "0x8000700060005"
+
+ test_one_register "vpinsrq" "ymm15" \
+ "0x50000cafe, 0x0"
+ test_one_register "vpinsrd" "ymm0" \
+ "0x500cafe, 0x0"
+ test_one_register "vpinsrw" "ymm15" \
+ "0x80007000600050004000300020001, 0x0"
+ test_one_register "vpinsrb" "ymm0" \
+ "0x80007000600050000cafe00020001, 0x0"
+
+ test_one_memory "vpextrq" "global_buf1" \
+ "\\\{0x5, 0x0, 0x6, 0x0 <repeats 29 times>"
+ test_one_general_register "vpextrq" "rax" "0x80007"
+ test_one_memory "vpextrd" "global_buf1" \
+ "\\\{0x3, 0x0 <repeats 31 times>"
+ test_one_general_register "vpextrd" "rax" "0x0"
+ test_one_memory "vpextrb" "global_buf1" \
+ "\\\{0x0 <repeats 32 times>"
+ test_one_general_register "vpextrb" "rax" "0xcafe"
+
+ test_one_general_register "vextractps" "eax" "0x0"
+ test_one_register "vinsertps" "ymm0" \
+ "0x10000f000e000d000c000b000a0009, 0x0"
+ test_one_register "vextractf128" "ymm15" \
+ "0xcafe, 0x10000f000e000d000c000b000a0009"
+ test_one_register "vextracti128" "ymm0" \
+ "0x80007000600050004000300020001, 0xcafe"
+ test_one_register "vinsertf128" "ymm15" \
+ "0x0, 0x0"
+ test_one_register "vinserti128" "ymm0" \
+ "0x0, 0x0"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for extract_insert_test"
+} else {
+ untested "couldn't run extract_insert tests"
+}
+gdb_test "finish" "Run till exit from.*extract_insert_test.*" \
+ "leaving extract_insert"
+
+# Preparation and testing blend instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for blend"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}" \
+ "set ymm1 for blend"
+gdb_test_no_output \
+ "set \$ymm2.v16_int16 = {17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}" \
+ "set ymm2 for blend"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" "set ymm15 for blend"
+
+if {[record_full_function "blend"] == true} {
+ test_one_register "vpblendvb" "ymm0" \
+ "0x180017000600050004000300120011, 0x20001f001e001d001c001b000a0009"
+ test_one_register "vpblendvb" "ymm15" \
+ "0x80007001600150004000300020001, 0x0"
+ test_one_register "vpblendd" "ymm15" \
+ "0x180007001600050004000300020011, 0x20000f001e000d000c000b000a0019"
+ test_one_register "vpblendd" "ymm0" \
+ "0x180017000600150004000300020001, 0x0"
+ test_one_register "vpblendw" "ymm0" \
+ "0x180017001600150014001300120011, 0x20001f001e001d001c001b001a0019"
+ test_one_register "vpblendw" "ymm15" \
+ "0x180017001600150014001300120011, 0x0"
+
+ test_one_register "vblendvpd" "ymm15" \
+ "0x80007000600050014001300120011, 0x10000f000e000d001c001b001a0019"
+ test_one_register "vblendvps" "ymm0" \
+ "0x180017000600050014001300020001, 0x0"
+ test_one_register "vblendpd" "ymm15" "0x0, 0x0"
+ test_one_register "vblendps" "ymm0" "0x0, 0x0"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for blend_test"
+} else {
+ untested "couldn't run blend tests"
+}
+gdb_test "finish" "Run till exit from.*blend_test.*" \
+ "leaving blend"
+
+# Preparation and testing compare instructions.
+gdb_test_no_output \
+ "set \$xmm0.v4_float = {0, 1.5, 2, 0}" "set ymm0 for compare"
+gdb_test_no_output \
+ "set \$xmm1.v4_float = {0, 1, 2.5, -1}" "set ymm1 for compare"
+gdb_test_no_output \
+ "set \$xmm15.v4_float = {-1, -2, 10, 100}" "set ymm15 for compare"
+gdb_test_no_output "set \$eflags = 2"
+
+if {[record_full_function "compare"] == true} {
+ test_one_general_register "vucomisd" "eflags" "0x203"
+ test_one_general_register "vucomiss" "eflags" "0x202"
+ test_one_general_register "vcomiss" "eflags" "0x203"
+ test_one_general_register "vcomisd" "eflags" "0x202"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for compare_test"
+} else {
+ untested "couldn't run compare tests"
+}
+gdb_test "finish" "Run till exit from.*compare_test.*" \
+ "leaving compare"
+
+# Preparation and testing pack instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0, 0}" "set ymm0 for pack"
+gdb_test_no_output \
+ "set \$ymm1.v16_int16 = {0x1020, 0x1121, 0x1222, 0x1323, 0x1424, 0x1525, 0x1626, 0x1727, 0x1828, 0x1929, 0x1a2a, 0x1b2b, 0x1c2c, 0x1d2d, 0x1e2e, 0x1f2f}" \
+ "set ymm1 for pack"
+gdb_test_no_output \
+ "set \$ymm2.v16_int16 = {0x3040, 0x3141, 0x3242, 0x3343, 0x3444, 0x3545, 0x3646, 0x3747, 0x3848, 0x3949, 0x3a4a, 0x3b4b, 0x3c4c, 0x3d4d, 0x3e4e, 0x3f4f}" \
+ "set ymm2 for pack"
+gdb_test_no_output \
+ "set \$ymm15.v2_int128 = {0, 0}" "set ymm15 for pack"
+
+if {[record_full_function "pack"] == true} {
+ test_one_register "vpackusdw" "ymm0" \
+ "0xffffffffffffffffffffffffffffffff, 0x0"
+ test_one_register "vpackusdw" "ymm15" \
+ "0xffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffff"
+ test_one_register "vpackuswb" "ymm15" \
+ "0x7fff7fff7fff7fff7fff7fff7fff7fff, 0x0"
+ test_one_register "vpackuswb" "ymm0" \
+ "0x7fff7fff7fff7fff7fff7fff7fff7fff, 0x7fff7fff7fff7fff7fff7fff7fff7fff"
+ test_one_register "vpackssdw" "ymm0" \
+ "0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f, 0x0"
+ test_one_register "vpackssdw" "ymm15" \
+ "0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f, 0x7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"
+ test_one_register "vpacksswb" "ymm15" "0x0, 0x0"
+ test_one_register "vpacksswb" "ymm0" "0x0, 0x0"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for pack_test"
+} else {
+ untested "couldn't run pack tests"
+}
+gdb_test "finish" "Run till exit from.*pack_test.*" \
+ "leaving pack"
+
+# Preparation and testing converting instructions.
+gdb_test_no_output \
+ "set \$ymm0.v2_int128 = {0,0}" \
+ "set ymm0 for convert test"
+gdb_test_no_output \
+ "set \$ymm1.v8_float = {0, 1, 2.5, 10, -1, -2.5, 0}" \
+ "set ymm1 for convert test"
+gdb_test_no_output "set \$ymm15.v2_int128 = {0,0}" \
+ "set ymm15 for convert test"
+gdb_test_no_output "set \$ecx = -1" "set ecx for convert test"
+gdb_test_no_output "set \$ebx = 1" "set ebx for convert test"
+
+if {[record_full_function "convert"] == true} {
+ gdb_test "maint print record-instruction" ".*"
+ test_one_general_register "vcvttss2si" "ecx" "0xffffffff"
+ test_one_general_register "vcvttsd2si" "ebx" "0x0"
+ test_one_register "vcvttps2dq" "ymm15" \
+ "0x41200000402000003f8000004f800000, 0x0"
+ test_one_register "vcvttpd2dq" "ymm0" \
+ "0x412000004020000041f0000000000000, 0x0"
+ test_one_general_register "vcvtss2si" "ebx" "0x0"
+
+ test_one_register "vcvtss2sd" "ymm0" \
+ "0x412000004020000041efffffffe00000, 0x0"
+ test_one_register "vcvtsi2ss" "ymm15" \
+ "0x41200000402000003f80000000000000, 0x0"
+ test_one_register "vcvtsi2sd" "ymm0" \
+ "0x8000000000000, 0x0"
+ test_one_register "vcvtsd2ss" "ymm15" \
+ "0x490000023c000000, 0x0"
+ test_one_general_register "vcvtsd2si" "ebx" "0x1"
+
+ test_one_register "vcvtpd2dq" "ymm0" \
+ "0x3ff00000000000000000000000000000, 0x0"
+ test_one_register "vcvtpd2ps" "ymm15" \
+ "0xa000000020000000100000000, 0x0"
+ test_one_register "vcvtps2pd" "ymm0" \
+ "0x4e8240004e8040004e7e000000000000, 0x0"
+ test_one_register "vcvtps2dq" "ymm15" \
+ "0x41cfc000000000000000000000000000, 0x0"
+ test_one_register "vcvtdq2pd" "ymm15" "0x0, 0x0"
+ test_one_register "vcvtdq2ps" "ymm0" "0x0, 0x0"
+
+ gdb_test "record stop" "Process record is stopped.*" \
+ "delete history for convert_test"
+} else {
+ untested "couldn't run convert tests"
+}
+gdb_test "finish" "Run till exit from.*convert_test.*" \
+ "leaving convert"
generated by cgit v1.1 at 2025-07-13 02:34:18 +0000