Reduce the code duplication and improve maintainability of x86 register
tests by combining all of them to a single base function.
---
tests/lib/libc/sys/t_ptrace_amd64_wait.h | 406 +---
tests/lib/libc/sys/t_ptrace_i386_wait.h | 335 +--
tests/lib/libc/sys/t_ptrace_x86_wait.h | 2417 ++++++++++------------
3 files changed, 1103 insertions(+), 2055 deletions(-)
diff --git a/tests/lib/libc/sys/t_ptrace_amd64_wait.h
b/tests/lib/libc/sys/t_ptrace_amd64_wait.h
index 1ea17ea1ec1a..0f410f3600d0 100644
--- a/tests/lib/libc/sys/t_ptrace_amd64_wait.h
+++ b/tests/lib/libc/sys/t_ptrace_amd64_wait.h
@@ -111,415 +111,11 @@ ATF_TC_BODY(x86_64_regs1, tc)
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-ATF_TC(x86_64_regs_gp_read);
-ATF_TC_HEAD(x86_64_regs_gp_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set general-purpose reg values from debugged program and read "
- "them via PT_GETREGS, comparing values against expected.");
-}
-
-ATF_TC_BODY(x86_64_regs_gp_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint64_t rax = 0x0001020304050607;
- const uint64_t rbx = 0x1011121314151617;
- const uint64_t rcx = 0x2021222324252627;
- const uint64_t rdx = 0x3031323334353637;
- const uint64_t rsi = 0x4041424344454647;
- const uint64_t rdi = 0x5051525354555657;
- const uint64_t rsp = 0x6061626364656667;
- const uint64_t rbp = 0x7071727374757677;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* rbp & rbp are a bit tricky, we must not clobber them
*/
- "movq %%rsp, %%r8\n\t"
- "movq %%rbp, %%r9\n\t"
- "movq %6, %%rsp\n\t"
- "movq %7, %%rbp\n\t"
- "\n\t"
- "int3\n\t"
- "\n\t"
- "movq %%r8, %%rsp\n\t"
- "movq %%r9, %%rbp\n\t"
- :
- : "a"(rax), "b"(rbx), "c"(rcx), "d"(rdx), "S"(rsi),
"D"(rdi),
- "i"(rsp), "i"(rbp)
- : "%r8", "%r9"
- );
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RAX], rax);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RBX], rbx);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RCX], rcx);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RDX], rdx);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RSI], rsi);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RDI], rdi);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RSP], rsp);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RBP], rbp);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_64_regs_gp_write);
-ATF_TC_HEAD(x86_64_regs_gp_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set general-purpose reg values into a debugged program via "
- "PT_SETREGS and compare the result against expected.");
-}
-
-ATF_TC_BODY(x86_64_regs_gp_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint64_t rax = 0x0001020304050607;
- const uint64_t rbx = 0x1011121314151617;
- const uint64_t rcx = 0x2021222324252627;
- const uint64_t rdx = 0x3031323334353637;
- const uint64_t rsi = 0x4041424344454647;
- const uint64_t rdi = 0x5051525354555657;
- const uint64_t rsp = 0x6061626364656667;
- const uint64_t rbp = 0x7071727374757677;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
- uint64_t v_rax, v_rbx, v_rcx, v_rdx, v_rsi, v_rdi, v_rsp, v_rbp;
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* save rsp & rbp */
- "movq %%rsp, %4\n\t"
- "movq %%rbp, %5\n\t"
- "\n\t"
- /* fill registers with clobber pattern */
- "movq %8, %%rax\n\t"
- "movq %8, %%rbx\n\t"
- "movq %8, %%rcx\n\t"
- "movq %8, %%rdx\n\t"
- "movq %8, %%rsp\n\t"
- "movq %8, %%rbp\n\t"
- "movq %8, %%rsi\n\t"
- "movq %8, %%rdi\n\t"
- "\n\t"
- "int3\n\t"
- "\n\t"
- /* swap saved & current rsp & rbp */
- "xchgq %%rsp, %4\n\t"
- "xchgq %%rbp, %5\n\t"
- : "=a"(v_rax), "=b"(v_rbx), "=c"(v_rcx), "=d"(v_rdx),
"=r"(v_rsp),
- "=r"(v_rbp), "=S"(v_rsi), "=D"(v_rdi)
- : "g"(fill)
- :
- );
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_rax, rax);
- FORKEE_ASSERT_EQ(v_rbx, rbx);
- FORKEE_ASSERT_EQ(v_rcx, rcx);
- FORKEE_ASSERT_EQ(v_rdx, rdx);
- FORKEE_ASSERT_EQ(v_rsi, rsi);
- FORKEE_ASSERT_EQ(v_rdi, rdi);
- FORKEE_ASSERT_EQ(v_rsp, rsp);
- FORKEE_ASSERT_EQ(v_rbp, rbp);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- gpr.regs[_REG_RAX] = rax;
- gpr.regs[_REG_RBX] = rbx;
- gpr.regs[_REG_RCX] = rcx;
- gpr.regs[_REG_RDX] = rdx;
- gpr.regs[_REG_RSI] = rsi;
- gpr.regs[_REG_RDI] = rdi;
- gpr.regs[_REG_RSP] = rsp;
- gpr.regs[_REG_RBP] = rbp;
-
- DPRINTF("Call SETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETREGS, child, &gpr, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_64_regs_r8_read);
-ATF_TC_HEAD(x86_64_regs_r8_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set r8..r15 reg values from debugged program and read "
- "them via PT_GETREGS, comparing values against expected.");
-}
-
-ATF_TC_BODY(x86_64_regs_r8_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint64_t r8[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- "movq 0x00(%%rbx), %%r8\n\t"
- "movq 0x08(%%rbx), %%r9\n\t"
- "movq 0x10(%%rbx), %%r10\n\t"
- "movq 0x18(%%rbx), %%r11\n\t"
- "movq 0x20(%%rbx), %%r12\n\t"
- "movq 0x28(%%rbx), %%r13\n\t"
- "movq 0x30(%%rbx), %%r14\n\t"
- "movq 0x38(%%rbx), %%r15\n\t"
- "int3\n\t"
- :
- : "b"(r8)
- : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14",
"%r15"
- );
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R8], r8[0]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R9], r8[1]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R10], r8[2]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R11], r8[3]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R12], r8[4]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R13], r8[5]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R14], r8[6]);
- ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R15], r8[7]);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_64_regs_r8_write);
-ATF_TC_HEAD(x86_64_regs_r8_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set r8..r15 reg values into a debugged program via "
- "PT_SETREGS and compare the result against expected.");
-}
-
-ATF_TC_BODY(x86_64_regs_r8_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint64_t r8[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
- uint64_t v_r8[8];
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* fill registers with clobber pattern */
- "movq %1, %%r8\n\t"
- "movq %1, %%r9\n\t"
- "movq %1, %%r10\n\t"
- "movq %1, %%r11\n\t"
- "movq %1, %%r12\n\t"
- "movq %1, %%r13\n\t"
- "movq %1, %%r14\n\t"
- "movq %1, %%r15\n\t"
- "\n\t"
- "int3\n\t"
- "\n\t"
- "movq %%r8, 0x00(%0)\n\t"
- "movq %%r9, 0x08(%0)\n\t"
- "movq %%r10, 0x10(%0)\n\t"
- "movq %%r11, 0x18(%0)\n\t"
- "movq %%r12, 0x20(%0)\n\t"
- "movq %%r13, 0x28(%0)\n\t"
- "movq %%r14, 0x30(%0)\n\t"
- "movq %%r15, 0x38(%0)\n\t"
- :
- : "a"(v_r8), "m"(fill)
- : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14",
"%r15"
- );
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_r8[0], r8[0]);
- FORKEE_ASSERT_EQ(v_r8[1], r8[1]);
- FORKEE_ASSERT_EQ(v_r8[2], r8[2]);
- FORKEE_ASSERT_EQ(v_r8[3], r8[3]);
- FORKEE_ASSERT_EQ(v_r8[4], r8[4]);
- FORKEE_ASSERT_EQ(v_r8[5], r8[5]);
- FORKEE_ASSERT_EQ(v_r8[6], r8[6]);
- FORKEE_ASSERT_EQ(v_r8[7], r8[7]);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- gpr.regs[_REG_R8] = r8[0];
- gpr.regs[_REG_R9] = r8[1];
- gpr.regs[_REG_R10] = r8[2];
- gpr.regs[_REG_R11] = r8[3];
- gpr.regs[_REG_R12] = r8[4];
- gpr.regs[_REG_R13] = r8[5];
- gpr.regs[_REG_R14] = r8[6];
- gpr.regs[_REG_R15] = r8[7];
-
- DPRINTF("Call SETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETREGS, child, &gpr, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
///
----------------------------------------------------------------------------
#define ATF_TP_ADD_TCS_PTRACE_WAIT_AMD64() \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs1); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs_gp_read); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs_gp_write); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs_r8_read); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs_r8_write);
+ ATF_TP_ADD_TC_HAVE_GPREGS(tp, x86_64_regs1);
#else
#define ATF_TP_ADD_TCS_PTRACE_WAIT_AMD64()
#endif
diff --git a/tests/lib/libc/sys/t_ptrace_i386_wait.h
b/tests/lib/libc/sys/t_ptrace_i386_wait.h
index 7250f4eb66db..8db74261bb35 100644
--- a/tests/lib/libc/sys/t_ptrace_i386_wait.h
+++ b/tests/lib/libc/sys/t_ptrace_i386_wait.h
@@ -101,341 +101,8 @@ ATF_TC_BODY(i386_regs1, tc)
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-ATF_TC(i386_regs_gp_read);
-ATF_TC_HEAD(i386_regs_gp_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set general-purpose reg values from debugged program and read "
- "them via PT_GETREGS, comparing values against expected.");
-}
-
-ATF_TC_BODY(i386_regs_gp_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint32_t eax = 0x00010203;
- const uint32_t ebx = 0x10111213;
- const uint32_t ecx = 0x20212223;
- const uint32_t edx = 0x30313233;
- const uint32_t esi = 0x40414243;
- const uint32_t edi = 0x50515253;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- "int3\n\t"
- :
- : "a"(eax), "b"(ebx), "c"(ecx), "d"(edx), "S"(esi),
"D"(edi)
- :
- );
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- ATF_CHECK_EQ((uint32_t)gpr.r_eax, eax);
- ATF_CHECK_EQ((uint32_t)gpr.r_ebx, ebx);
- ATF_CHECK_EQ((uint32_t)gpr.r_ecx, ecx);
- ATF_CHECK_EQ((uint32_t)gpr.r_edx, edx);
- ATF_CHECK_EQ((uint32_t)gpr.r_esi, esi);
- ATF_CHECK_EQ((uint32_t)gpr.r_edi, edi);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(i386_regs_gp_write);
-ATF_TC_HEAD(i386_regs_gp_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set general-purpose reg values into a debugged program via "
- "PT_SETREGS and compare the result against expected.");
-}
-
-ATF_TC_BODY(i386_regs_gp_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint32_t eax = 0x00010203;
- const uint32_t ebx = 0x10111213;
- const uint32_t ecx = 0x20212223;
- const uint32_t edx = 0x30313233;
- const uint32_t esi = 0x40414243;
- const uint32_t edi = 0x50515253;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- const uint64_t fill = 0x0F0F0F0F;
- uint32_t v_eax, v_ebx, v_ecx, v_edx, v_esi, v_edi;
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* fill registers with clobber pattern */
- "movl %6, %%eax\n\t"
- "movl %6, %%ebx\n\t"
- "movl %6, %%ecx\n\t"
- "movl %6, %%edx\n\t"
- "movl %6, %%esi\n\t"
- "movl %6, %%edi\n\t"
- "\n\t"
- "int3\n\t"
- : "=a"(v_eax), "=b"(v_ebx), "=c"(v_ecx), "=d"(v_edx),
"=S"(v_esi),
- "=D"(v_edi)
- : "g"(fill)
- :
- );
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_eax, eax);
- FORKEE_ASSERT_EQ(v_ebx, ebx);
- FORKEE_ASSERT_EQ(v_ecx, ecx);
- FORKEE_ASSERT_EQ(v_edx, edx);
- FORKEE_ASSERT_EQ(v_esi, esi);
- FORKEE_ASSERT_EQ(v_edi, edi);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- gpr.r_eax = eax;
- gpr.r_ebx = ebx;
- gpr.r_ecx = ecx;
- gpr.r_edx = edx;
- gpr.r_esi = esi;
- gpr.r_edi = edi;
-
- DPRINTF("Call SETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETREGS, child, &gpr, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(i386_regs_ebp_esp_read);
-ATF_TC_HEAD(i386_regs_ebp_esp_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set EBP & ESP reg values from debugged program and read "
- "them via PT_GETREGS, comparing values against expected.");
-}
-
-ATF_TC_BODY(i386_regs_ebp_esp_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint32_t esp = 0x60616263;
- const uint32_t ebp = 0x70717273;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* ebp & ebp are a bit tricky, we must not clobber them
*/
- "movl %%esp, %%eax\n\t"
- "movl %%ebp, %%ebx\n\t"
- "movl %0, %%esp\n\t"
- "movl %1, %%ebp\n\t"
- "\n\t"
- "int3\n\t"
- "\n\t"
- "movl %%eax, %%esp\n\t"
- "movl %%ebx, %%ebp\n\t"
- :
- : "ri"(esp), "ri"(ebp)
- : "%eax", "%ebx"
- );
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- ATF_CHECK_EQ((uint32_t)gpr.r_esp, esp);
- ATF_CHECK_EQ((uint32_t)gpr.r_ebp, ebp);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(i386_regs_ebp_esp_write);
-ATF_TC_HEAD(i386_regs_ebp_esp_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set EBP & ESP reg values into a debugged program via "
- "PT_SETREGS and compare the result against expected.");
-}
-
-ATF_TC_BODY(i386_regs_ebp_esp_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct reg gpr;
-
- const uint32_t esp = 0x60616263;
- const uint32_t ebp = 0x70717273;
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- const uint64_t fill = 0x0F0F0F0F;
- uint32_t v_esp, v_ebp;
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
-
- __asm__ __volatile__(
- /* save original ebp & esp using our output registers */
- "movl %%esp, %0\n\t"
- "movl %%ebp, %1\n\t"
- /* fill them with clobber pattern */
- "movl %2, %%esp\n\t"
- "movl %2, %%ebp\n\t"
- "\n\t"
- "int3\n\t"
- "\n\t"
- /* restore ebp & esp, and save the result */
- "xchgl %%esp, %0\n\t"
- "xchgl %%ebp, %1\n\t"
- : "=r"(v_esp), "=r"(v_ebp)
- : "g"(fill)
- :
- );
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_esp, esp);
- FORKEE_ASSERT_EQ(v_ebp, ebp);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
-
- gpr.r_esp = esp;
- gpr.r_ebp = ebp;
-
- DPRINTF("Call SETREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETREGS, child, &gpr, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
#define ATF_TP_ADD_TCS_PTRACE_WAIT_I386() \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs1); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs_gp_read); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs_gp_write); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs_ebp_esp_read); \
- ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs_ebp_esp_write);
+ ATF_TP_ADD_TC_HAVE_GPREGS(tp, i386_regs1);
#else
#define ATF_TP_ADD_TCS_PTRACE_WAIT_I386()
#endif
diff --git a/tests/lib/libc/sys/t_ptrace_x86_wait.h
b/tests/lib/libc/sys/t_ptrace_x86_wait.h
index 6d177d4624e9..4572e3eb8b23 100644
--- a/tests/lib/libc/sys/t_ptrace_x86_wait.h
+++ b/tests/lib/libc/sys/t_ptrace_x86_wait.h
@@ -2189,1273 +2189,400 @@ ATF_TC_BODY(x86_cve_2018_8897, tc)
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-ATF_TC(x86_regs_mm_read);
-ATF_TC_HEAD(x86_regs_mm_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set MMX (mm0..mm7) reg values from debugged program and read "
- "them via PT_GETFPREGS, comparing values against expected.");
-}
+///
----------------------------------------------------------------------------
-__attribute__((target("mmx")))
-static __inline void set_mm_regs(const uint64_t mm[])
+union x86_test_register {
+ struct {
+ uint64_t a, b, c, d;
+ } ymm;
+ struct {
+ uint64_t a, b;
+ } xmm;
+ uint64_t u64;
+ uint32_t u32;
+};
+
+enum x86_test_regset {
+ TEST_GPREGS,
+ TEST_FPREGS,
+ TEST_XMMREGS,
+ TEST_XSTATE
+};
+
+/* Please keep them grouped by acceptable x86_test_regset. */
+enum x86_test_registers {
+ /* TEST_GPREGS */
+ GPREGS_32,
+ GPREGS_32_EBP_ESP,
+ GPREGS_64,
+ GPREGS_64_R8,
+ /* TEST_FPREGS/TEST_XMMREGS */
+ FPREGS_MM,
+ FPREGS_XMM,
+ /* TEST_XSTATE */
+ FPREGS_YMM
+};
+
+enum x86_test_regmode {
+ TEST_GETREGS,
+ TEST_SETREGS
+};
+
+static __inline void get_gp32_regs(union x86_test_register out[])
{
+#if defined(__i386__)
+ const uint32_t fill = 0x0F0F0F0F;
+
__asm__ __volatile__(
- "movq 0x00(%0), %%mm0\n\t"
- "movq 0x08(%0), %%mm1\n\t"
- "movq 0x10(%0), %%mm2\n\t"
- "movq 0x18(%0), %%mm3\n\t"
- "movq 0x20(%0), %%mm4\n\t"
- "movq 0x28(%0), %%mm5\n\t"
- "movq 0x30(%0), %%mm6\n\t"
- "movq 0x38(%0), %%mm7\n\t"
+ /* fill registers with clobber pattern */
+ "movl %6, %%eax\n\t"
+ "movl %6, %%ebx\n\t"
+ "movl %6, %%ecx\n\t"
+ "movl %6, %%edx\n\t"
+ "movl %6, %%esi\n\t"
+ "movl %6, %%edi\n\t"
+ "\n\t"
"int3\n\t"
- :
- : "b"(mm)
- : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
+ : "=a"(out[0].u32), "=b"(out[1].u32), "=c"(out[2].u32),
+ "=d"(out[3].u32), "=S"(out[4].u32), "=D"(out[5].u32)
+ : "g"(fill)
);
+#else
+ __unreachable();
+#endif
}
-ATF_TC_BODY(x86_regs_mm_read, tc)
+static __inline void set_gp32_regs(const union x86_test_register data[])
{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct fpreg fpr;
-
- const uint64_t mm[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- /* verify whether MMX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_MMX))
- atf_tc_skip("MMX is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- set_mm_regs(mm);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1);
-
-#if defined(__x86_64__)
-#define MM_REG(n) fpr.fxstate.fx_87_ac[n].r.f87_mantissa
+#if defined(__i386__)
+ __asm__ __volatile__(
+ "int3\n\t"
+ :
+ : "a"(data[0].u32), "b"(data[1].u32), "c"(data[2].u32),
+ "d"(data[3].u32), "S"(data[4].u32), "D"(data[5].u32)
+ :
+ );
#else
-#define MM_REG(n) fpr.fstate.s87_ac[n].f87_mantissa
+ __unreachable();
#endif
-
- ATF_CHECK_EQ(MM_REG(0), mm[0]);
- ATF_CHECK_EQ(MM_REG(1), mm[1]);
- ATF_CHECK_EQ(MM_REG(2), mm[2]);
- ATF_CHECK_EQ(MM_REG(3), mm[3]);
- ATF_CHECK_EQ(MM_REG(4), mm[4]);
- ATF_CHECK_EQ(MM_REG(5), mm[5]);
- ATF_CHECK_EQ(MM_REG(6), mm[6]);
- ATF_CHECK_EQ(MM_REG(7), mm[7]);
-
-#undef MM_REG
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-__attribute__((target("mmx")))
-static __inline void get_mm_regs(uint64_t v_mm[])
+static __inline void get_gp32_ebp_esp_regs(union x86_test_register out[])
{
- const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
+#if defined(__i386__)
+ const uint32_t fill = 0x0F0F0F0F;
__asm__ __volatile__(
- /* fill registers with clobber pattern */
- "movq %1, %%mm0\n\t"
- "movq %1, %%mm1\n\t"
- "movq %1, %%mm2\n\t"
- "movq %1, %%mm3\n\t"
- "movq %1, %%mm4\n\t"
- "movq %1, %%mm5\n\t"
- "movq %1, %%mm6\n\t"
- "movq %1, %%mm7\n\t"
+ /* save original ebp & esp using our output registers */
+ "movl %%esp, %0\n\t"
+ "movl %%ebp, %1\n\t"
+ /* fill them with clobber pattern */
+ "movl %2, %%esp\n\t"
+ "movl %2, %%ebp\n\t"
"\n\t"
"int3\n\t"
"\n\t"
- "movq %%mm0, 0x00(%0)\n\t"
- "movq %%mm1, 0x08(%0)\n\t"
- "movq %%mm2, 0x10(%0)\n\t"
- "movq %%mm3, 0x18(%0)\n\t"
- "movq %%mm4, 0x20(%0)\n\t"
- "movq %%mm5, 0x28(%0)\n\t"
- "movq %%mm6, 0x30(%0)\n\t"
- "movq %%mm7, 0x38(%0)\n\t"
+ /* restore ebp & esp, and save the result */
+ "xchgl %%esp, %0\n\t"
+ "xchgl %%ebp, %1\n\t"
+ : "=r"(out[0].u32), "=r"(out[1].u32)
+ : "g"(fill)
:
- : "a"(v_mm), "m"(fill)
- : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
);
-}
-
-ATF_TC(x86_regs_mm_write);
-ATF_TC_HEAD(x86_regs_mm_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set mm0..mm7 reg values into a debugged program via "
- "PT_SETFPREGS and compare the result against expected.");
-}
-
-ATF_TC_BODY(x86_regs_mm_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct fpreg fpr;
-
- const uint64_t mm[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- /* verify whether MMX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_MMX))
- atf_tc_skip("MMX is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- uint64_t v_mm[8];
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- get_mm_regs(v_mm);
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_mm[0], mm[0]);
- FORKEE_ASSERT_EQ(v_mm[1], mm[1]);
- FORKEE_ASSERT_EQ(v_mm[2], mm[2]);
- FORKEE_ASSERT_EQ(v_mm[3], mm[3]);
- FORKEE_ASSERT_EQ(v_mm[4], mm[4]);
- FORKEE_ASSERT_EQ(v_mm[5], mm[5]);
- FORKEE_ASSERT_EQ(v_mm[6], mm[6]);
- FORKEE_ASSERT_EQ(v_mm[7], mm[7]);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- DPRINTF("Call GETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1);
-
-#if defined(__x86_64__)
-#define MM_REG(n) fpr.fxstate.fx_87_ac[n].r.f87_mantissa
#else
-#define MM_REG(n) fpr.fstate.s87_ac[n].f87_mantissa
+ __unreachable();
#endif
-
- MM_REG(0) = mm[0];
- MM_REG(1) = mm[1];
- MM_REG(2) = mm[2];
- MM_REG(3) = mm[3];
- MM_REG(4) = mm[4];
- MM_REG(5) = mm[5];
- MM_REG(6) = mm[6];
- MM_REG(7) = mm[7];
-
-#undef MM_REG
-
- DPRINTF("Call SETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETFPREGS, child, &fpr, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-__attribute__((target("sse")))
-static __inline void set_xmm_regs(const void* xmm)
+static __inline void set_gp32_ebp_esp_regs(const union x86_test_register
data[])
{
+#if defined(__i386__)
__asm__ __volatile__(
- "movaps 0x00(%0), %%xmm0\n\t"
- "movaps 0x10(%0), %%xmm1\n\t"
- "movaps 0x20(%0), %%xmm2\n\t"
- "movaps 0x30(%0), %%xmm3\n\t"
- "movaps 0x40(%0), %%xmm4\n\t"
- "movaps 0x50(%0), %%xmm5\n\t"
- "movaps 0x60(%0), %%xmm6\n\t"
- "movaps 0x70(%0), %%xmm7\n\t"
-#if defined(__x86_64__)
- "movaps 0x80(%0), %%xmm8\n\t"
- "movaps 0x90(%0), %%xmm9\n\t"
- "movaps 0xA0(%0), %%xmm10\n\t"
- "movaps 0xB0(%0), %%xmm11\n\t"
- "movaps 0xC0(%0), %%xmm12\n\t"
- "movaps 0xD0(%0), %%xmm13\n\t"
- "movaps 0xE0(%0), %%xmm14\n\t"
- "movaps 0xF0(%0), %%xmm15\n\t"
-#endif
+ /* ebp & ebp are a bit tricky, we must not clobber them */
+ "movl %%esp, %%eax\n\t"
+ "movl %%ebp, %%ebx\n\t"
+ "movl %0, %%esp\n\t"
+ "movl %1, %%ebp\n\t"
+ "\n\t"
"int3\n\t"
+ "\n\t"
+ "movl %%eax, %%esp\n\t"
+ "movl %%ebx, %%ebp\n\t"
:
- : "b"(xmm)
- : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6",
- "%xmm7"
-#if defined(__x86_64__)
- , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
- "%xmm14", "%xmm15"
-#endif
+ : "ri"(data[0].u32), "ri"(data[1].u32)
+ : "%eax", "%ebx"
);
+#else
+ __unreachable();
+#endif
}
-ATF_TC(x86_regs_xmm_read);
-ATF_TC_HEAD(x86_regs_xmm_read, tc)
+static __inline void get_gp64_regs(union x86_test_register out[])
{
- atf_tc_set_md_var(tc, "descr",
- "Set xmm0..xmm15 (..xmm7 on i386) reg values from debugged
program "
- "and read them via PT_GETFPREGS (PT_GETXMMREGS on i386),
comparing "
- "values against expected.");
+#if defined(__x86_64__)
+ const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
+
+ __asm__ __volatile__(
+ /* save rsp & rbp */
+ "movq %%rsp, %6\n\t"
+ "movq %%rbp, %7\n\t"
+ "\n\t"
+ /* fill registers with clobber pattern */
+ "movq %8, %%rax\n\t"
+ "movq %8, %%rbx\n\t"
+ "movq %8, %%rcx\n\t"
+ "movq %8, %%rdx\n\t"
+ "movq %8, %%rsp\n\t"
+ "movq %8, %%rbp\n\t"
+ "movq %8, %%rsi\n\t"
+ "movq %8, %%rdi\n\t"
+ "\n\t"
+ "int3\n\t"
+ "\n\t"
+ /* swap saved & current rsp & rbp */
+ "xchgq %%rsp, %6\n\t"
+ "xchgq %%rbp, %7\n\t"
+ : "=a"(out[0].u64), "=b"(out[1].u64), "=c"(out[2].u64),
+ "=d"(out[3].u64), "=S"(out[4].u64), "=D"(out[5].u64),
+ "=r"(out[6].u64), "=r"(out[7].u64)
+ : "g"(fill)
+ );
+#else
+ __unreachable();
+#endif
}
-ATF_TC_BODY(x86_regs_xmm_read, tc)
+static __inline void set_gp64_regs(const union x86_test_register data[])
{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
#if defined(__x86_64__)
- struct fpreg fpr;
+ __asm__ __volatile__(
+ /* rbp & rbp are a bit tricky, we must not clobber them */
+ "movq %%rsp, %%r8\n\t"
+ "movq %%rbp, %%r9\n\t"
+ "movq %6, %%rsp\n\t"
+ "movq %7, %%rbp\n\t"
+ "\n\t"
+ "int3\n\t"
+ "\n\t"
+ "movq %%r8, %%rsp\n\t"
+ "movq %%r9, %%rbp\n\t"
+ :
+ : "a"(data[0].u64), "b"(data[1].u64), "c"(data[2].u64),
+ "d"(data[3].u64), "S"(data[4].u64), "D"(data[5].u64),
+ "r"(data[6].u64), "r"(data[7].u64)
+ : "%r8", "%r9"
+ );
#else
- struct xmmregs fpr;
+ __unreachable();
#endif
+}
- const struct {
- uint64_t a, b;
- } xmm[] __aligned(16) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F, },
+static __inline void get_gp64_r8_regs(union x86_test_register out[])
+{
#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817, },
-#endif
- };
-
- /* verify whether SSE is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_SSE))
- atf_tc_skip("SSE is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- set_xmm_regs(xmm);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
+ const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
-#if defined(__x86_64__)
- DPRINTF("Call GETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1);
+ __asm__ __volatile__(
+ /* fill registers with clobber pattern */
+ "movq %1, %%r8\n\t"
+ "movq %1, %%r9\n\t"
+ "movq %1, %%r10\n\t"
+ "movq %1, %%r11\n\t"
+ "movq %1, %%r12\n\t"
+ "movq %1, %%r13\n\t"
+ "movq %1, %%r14\n\t"
+ "movq %1, %%r15\n\t"
+ "\n\t"
+ "int3\n\t"
+ "\n\t"
+ "movq %%r8, 0x00(%0)\n\t"
+ "movq %%r9, 0x20(%0)\n\t"
+ "movq %%r10, 0x40(%0)\n\t"
+ "movq %%r11, 0x60(%0)\n\t"
+ "movq %%r12, 0x80(%0)\n\t"
+ "movq %%r13, 0xA0(%0)\n\t"
+ "movq %%r14, 0xC0(%0)\n\t"
+ "movq %%r15, 0xE0(%0)\n\t"
+ :
+ : "a"(out), "m"(fill)
+ : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
+ );
#else
- DPRINTF("Call GETXMMREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXMMREGS, child, &fpr, 0) != -1);
-#endif
-
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[0], &xmm[0], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[1], &xmm[1], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[2], &xmm[2], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[3], &xmm[3], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[4], &xmm[4], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[5], &xmm[5], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[6], &xmm[6], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[7], &xmm[7], sizeof(*xmm)));
-#if defined(__x86_64__)
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[8], &xmm[8], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[9], &xmm[9], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[10], &xmm[10], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[11], &xmm[11], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[12], &xmm[12], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[13], &xmm[13], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[14], &xmm[14], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&fpr.fxstate.fx_xmm[15], &xmm[15], sizeof(*xmm)));
+ __unreachable();
#endif
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
-__attribute__((target("sse")))
-static __inline void get_xmm_regs(void* v_xmm)
+static __inline void set_gp64_r8_regs(const union x86_test_register data[])
{
- const struct {
- uint64_t a, b;
- } fill __aligned(16) = {0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F};
-
- __asm__ __volatile__(
- /* fill registers with clobber pattern */
- "movaps %1, %%xmm0\n\t"
- "movaps %1, %%xmm1\n\t"
- "movaps %1, %%xmm2\n\t"
- "movaps %1, %%xmm3\n\t"
- "movaps %1, %%xmm4\n\t"
- "movaps %1, %%xmm5\n\t"
- "movaps %1, %%xmm6\n\t"
- "movaps %1, %%xmm7\n\t"
-#if defined(__x86_64__)
- "movaps %1, %%xmm8\n\t"
- "movaps %1, %%xmm9\n\t"
- "movaps %1, %%xmm10\n\t"
- "movaps %1, %%xmm11\n\t"
- "movaps %1, %%xmm12\n\t"
- "movaps %1, %%xmm13\n\t"
- "movaps %1, %%xmm14\n\t"
- "movaps %1, %%xmm15\n\t"
-#endif
- "\n\t"
- "int3\n\t"
- "\n\t"
- "movaps %%xmm0, 0x00(%0)\n\t"
- "movaps %%xmm1, 0x10(%0)\n\t"
- "movaps %%xmm2, 0x20(%0)\n\t"
- "movaps %%xmm3, 0x30(%0)\n\t"
- "movaps %%xmm4, 0x40(%0)\n\t"
- "movaps %%xmm5, 0x50(%0)\n\t"
- "movaps %%xmm6, 0x60(%0)\n\t"
- "movaps %%xmm7, 0x70(%0)\n\t"
-#if defined(__x86_64__)
- "movaps %%xmm8, 0x80(%0)\n\t"
- "movaps %%xmm9, 0x90(%0)\n\t"
- "movaps %%xmm10, 0xA0(%0)\n\t"
- "movaps %%xmm11, 0xB0(%0)\n\t"
- "movaps %%xmm12, 0xC0(%0)\n\t"
- "movaps %%xmm13, 0xD0(%0)\n\t"
- "movaps %%xmm14, 0xE0(%0)\n\t"
- "movaps %%xmm15, 0xF0(%0)\n\t"
-#endif
- :
- : "a"(v_xmm), "m"(fill)
- : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5",
"%xmm6", "%xmm7"
-#if defined(__x86_64__)
- , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
"%xmm14",
- "%xmm15"
-#endif
- );
-}
-
-ATF_TC(x86_regs_xmm_write);
-ATF_TC_HEAD(x86_regs_xmm_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set xmm0..xmm15 (..xmm7 on i386) reg values into a debugged "
- "program via PT_SETFPREGS (PT_SETXMMREGS on i386) and compare "
- "the result against expected.");
-}
-
-ATF_TC_BODY(x86_regs_xmm_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
#if defined(__x86_64__)
- struct fpreg fpr;
-#else
- struct xmmregs fpr;
-#endif
-
- const struct {
- uint64_t a, b;
- } xmm[] __aligned(16) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F, },
-#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817, },
-#endif
- };
-
- /* verify whether SSE is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_SSE))
- atf_tc_skip("SSE is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- struct {
- uint64_t a, b;
- } v_xmm[16] __aligned(16);
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- get_xmm_regs(v_xmm);
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT(!memcmp(&v_xmm[0], &xmm[0], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[1], &xmm[1], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[2], &xmm[2], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[3], &xmm[3], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[4], &xmm[4], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[5], &xmm[5], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[6], &xmm[6], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[7], &xmm[7], sizeof(*xmm)));
-#if defined(__x86_64__)
- FORKEE_ASSERT(!memcmp(&v_xmm[8], &xmm[8], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[9], &xmm[9], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[10], &xmm[10], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[11], &xmm[11], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[12], &xmm[12], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[13], &xmm[13], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[14], &xmm[14], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[15], &xmm[15], sizeof(*xmm)));
-#endif
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
-#if defined(__x86_64__)
- DPRINTF("Call GETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1);
-#else
- DPRINTF("Call GETXMMREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXMMREGS, child, &fpr, 0) != -1);
-#endif
-
- memcpy(&fpr.fxstate.fx_xmm[0], &xmm[0], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[1], &xmm[1], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[2], &xmm[2], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[3], &xmm[3], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[4], &xmm[4], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[5], &xmm[5], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[6], &xmm[6], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[7], &xmm[7], sizeof(*xmm));
-#if defined(__x86_64__)
- memcpy(&fpr.fxstate.fx_xmm[8], &xmm[8], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[9], &xmm[9], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[10], &xmm[10], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[11], &xmm[11], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[12], &xmm[12], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[13], &xmm[13], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[14], &xmm[14], sizeof(*xmm));
- memcpy(&fpr.fxstate.fx_xmm[15], &xmm[15], sizeof(*xmm));
-#endif
-
-#if defined(__x86_64__)
- DPRINTF("Call SETFPREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETFPREGS, child, &fpr, 0) != -1);
-#else
- DPRINTF("Call SETXMMREGS for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETXMMREGS, child, &fpr, 0) != -1);
-#endif
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_xstate_mm_read);
-ATF_TC_HEAD(x86_xstate_mm_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set MMX (mm0..mm7) reg values from debugged program and read "
- "them via PT_GETXSTATE, comparing values against expected.");
-}
-
-ATF_TC_BODY(x86_xstate_mm_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct iovec iov;
- struct xstate xst;
-
- const uint64_t mm[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- /* verify whether MMX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_MMX))
- atf_tc_skip("MMX is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- set_mm_regs(mm);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_X87);
- ATF_REQUIRE(xst.xs_xstate_bv & XCR0_X87);
-
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[0].r.f87_mantissa, mm[0]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[1].r.f87_mantissa, mm[1]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[2].r.f87_mantissa, mm[2]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[3].r.f87_mantissa, mm[3]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[4].r.f87_mantissa, mm[4]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[5].r.f87_mantissa, mm[5]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[6].r.f87_mantissa, mm[6]);
- ATF_CHECK_EQ(xst.xs_fxsave.fx_87_ac[7].r.f87_mantissa, mm[7]);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_xstate_mm_write);
-ATF_TC_HEAD(x86_xstate_mm_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set mm0..mm7 reg values into a debugged program via "
- "PT_SETXSTATE and compare the result against expected.");
-}
-
-ATF_TC_BODY(x86_xstate_mm_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct iovec iov;
- struct xstate xst;
-
- const uint64_t mm[] = {
- 0x0001020304050607,
- 0x1011121314151617,
- 0x2021222324252627,
- 0x3031323334353637,
- 0x4041424344454647,
- 0x5051525354555657,
- 0x6061626364656667,
- 0x7071727374757677,
- };
-
- /* verify whether MMX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_MMX))
- atf_tc_skip("MMX is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- uint64_t v_mm[8];
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- get_mm_regs(v_mm);
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT_EQ(v_mm[0], mm[0]);
- FORKEE_ASSERT_EQ(v_mm[1], mm[1]);
- FORKEE_ASSERT_EQ(v_mm[2], mm[2]);
- FORKEE_ASSERT_EQ(v_mm[3], mm[3]);
- FORKEE_ASSERT_EQ(v_mm[4], mm[4]);
- FORKEE_ASSERT_EQ(v_mm[5], mm[5]);
- FORKEE_ASSERT_EQ(v_mm[6], mm[6]);
- FORKEE_ASSERT_EQ(v_mm[7], mm[7]);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_X87);
-
- xst.xs_rfbm = XCR0_X87;
- xst.xs_xstate_bv = XCR0_X87;
-
- xst.xs_fxsave.fx_87_ac[0].r.f87_mantissa = mm[0];
- xst.xs_fxsave.fx_87_ac[1].r.f87_mantissa = mm[1];
- xst.xs_fxsave.fx_87_ac[2].r.f87_mantissa = mm[2];
- xst.xs_fxsave.fx_87_ac[3].r.f87_mantissa = mm[3];
- xst.xs_fxsave.fx_87_ac[4].r.f87_mantissa = mm[4];
- xst.xs_fxsave.fx_87_ac[5].r.f87_mantissa = mm[5];
- xst.xs_fxsave.fx_87_ac[6].r.f87_mantissa = mm[6];
- xst.xs_fxsave.fx_87_ac[7].r.f87_mantissa = mm[7];
-
- DPRINTF("Call SETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETXSTATE, child, &iov, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_xstate_xmm_read);
-ATF_TC_HEAD(x86_xstate_xmm_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set xmm0..xmm15 (..xmm7 on i386) reg values from debugged
program "
- "and read them via PT_GETXSTATE, comparing values against
expected.");
-}
-
-ATF_TC_BODY(x86_xstate_xmm_read, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct xstate xst;
- struct iovec iov;
-
- const struct {
- uint64_t a, b;
- } xmm[] __aligned(16) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F, },
-#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817, },
-#endif
- };
-
- /* verify whether SSE is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_SSE))
- atf_tc_skip("SSE is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- set_xmm_regs(xmm);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_SSE);
- ATF_REQUIRE(xst.xs_xstate_bv & XCR0_SSE);
-
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[0], &xmm[0], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[1], &xmm[1], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[2], &xmm[2], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[3], &xmm[3], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[4], &xmm[4], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[5], &xmm[5], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[6], &xmm[6], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[7], &xmm[7], sizeof(*xmm)));
-#if defined(__x86_64__)
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[8], &xmm[8], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[9], &xmm[9], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[10], &xmm[10], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[11], &xmm[11], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[12], &xmm[12], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[13], &xmm[13], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[14], &xmm[14], sizeof(*xmm)));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[15], &xmm[15], sizeof(*xmm)));
-#endif
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
-}
-
-ATF_TC(x86_xstate_xmm_write);
-ATF_TC_HEAD(x86_xstate_xmm_write, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set xmm0..xmm15 (..xmm7 on i386) reg values into a debugged "
- "program via PT_SETXSTATE and compare the result against
expected.");
-}
-
-ATF_TC_BODY(x86_xstate_xmm_write, tc)
-{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct xstate xst;
- struct iovec iov;
-
- const struct {
- uint64_t a, b;
- } xmm[] __aligned(16) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F, },
-#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817, },
-#endif
- };
-
- /* verify whether SSE is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: EDX = %08x\n", edx);
-
- if (!(edx & bit_SSE))
- atf_tc_skip("SSE is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- struct {
- uint64_t a, b;
- } v_xmm[16] __aligned(16);
-
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- get_xmm_regs(v_xmm);
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT(!memcmp(&v_xmm[0], &xmm[0], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[1], &xmm[1], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[2], &xmm[2], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[3], &xmm[3], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[4], &xmm[4], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[5], &xmm[5], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[6], &xmm[6], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[7], &xmm[7], sizeof(*xmm)));
-#if defined(__x86_64__)
- FORKEE_ASSERT(!memcmp(&v_xmm[8], &xmm[8], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[9], &xmm[9], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[10], &xmm[10], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[11], &xmm[11], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[12], &xmm[12], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[13], &xmm[13], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[14], &xmm[14], sizeof(*xmm)));
- FORKEE_ASSERT(!memcmp(&v_xmm[15], &xmm[15], sizeof(*xmm)));
-#endif
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_SSE);
-
- xst.xs_rfbm = XCR0_SSE;
- xst.xs_xstate_bv = XCR0_SSE;
-
- memcpy(&xst.xs_fxsave.fx_xmm[0], &xmm[0], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[1], &xmm[1], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[2], &xmm[2], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[3], &xmm[3], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[4], &xmm[4], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[5], &xmm[5], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[6], &xmm[6], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[7], &xmm[7], sizeof(*xmm));
-#if defined(__x86_64__)
- memcpy(&xst.xs_fxsave.fx_xmm[8], &xmm[8], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[9], &xmm[9], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[10], &xmm[10], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[11], &xmm[11], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[12], &xmm[12], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[13], &xmm[13], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[14], &xmm[14], sizeof(*xmm));
- memcpy(&xst.xs_fxsave.fx_xmm[15], &xmm[15], sizeof(*xmm));
+ __asm__ __volatile__(
+ "movq 0x00(%0), %%r8\n\t"
+ "movq 0x20(%0), %%r9\n\t"
+ "movq 0x40(%0), %%r10\n\t"
+ "movq 0x60(%0), %%r11\n\t"
+ "movq 0x80(%0), %%r12\n\t"
+ "movq 0xA0(%0), %%r13\n\t"
+ "movq 0xC0(%0), %%r14\n\t"
+ "movq 0xE0(%0), %%r15\n\t"
+ "int3\n\t"
+ :
+ : "b"(data)
+ : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
+ );
+#else
+ __unreachable();
#endif
+}
- DPRINTF("Call SETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETXSTATE, child, &iov, 0) != -1);
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
+__attribute__((target("mmx")))
+static __inline void get_mm_regs(union x86_test_register out[])
+{
+ const uint64_t fill = 0x0F0F0F0F0F0F0F0F;
- validate_status_exited(status, exitval);
+ __asm__ __volatile__(
+ /* fill registers with clobber pattern */
+ "movq %1, %%mm0\n\t"
+ "movq %1, %%mm1\n\t"
+ "movq %1, %%mm2\n\t"
+ "movq %1, %%mm3\n\t"
+ "movq %1, %%mm4\n\t"
+ "movq %1, %%mm5\n\t"
+ "movq %1, %%mm6\n\t"
+ "movq %1, %%mm7\n\t"
+ "\n\t"
+ "int3\n\t"
+ "\n\t"
+ "movq %%mm0, 0x00(%0)\n\t"
+ "movq %%mm1, 0x20(%0)\n\t"
+ "movq %%mm2, 0x40(%0)\n\t"
+ "movq %%mm3, 0x60(%0)\n\t"
+ "movq %%mm4, 0x80(%0)\n\t"
+ "movq %%mm5, 0xA0(%0)\n\t"
+ "movq %%mm6, 0xC0(%0)\n\t"
+ "movq %%mm7, 0xE0(%0)\n\t"
+ :
+ : "a"(out), "m"(fill)
+ : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
+ );
+}
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
+__attribute__((target("mmx")))
+static __inline void set_mm_regs(const union x86_test_register data[])
+{
+ __asm__ __volatile__(
+ "movq 0x00(%0), %%mm0\n\t"
+ "movq 0x20(%0), %%mm1\n\t"
+ "movq 0x40(%0), %%mm2\n\t"
+ "movq 0x60(%0), %%mm3\n\t"
+ "movq 0x80(%0), %%mm4\n\t"
+ "movq 0xA0(%0), %%mm5\n\t"
+ "movq 0xC0(%0), %%mm6\n\t"
+ "movq 0xE0(%0), %%mm7\n\t"
+ "int3\n\t"
+ :
+ : "b"(data)
+ : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
+ );
}
-__attribute__((target("avx")))
-static __inline void set_ymm_regs(const void* ymm)
+__attribute__((target("sse")))
+static __inline void get_xmm_regs(union x86_test_register out[])
{
+ union x86_test_register fill __aligned(32) = {
+ .xmm={ 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F }
+ };
+
__asm__ __volatile__(
- "vmovaps 0x000(%0), %%ymm0\n\t"
- "vmovaps 0x020(%0), %%ymm1\n\t"
- "vmovaps 0x040(%0), %%ymm2\n\t"
- "vmovaps 0x060(%0), %%ymm3\n\t"
- "vmovaps 0x080(%0), %%ymm4\n\t"
- "vmovaps 0x0A0(%0), %%ymm5\n\t"
- "vmovaps 0x0C0(%0), %%ymm6\n\t"
- "vmovaps 0x0E0(%0), %%ymm7\n\t"
+ /* fill registers with clobber pattern */
+ "movaps %1, %%xmm0\n\t"
+ "movaps %1, %%xmm1\n\t"
+ "movaps %1, %%xmm2\n\t"
+ "movaps %1, %%xmm3\n\t"
+ "movaps %1, %%xmm4\n\t"
+ "movaps %1, %%xmm5\n\t"
+ "movaps %1, %%xmm6\n\t"
+ "movaps %1, %%xmm7\n\t"
#if defined(__x86_64__)
- "vmovaps 0x100(%0), %%ymm8\n\t"
- "vmovaps 0x120(%0), %%ymm9\n\t"
- "vmovaps 0x140(%0), %%ymm10\n\t"
- "vmovaps 0x160(%0), %%ymm11\n\t"
- "vmovaps 0x180(%0), %%ymm12\n\t"
- "vmovaps 0x1A0(%0), %%ymm13\n\t"
- "vmovaps 0x1C0(%0), %%ymm14\n\t"
- "vmovaps 0x1E0(%0), %%ymm15\n\t"
+ "movaps %1, %%xmm8\n\t"
+ "movaps %1, %%xmm9\n\t"
+ "movaps %1, %%xmm10\n\t"
+ "movaps %1, %%xmm11\n\t"
+ "movaps %1, %%xmm12\n\t"
+ "movaps %1, %%xmm13\n\t"
+ "movaps %1, %%xmm14\n\t"
+ "movaps %1, %%xmm15\n\t"
#endif
+ "\n\t"
"int3\n\t"
+ "\n\t"
+ "movaps %%xmm0, 0x000(%0)\n\t"
+ "movaps %%xmm1, 0x020(%0)\n\t"
+ "movaps %%xmm2, 0x040(%0)\n\t"
+ "movaps %%xmm3, 0x060(%0)\n\t"
+ "movaps %%xmm4, 0x080(%0)\n\t"
+ "movaps %%xmm5, 0x0A0(%0)\n\t"
+ "movaps %%xmm6, 0x0C0(%0)\n\t"
+ "movaps %%xmm7, 0x0E0(%0)\n\t"
+#if defined(__x86_64__)
+ "movaps %%xmm8, 0x100(%0)\n\t"
+ "movaps %%xmm9, 0x120(%0)\n\t"
+ "movaps %%xmm10, 0x140(%0)\n\t"
+ "movaps %%xmm11, 0x160(%0)\n\t"
+ "movaps %%xmm12, 0x180(%0)\n\t"
+ "movaps %%xmm13, 0x1A0(%0)\n\t"
+ "movaps %%xmm14, 0x1C0(%0)\n\t"
+ "movaps %%xmm15, 0x1E0(%0)\n\t"
+#endif
:
- : "b"(ymm)
- : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6",
- "%ymm7"
+ : "a"(out), "m"(fill)
+ : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5",
"%xmm6", "%xmm7"
#if defined(__x86_64__)
- , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13",
- "%ymm14", "%ymm15"
+ , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
"%xmm14",
+ "%xmm15"
#endif
);
}
-ATF_TC(x86_xstate_ymm_read);
-ATF_TC_HEAD(x86_xstate_ymm_read, tc)
-{
- atf_tc_set_md_var(tc, "descr",
- "Set ymm0..ymm15 (..ymm7 on i386) reg values from debugged
program "
- "and read them via PT_GETXSTATE, comparing values against
expected.");
-}
-
-ATF_TC_BODY(x86_xstate_ymm_read, tc)
+__attribute__((target("sse")))
+static __inline void set_xmm_regs(const union x86_test_register data[])
{
- const int exitval = 5;
- pid_t child, wpid;
-#if defined(TWAIT_HAVE_STATUS)
- const int sigval = SIGTRAP;
- int status;
-#endif
- struct xstate xst;
- struct iovec iov;
-
- const struct {
- uint64_t a, b, c, d;
- } ymm[] __aligned(32) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908,
- 0x1716151413121110, 0x1F1E1D1C1B1A1918, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09,
- 0x1817161514131211, 0x201F1E1D1C1B1A19, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A,
- 0x1918171615141312, 0x21201F1E1D1C1B1A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B,
- 0x1A19181716151413, 0x2221201F1E1D1C1B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C,
- 0x1B1A191817161514, 0x232221201F1E1D1C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D,
- 0x1C1B1A1918171615, 0x24232221201F1E1D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E,
- 0x1D1C1B1A19181716, 0x2524232221201F1E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F,
- 0x1E1D1C1B1A191817, 0x262524232221201F, },
+ __asm__ __volatile__(
+ "movaps 0x000(%0), %%xmm0\n\t"
+ "movaps 0x020(%0), %%xmm1\n\t"
+ "movaps 0x040(%0), %%xmm2\n\t"
+ "movaps 0x060(%0), %%xmm3\n\t"
+ "movaps 0x080(%0), %%xmm4\n\t"
+ "movaps 0x0A0(%0), %%xmm5\n\t"
+ "movaps 0x0C0(%0), %%xmm6\n\t"
+ "movaps 0x0E0(%0), %%xmm7\n\t"
#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110,
- 0x1F1E1D1C1B1A1918, 0x2726252423222120, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211,
- 0x201F1E1D1C1B1A19, 0x2827262524232221, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312,
- 0x21201F1E1D1C1B1A, 0x2928272625242322, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413,
- 0x2221201F1E1D1C1B, 0x2A29282726252423, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514,
- 0x232221201F1E1D1C, 0x2B2A292827262524, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615,
- 0x24232221201F1E1D, 0x2C2B2A2928272625, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716,
- 0x2524232221201F1E, 0x2D2C2B2A29282726, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817,
- 0x262524232221201F, 0x2E2D2C2B2A292827, },
+ "movaps 0x100(%0), %%xmm8\n\t"
+ "movaps 0x120(%0), %%xmm9\n\t"
+ "movaps 0x140(%0), %%xmm10\n\t"
+ "movaps 0x160(%0), %%xmm11\n\t"
+ "movaps 0x180(%0), %%xmm12\n\t"
+ "movaps 0x1A0(%0), %%xmm13\n\t"
+ "movaps 0x1C0(%0), %%xmm14\n\t"
+ "movaps 0x1E0(%0), %%xmm15\n\t"
#endif
- };
-
- /* verify whether AVX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
- unsigned int eax, ebx, ecx, edx;
- if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
- atf_tc_skip("CPUID is not supported by the CPU");
-
- DPRINTF("cpuid: ECX = %08x\n", ecx);
-
- if (!(ecx & bit_AVX))
- atf_tc_skip("AVX is not supported by the CPU");
- }
-
- DPRINTF("Before forking process PID=%d\n", getpid());
- SYSCALL_REQUIRE((child = fork()) != -1);
- if (child == 0) {
- DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
- FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
-
- DPRINTF("Before running assembly from child\n");
- set_ymm_regs(ymm);
-
- DPRINTF("Before exiting of the child process\n");
- _exit(exitval);
- }
- DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_stopped(status, sigval);
-
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_SSE);
- ATF_REQUIRE(xst.xs_rfbm & XCR0_YMM_Hi128);
- ATF_REQUIRE(xst.xs_xstate_bv & XCR0_SSE);
- ATF_REQUIRE(xst.xs_xstate_bv & XCR0_YMM_Hi128);
-
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[0], &ymm[0].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[0], &ymm[0].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[1], &ymm[1].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[1], &ymm[1].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[2], &ymm[2].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[2], &ymm[2].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[3], &ymm[3].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[3], &ymm[3].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[4], &ymm[4].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[4], &ymm[4].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[5], &ymm[5].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[5], &ymm[5].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[6], &ymm[6].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[6], &ymm[6].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[7], &ymm[7].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[7], &ymm[7].c,
sizeof(*ymm)/2));
+ "int3\n\t"
+ :
+ : "b"(data)
+ : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6",
+ "%xmm7"
#if defined(__x86_64__)
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[8], &ymm[8].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[8], &ymm[8].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[9], &ymm[9].a, sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[9], &ymm[9].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[10], &ymm[10].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[10], &ymm[10].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[11], &ymm[11].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[11], &ymm[11].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[12], &ymm[12].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[12], &ymm[12].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[13], &ymm[13].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[13], &ymm[13].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[14], &ymm[14].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[14], &ymm[14].c,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_fxsave.fx_xmm[15], &ymm[15].a,
sizeof(*ymm)/2));
- ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[15], &ymm[15].c,
sizeof(*ymm)/2));
+ , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
+ "%xmm14", "%xmm15"
#endif
-
- DPRINTF("Before resuming the child process where it left off and "
- "without signal to be sent\n");
- SYSCALL_REQUIRE(ptrace(PT_CONTINUE, child, (void *)1, 0) != -1);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
-
- validate_status_exited(status, exitval);
-
- DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
- TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
+ );
}
__attribute__((target("avx")))
-static __inline void get_ymm_regs(void* v_ymm)
+static __inline void get_ymm_regs(union x86_test_register out[])
{
- const struct {
- uint64_t a, b, c, d;
- } fill __aligned(32) = {
- 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
- 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F
+ union x86_test_register fill __aligned(32) = {
+ { 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
+ 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F }
};
__asm__ __volatile__(
@@ -3500,7 +2627,7 @@ static __inline void get_ymm_regs(void* v_ymm)
"vmovaps %%ymm15, 0x1E0(%0)\n\t"
#endif
:
- : "a"(v_ymm), "m"(fill)
+ : "a"(out), "m"(fill)
: "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5",
"%ymm6", "%ymm7"
#if defined(__x86_64__)
, "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13",
"%ymm14",
@@ -3509,109 +2636,328 @@ static __inline void get_ymm_regs(void* v_ymm)
);
}
-ATF_TC(x86_xstate_ymm_write);
-ATF_TC_HEAD(x86_xstate_ymm_write, tc)
+__attribute__((target("avx")))
+static __inline void set_ymm_regs(const union x86_test_register data[])
{
- atf_tc_set_md_var(tc, "descr",
- "Set ymm0..ymm15 (..ymm7 on i386) reg values into a debugged "
- "program via PT_SETXSTATE and compare the result against
expected.");
+ __asm__ __volatile__(
+ "vmovaps 0x000(%0), %%ymm0\n\t"
+ "vmovaps 0x020(%0), %%ymm1\n\t"
+ "vmovaps 0x040(%0), %%ymm2\n\t"
+ "vmovaps 0x060(%0), %%ymm3\n\t"
+ "vmovaps 0x080(%0), %%ymm4\n\t"
+ "vmovaps 0x0A0(%0), %%ymm5\n\t"
+ "vmovaps 0x0C0(%0), %%ymm6\n\t"
+ "vmovaps 0x0E0(%0), %%ymm7\n\t"
+#if defined(__x86_64__)
+ "vmovaps 0x100(%0), %%ymm8\n\t"
+ "vmovaps 0x120(%0), %%ymm9\n\t"
+ "vmovaps 0x140(%0), %%ymm10\n\t"
+ "vmovaps 0x160(%0), %%ymm11\n\t"
+ "vmovaps 0x180(%0), %%ymm12\n\t"
+ "vmovaps 0x1A0(%0), %%ymm13\n\t"
+ "vmovaps 0x1C0(%0), %%ymm14\n\t"
+ "vmovaps 0x1E0(%0), %%ymm15\n\t"
+#endif
+ "int3\n\t"
+ :
+ : "b"(data)
+ : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6",
+ "%ymm7"
+#if defined(__x86_64__)
+ , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13",
+ "%ymm14", "%ymm15"
+#endif
+ );
}
-ATF_TC_BODY(x86_xstate_ymm_write, tc)
+static void
+x86_register_test(enum x86_test_regset regset, enum x86_test_registers regs,
+ enum x86_test_regmode regmode)
{
const int exitval = 5;
pid_t child, wpid;
#if defined(TWAIT_HAVE_STATUS)
const int sigval = SIGTRAP;
int status;
+#endif
+ struct reg gpr;
+ struct fpreg fpr;
+#if defined(__i386__)
+ struct xmmregs xmm;
#endif
struct xstate xst;
struct iovec iov;
+ struct fxsave* fxs;
+ uint64_t xst_flags = 0;
+
+ const union x86_test_register expected[] __aligned(32) = {
+ {{ 0x0706050403020100, 0x0F0E0D0C0B0A0908,
+ 0x1716151413121110, 0x1F1E1D1C1B1A1918, }},
+ {{ 0x0807060504030201, 0x100F0E0D0C0B0A09,
+ 0x1817161514131211, 0x201F1E1D1C1B1A19, }},
+ {{ 0x0908070605040302, 0x11100F0E0D0C0B0A,
+ 0x1918171615141312, 0x21201F1E1D1C1B1A, }},
+ {{ 0x0A09080706050403, 0x1211100F0E0D0C0B,
+ 0x1A19181716151413, 0x2221201F1E1D1C1B, }},
+ {{ 0x0B0A090807060504, 0x131211100F0E0D0C,
+ 0x1B1A191817161514, 0x232221201F1E1D1C, }},
+ {{ 0x0C0B0A0908070605, 0x14131211100F0E0D,
+ 0x1C1B1A1918171615, 0x24232221201F1E1D, }},
+ {{ 0x0D0C0B0A09080706, 0x1514131211100F0E,
+ 0x1D1C1B1A19181716, 0x2524232221201F1E, }},
+ {{ 0x0E0D0C0B0A090807, 0x161514131211100F,
+ 0x1E1D1C1B1A191817, 0x262524232221201F, }},
+ {{ 0x0F0E0D0C0B0A0908, 0x1716151413121110,
+ 0x1F1E1D1C1B1A1918, 0x2726252423222120, }},
+ {{ 0x100F0E0D0C0B0A09, 0x1817161514131211,
+ 0x201F1E1D1C1B1A19, 0x2827262524232221, }},
+ {{ 0x11100F0E0D0C0B0A, 0x1918171615141312,
+ 0x21201F1E1D1C1B1A, 0x2928272625242322, }},
+ {{ 0x1211100F0E0D0C0B, 0x1A19181716151413,
+ 0x2221201F1E1D1C1B, 0x2A29282726252423, }},
+ {{ 0x131211100F0E0D0C, 0x1B1A191817161514,
+ 0x232221201F1E1D1C, 0x2B2A292827262524, }},
+ {{ 0x14131211100F0E0D, 0x1C1B1A1918171615,
+ 0x24232221201F1E1D, 0x2C2B2A2928272625, }},
+ {{ 0x1514131211100F0E, 0x1D1C1B1A19181716,
+ 0x2524232221201F1E, 0x2D2C2B2A29282726, }},
+ {{ 0x161514131211100F, 0x1E1D1C1B1A191817,
+ 0x262524232221201F, 0x2E2D2C2B2A292827, }},
+ };
- const struct {
- uint64_t a, b, c, d;
- } ymm[] __aligned(32) = {
- { 0x0706050403020100, 0x0F0E0D0C0B0A0908,
- 0x1716151413121110, 0x1F1E1D1C1B1A1918, },
- { 0x0807060504030201, 0x100F0E0D0C0B0A09,
- 0x1817161514131211, 0x201F1E1D1C1B1A19, },
- { 0x0908070605040302, 0x11100F0E0D0C0B0A,
- 0x1918171615141312, 0x21201F1E1D1C1B1A, },
- { 0x0A09080706050403, 0x1211100F0E0D0C0B,
- 0x1A19181716151413, 0x2221201F1E1D1C1B, },
- { 0x0B0A090807060504, 0x131211100F0E0D0C,
- 0x1B1A191817161514, 0x232221201F1E1D1C, },
- { 0x0C0B0A0908070605, 0x14131211100F0E0D,
- 0x1C1B1A1918171615, 0x24232221201F1E1D, },
- { 0x0D0C0B0A09080706, 0x1514131211100F0E,
- 0x1D1C1B1A19181716, 0x2524232221201F1E, },
- { 0x0E0D0C0B0A090807, 0x161514131211100F,
- 0x1E1D1C1B1A191817, 0x262524232221201F, },
+ bool need_32 = false, need_64 = false, need_cpuid = false;
+
+ switch (regs) {
+ case GPREGS_32:
+ case GPREGS_32_EBP_ESP:
+ need_32 = true;
+ break;
+ case GPREGS_64:
+ case GPREGS_64_R8:
+ need_64 = true;
+ break;
+ case FPREGS_MM:
+ case FPREGS_XMM:
+ case FPREGS_YMM:
+ need_cpuid = true;
+ break;
+ }
+
+ if (need_32) {
#if defined(__x86_64__)
- { 0x0F0E0D0C0B0A0908, 0x1716151413121110,
- 0x1F1E1D1C1B1A1918, 0x2726252423222120, },
- { 0x100F0E0D0C0B0A09, 0x1817161514131211,
- 0x201F1E1D1C1B1A19, 0x2827262524232221, },
- { 0x11100F0E0D0C0B0A, 0x1918171615141312,
- 0x21201F1E1D1C1B1A, 0x2928272625242322, },
- { 0x1211100F0E0D0C0B, 0x1A19181716151413,
- 0x2221201F1E1D1C1B, 0x2A29282726252423, },
- { 0x131211100F0E0D0C, 0x1B1A191817161514,
- 0x232221201F1E1D1C, 0x2B2A292827262524, },
- { 0x14131211100F0E0D, 0x1C1B1A1918171615,
- 0x24232221201F1E1D, 0x2C2B2A2928272625, },
- { 0x1514131211100F0E, 0x1D1C1B1A19181716,
- 0x2524232221201F1E, 0x2D2C2B2A29282726, },
- { 0x161514131211100F, 0x1E1D1C1B1A191817,
- 0x262524232221201F, 0x2E2D2C2B2A292827, },
+ atf_tc_skip("Test requires 32-bit mode");
#endif
- };
+ }
+ if (need_64) {
+#if defined(__i386__)
+ atf_tc_skip("Test requires 64-bit mode");
+#endif
+ }
- /* verify whether AVX is supported here */
- DPRINTF("Before invoking cpuid\n");
- {
+ if (need_cpuid) {
+ /* verify whether needed instruction sets are supported here */
unsigned int eax, ebx, ecx, edx;
+
+ DPRINTF("Before invoking cpuid\n");
if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
atf_tc_skip("CPUID is not supported by the CPU");
- DPRINTF("cpuid: ECX = %08x\n", ecx);
-
- if (!(ecx & bit_AVX))
- atf_tc_skip("AVX is not supported by the CPU");
+ DPRINTF("cpuid: ECX = %08x, EDX = %08xd\n", ecx, edx);
+
+ switch (regs) {
+ case FPREGS_YMM:
+ if (!(ecx & bit_AVX))
+ atf_tc_skip("AVX is not supported by the CPU");
+ /*FALLTHROUGH*/
+ case FPREGS_XMM:
+ if (!(edx & bit_SSE))
+ atf_tc_skip("SSE is not supported by the CPU");
+ break;
+ case FPREGS_MM:
+ if (!(edx & bit_MMX))
+ atf_tc_skip("MMX is not supported by the CPU");
+ break;
+ case GPREGS_32:
+ case GPREGS_32_EBP_ESP:
+ case GPREGS_64:
+ case GPREGS_64_R8:
+ __unreachable();
+ }
}
DPRINTF("Before forking process PID=%d\n", getpid());
SYSCALL_REQUIRE((child = fork()) != -1);
if (child == 0) {
- struct {
- uint64_t a, b, c, d;
- } v_ymm[16] __aligned(32);
+ union x86_test_register vals[16] __aligned(32);
DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
DPRINTF("Before running assembly from child\n");
- get_ymm_regs(v_ymm);
-
- DPRINTF("Before comparing results\n");
- FORKEE_ASSERT(!memcmp(&v_ymm[0], &ymm[0], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[1], &ymm[1], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[2], &ymm[2], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[3], &ymm[3], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[4], &ymm[4], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[5], &ymm[5], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[6], &ymm[6], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[7], &ymm[7], sizeof(*ymm)));
+ switch (regmode) {
+ case TEST_GETREGS:
+ switch (regs) {
+ case GPREGS_32:
+ set_gp32_regs(expected);
+ break;
+ case GPREGS_32_EBP_ESP:
+ set_gp32_ebp_esp_regs(expected);
+ break;
+ case GPREGS_64:
+ set_gp64_regs(expected);
+ break;
+ case GPREGS_64_R8:
+ set_gp64_r8_regs(expected);
+ break;
+ case FPREGS_MM:
+ set_mm_regs(expected);
+ break;
+ case FPREGS_XMM:
+ set_xmm_regs(expected);
+ break;
+ case FPREGS_YMM:
+ set_ymm_regs(expected);
+ break;
+ }
+ break;
+ case TEST_SETREGS:
+ switch (regs) {
+ case GPREGS_32:
+ get_gp32_regs(vals);
+ break;
+ case GPREGS_32_EBP_ESP:
+ get_gp32_ebp_esp_regs(vals);
+ break;
+ case GPREGS_64:
+ get_gp64_regs(vals);
+ break;
+ case GPREGS_64_R8:
+ get_gp64_r8_regs(vals);
+ break;
+ case FPREGS_MM:
+ get_mm_regs(vals);
+ break;
+ case FPREGS_XMM:
+ get_xmm_regs(vals);
+ break;
+ case FPREGS_YMM:
+ get_ymm_regs(vals);
+ break;
+ }
+
+ DPRINTF("Before comparing results\n");
+ switch (regs) {
+ case GPREGS_32:
+ FORKEE_ASSERT(!memcmp(&vals[5].u32,
+ &expected[5].u32, sizeof(vals->u32)));
+ FORKEE_ASSERT(!memcmp(&vals[4].u32,
+ &expected[4].u32, sizeof(vals->u32)));
+ FORKEE_ASSERT(!memcmp(&vals[3].u32,
+ &expected[3].u32, sizeof(vals->u32)));
+ FORKEE_ASSERT(!memcmp(&vals[2].u32,
+ &expected[2].u32, sizeof(vals->u32)));
+ /*FALLTHROUGH*/
+ case GPREGS_32_EBP_ESP:
+ FORKEE_ASSERT(!memcmp(&vals[1].u32,
+ &expected[1].u32, sizeof(vals->u32)));
+ FORKEE_ASSERT(!memcmp(&vals[0].u32,
+ &expected[0].u32, sizeof(vals->u32)));
+ break;
+ case GPREGS_64:
+ case GPREGS_64_R8:
+ case FPREGS_MM:
+ FORKEE_ASSERT(!memcmp(&vals[0].u64,
+ &expected[0].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[1].u64,
+ &expected[1].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[2].u64,
+ &expected[2].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[3].u64,
+ &expected[3].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[4].u64,
+ &expected[4].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[5].u64,
+ &expected[5].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[6].u64,
+ &expected[6].u64, sizeof(vals->u64)));
+ FORKEE_ASSERT(!memcmp(&vals[7].u64,
+ &expected[7].u64, sizeof(vals->u64)));
+ break;
+ case FPREGS_XMM:
+ FORKEE_ASSERT(!memcmp(&vals[0].xmm,
+ &expected[0].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[1].xmm,
+ &expected[1].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[2].xmm,
+ &expected[2].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[3].xmm,
+ &expected[3].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[4].xmm,
+ &expected[4].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[5].xmm,
+ &expected[5].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[6].xmm,
+ &expected[6].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[7].xmm,
+ &expected[7].xmm, sizeof(vals->xmm)));
+#if defined(__x86_64__)
+ FORKEE_ASSERT(!memcmp(&vals[8].xmm,
+ &expected[8].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[9].xmm,
+ &expected[9].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[10].xmm,
+ &expected[10].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[11].xmm,
+ &expected[11].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[12].xmm,
+ &expected[12].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[13].xmm,
+ &expected[13].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[14].xmm,
+ &expected[14].xmm, sizeof(vals->xmm)));
+ FORKEE_ASSERT(!memcmp(&vals[15].xmm,
+ &expected[15].xmm, sizeof(vals->xmm)));
+#endif
+ break;
+ case FPREGS_YMM:
+ FORKEE_ASSERT(!memcmp(&vals[0].ymm,
+ &expected[0].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[1].ymm,
+ &expected[1].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[2].ymm,
+ &expected[2].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[3].ymm,
+ &expected[3].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[4].ymm,
+ &expected[4].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[5].ymm,
+ &expected[5].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[6].ymm,
+ &expected[6].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[7].ymm,
+ &expected[7].ymm, sizeof(vals->ymm)));
#if defined(__x86_64__)
- FORKEE_ASSERT(!memcmp(&v_ymm[8], &ymm[8], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[9], &ymm[9], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[10], &ymm[10], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[11], &ymm[11], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[12], &ymm[12], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[13], &ymm[13], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[14], &ymm[14], sizeof(*ymm)));
- FORKEE_ASSERT(!memcmp(&v_ymm[15], &ymm[15], sizeof(*ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[8].ymm,
+ &expected[8].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[9].ymm,
+ &expected[9].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[10].ymm,
+ &expected[10].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[11].ymm,
+ &expected[11].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[12].ymm,
+ &expected[12].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[13].ymm,
+ &expected[13].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[14].ymm,
+ &expected[14].ymm, sizeof(vals->ymm)));
+ FORKEE_ASSERT(!memcmp(&vals[15].ymm,
+ &expected[15].ymm, sizeof(vals->ymm)));
#endif
+ break;
+ }
+ break;
+ }
DPRINTF("Before exiting of the child process\n");
_exit(exitval);
@@ -3623,55 +2969,417 @@ ATF_TC_BODY(x86_xstate_ymm_write, tc)
validate_status_stopped(status, sigval);
- iov.iov_base = &xst;
- iov.iov_len = sizeof(xst);
-
- DPRINTF("Call GETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
-
- ATF_REQUIRE(xst.xs_rfbm & XCR0_SSE);
- ATF_REQUIRE(xst.xs_rfbm & XCR0_YMM_Hi128);
-
- xst.xs_rfbm = XCR0_SSE | XCR0_YMM_Hi128;
- xst.xs_xstate_bv = XCR0_SSE | XCR0_YMM_Hi128;
-
- memcpy(&xst.xs_fxsave.fx_xmm[0], &ymm[0].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[0], &ymm[0].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[1], &ymm[1].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[1], &ymm[1].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[2], &ymm[2].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[2], &ymm[2].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[3], &ymm[3].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[3], &ymm[3].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[4], &ymm[4].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[4], &ymm[4].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[5], &ymm[5].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[5], &ymm[5].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[6], &ymm[6].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[6], &ymm[6].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[7], &ymm[7].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[7], &ymm[7].c, sizeof(*ymm)/2);
+ switch (regset) {
+ case TEST_GPREGS:
+ ATF_REQUIRE(regs < FPREGS_MM);
+ DPRINTF("Call GETREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_GETREGS, child, &gpr, 0) != -1);
+ break;
+ case TEST_XMMREGS:
+#if defined(__i386__)
+ ATF_REQUIRE(regs >= FPREGS_MM && regs < FPREGS_YMM);
+ DPRINTF("Call GETXMMREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_GETXMMREGS, child, &xmm, 0) != -1);
+ fxs = &xmm.fxstate;
+ break;
+#else
+ /*FALLTHROUGH*/
+#endif
+ case TEST_FPREGS:
+#if defined(__x86_64__)
+ ATF_REQUIRE(regs >= FPREGS_MM && regs < FPREGS_YMM);
+ fxs = &fpr.fxstate;
+#else
+ ATF_REQUIRE(regs >= FPREGS_MM && regs < FPREGS_XMM);
+#endif
+ DPRINTF("Call GETFPREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_GETFPREGS, child, &fpr, 0) != -1);
+ break;
+ case TEST_XSTATE:
+ ATF_REQUIRE(regs >= FPREGS_MM);
+ iov.iov_base = &xst;
+ iov.iov_len = sizeof(xst);
+
+ DPRINTF("Call GETXSTATE for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_GETXSTATE, child, &iov, 0) != -1);
+
+ switch (regs) {
+ case FPREGS_MM:
+ xst_flags |= XCR0_X87;
+ break;
+ case FPREGS_YMM:
+ xst_flags |= XCR0_YMM_Hi128;
+ /*FALLTHROUGH*/
+ case FPREGS_XMM:
+ xst_flags |= XCR0_SSE;
+ break;
+ case GPREGS_32:
+ case GPREGS_32_EBP_ESP:
+ case GPREGS_64:
+ case GPREGS_64_R8:
+ __unreachable();
+ break;
+ }
+
+ ATF_REQUIRE((xst.xs_rfbm & xst_flags) == xst_flags);
+ switch (regmode) {
+ case TEST_SETREGS:
+ xst.xs_rfbm = xst_flags;
+ xst.xs_xstate_bv = xst_flags;
+ break;
+ case TEST_GETREGS:
+ ATF_REQUIRE((xst.xs_xstate_bv & xst_flags)
+ == xst_flags);
+ break;
+ }
+
+ fxs = &xst.xs_fxsave;
+ break;
+ }
+
+#if defined(__x86_64__)
+#define MM_REG(n) fpr.fxstate.fx_87_ac[n].r.f87_mantissa
+#else
+#define MM_REG(n) fpr.fstate.s87_ac[n].f87_mantissa
+#endif
+
+ switch (regmode) {
+ case TEST_GETREGS:
+ switch (regs) {
+ case GPREGS_32:
+#if defined(__i386__)
+ ATF_CHECK_EQ((uint32_t)gpr.r_eax, expected[0].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_ebx, expected[1].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_ecx, expected[2].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_edx, expected[3].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_esi, expected[4].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_edi, expected[5].u32);
+#endif
+ break;
+ case GPREGS_32_EBP_ESP:
+#if defined(__i386__)
+ ATF_CHECK_EQ((uint32_t)gpr.r_esp, expected[0].u32);
+ ATF_CHECK_EQ((uint32_t)gpr.r_ebp, expected[1].u32);
+#endif
+ break;
+ case GPREGS_64:
+#if defined(__x86_64__)
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RAX],
+ expected[0].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RBX],
+ expected[1].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RCX],
+ expected[2].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RDX],
+ expected[3].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RSI],
+ expected[4].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RDI],
+ expected[5].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RSP],
+ expected[6].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_RBP],
+ expected[7].u64);
+#endif
+ break;
+ case GPREGS_64_R8:
+#if defined(__x86_64__)
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R8],
+ expected[0].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R9],
+ expected[1].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R10],
+ expected[2].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R11],
+ expected[3].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R12],
+ expected[4].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R13],
+ expected[5].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R14],
+ expected[6].u64);
+ ATF_CHECK_EQ((uint64_t)gpr.regs[_REG_R15],
+ expected[7].u64);
+#endif
+ break;
+ case FPREGS_MM:
+ if (regset == TEST_FPREGS) {
+ ATF_CHECK_EQ(MM_REG(0), expected[0].u64);
+ ATF_CHECK_EQ(MM_REG(1), expected[1].u64);
+ ATF_CHECK_EQ(MM_REG(2), expected[2].u64);
+ ATF_CHECK_EQ(MM_REG(3), expected[3].u64);
+ ATF_CHECK_EQ(MM_REG(4), expected[4].u64);
+ ATF_CHECK_EQ(MM_REG(5), expected[5].u64);
+ ATF_CHECK_EQ(MM_REG(6), expected[6].u64);
+ ATF_CHECK_EQ(MM_REG(7), expected[7].u64);
+ } else {
+ ATF_CHECK_EQ(fxs->fx_87_ac[0].r.f87_mantissa,
+ expected[0].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[1].r.f87_mantissa,
+ expected[1].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[2].r.f87_mantissa,
+ expected[2].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[3].r.f87_mantissa,
+ expected[3].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[4].r.f87_mantissa,
+ expected[4].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[5].r.f87_mantissa,
+ expected[5].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[6].r.f87_mantissa,
+ expected[6].u64);
+ ATF_CHECK_EQ(fxs->fx_87_ac[7].r.f87_mantissa,
+ expected[7].u64);
+ }
+ break;
+ case FPREGS_YMM:
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[0],
+ &expected[0].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[1],
+ &expected[1].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[2],
+ &expected[2].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[3],
+ &expected[3].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[4],
+ &expected[4].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[5],
+ &expected[5].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[6],
+ &expected[6].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[7],
+ &expected[7].ymm.c, sizeof(expected->ymm)/2));
+#if defined(__x86_64__)
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[8],
+ &expected[8].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[9],
+ &expected[9].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[10],
+ &expected[10].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[11],
+ &expected[11].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[12],
+ &expected[12].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[13],
+ &expected[13].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[14],
+ &expected[14].ymm.c, sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[15],
+ &expected[15].ymm.c, sizeof(expected->ymm)/2));
+#endif
+ /*FALLTHROUGH*/
+ case FPREGS_XMM:
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[0], &expected[0].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[1], &expected[1].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[2], &expected[2].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[3], &expected[3].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[4], &expected[4].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[5], &expected[5].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[6], &expected[6].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[7], &expected[7].ymm.a,
+ sizeof(expected->ymm)/2));
+#if defined(__x86_64__)
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[8], &expected[8].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[9], &expected[9].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[10], &expected[10].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[11], &expected[11].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[12], &expected[12].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[13], &expected[13].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[14], &expected[14].ymm.a,
+ sizeof(expected->ymm)/2));
+ ATF_CHECK(!memcmp(&fxs->fx_xmm[15], &expected[15].ymm.a,
+ sizeof(expected->ymm)/2));
+#endif
+ break;
+ }
+ break;
+ case TEST_SETREGS:
+ switch (regs) {
+ case GPREGS_32:
+#if defined(__i386__)
+ gpr.r_eax = expected[0].u32;
+ gpr.r_ebx = expected[1].u32;
+ gpr.r_ecx = expected[2].u32;
+ gpr.r_edx = expected[3].u32;
+ gpr.r_esi = expected[4].u32;
+ gpr.r_edi = expected[5].u32;
+#endif
+ break;
+ case GPREGS_32_EBP_ESP:
+#if defined(__i386__)
+ gpr.r_esp = expected[0].u32;
+ gpr.r_ebp = expected[1].u32;
+#endif
+ break;
+ case GPREGS_64:
+#if defined(__x86_64__)
+ gpr.regs[_REG_RAX] = expected[0].u64;
+ gpr.regs[_REG_RBX] = expected[1].u64;
+ gpr.regs[_REG_RCX] = expected[2].u64;
+ gpr.regs[_REG_RDX] = expected[3].u64;
+ gpr.regs[_REG_RSI] = expected[4].u64;
+ gpr.regs[_REG_RDI] = expected[5].u64;
+ gpr.regs[_REG_RSP] = expected[6].u64;
+ gpr.regs[_REG_RBP] = expected[7].u64;
+#endif
+ break;
+ case GPREGS_64_R8:
+#if defined(__x86_64__)
+ gpr.regs[_REG_R8] = expected[0].u64;
+ gpr.regs[_REG_R9] = expected[1].u64;
+ gpr.regs[_REG_R10] = expected[2].u64;
+ gpr.regs[_REG_R11] = expected[3].u64;
+ gpr.regs[_REG_R12] = expected[4].u64;
+ gpr.regs[_REG_R13] = expected[5].u64;
+ gpr.regs[_REG_R14] = expected[6].u64;
+ gpr.regs[_REG_R15] = expected[7].u64;
+#endif
+ break;
+ case FPREGS_MM:
+ if (regset == TEST_FPREGS) {
+ MM_REG(0) = expected[0].u64;
+ MM_REG(1) = expected[1].u64;
+ MM_REG(2) = expected[2].u64;
+ MM_REG(3) = expected[3].u64;
+ MM_REG(4) = expected[4].u64;
+ MM_REG(5) = expected[5].u64;
+ MM_REG(6) = expected[6].u64;
+ MM_REG(7) = expected[7].u64;
+ } else {
+ fxs->fx_87_ac[0].r.f87_mantissa =
+ expected[0].u64;
+ fxs->fx_87_ac[1].r.f87_mantissa =
+ expected[1].u64;
+ fxs->fx_87_ac[2].r.f87_mantissa =
+ expected[2].u64;
+ fxs->fx_87_ac[3].r.f87_mantissa =
+ expected[3].u64;
+ fxs->fx_87_ac[4].r.f87_mantissa =
+ expected[4].u64;
+ fxs->fx_87_ac[5].r.f87_mantissa =
+ expected[5].u64;
+ fxs->fx_87_ac[6].r.f87_mantissa =
+ expected[6].u64;
+ fxs->fx_87_ac[7].r.f87_mantissa =
+ expected[7].u64;
+ }
+ break;
+ case FPREGS_YMM:
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[0],
+ &expected[0].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[1],
+ &expected[1].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[2],
+ &expected[2].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[3],
+ &expected[3].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[4],
+ &expected[4].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[5],
+ &expected[5].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[6],
+ &expected[6].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[7],
+ &expected[7].ymm.c, sizeof(expected->ymm)/2);
+#if defined(__x86_64__)
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[8],
+ &expected[8].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[9],
+ &expected[9].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[10],
+ &expected[10].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[11],
+ &expected[11].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[12],
+ &expected[12].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[13],
+ &expected[13].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[14],
+ &expected[14].ymm.c, sizeof(expected->ymm)/2);
+ memcpy(&xst.xs_ymm_hi128.xs_ymm[15],
+ &expected[15].ymm.c, sizeof(expected->ymm)/2);
+#endif
+ /*FALLTHROUGH*/
+ case FPREGS_XMM:
+ memcpy(&fxs->fx_xmm[0], &expected[0].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[1], &expected[1].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[2], &expected[2].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[3], &expected[3].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[4], &expected[4].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[5], &expected[5].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[6], &expected[6].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[7], &expected[7].ymm.a,
+ sizeof(expected->ymm)/2);
#if defined(__x86_64__)
- memcpy(&xst.xs_fxsave.fx_xmm[8], &ymm[8].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[8], &ymm[8].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[9], &ymm[9].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[9], &ymm[9].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[10], &ymm[10].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[10], &ymm[10].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[11], &ymm[11].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[11], &ymm[11].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[12], &ymm[12].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[12], &ymm[12].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[13], &ymm[13].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[13], &ymm[13].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[14], &ymm[14].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[14], &ymm[14].c, sizeof(*ymm)/2);
- memcpy(&xst.xs_fxsave.fx_xmm[15], &ymm[15].a, sizeof(*ymm)/2);
- memcpy(&xst.xs_ymm_hi128.xs_ymm[15], &ymm[15].c, sizeof(*ymm)/2);
+ memcpy(&fxs->fx_xmm[8], &expected[8].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[9], &expected[9].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[10], &expected[10].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[11], &expected[11].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[12], &expected[12].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[13], &expected[13].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[14], &expected[14].ymm.a,
+ sizeof(expected->ymm)/2);
+ memcpy(&fxs->fx_xmm[15], &expected[15].ymm.a,
+ sizeof(expected->ymm)/2);
+#endif
+ break;
+ }
+
+ switch (regset) {
+ case TEST_GPREGS:
+ DPRINTF("Call SETREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_SETREGS, child, &gpr, 0)
+ != -1);
+ break;
+ case TEST_XMMREGS:
+#if defined(__i386__)
+ DPRINTF("Call SETXMMREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_SETXMMREGS, child, &xmm, 0)
+ != -1);
+ break;
+#else
+ /*FALLTHROUGH*/
#endif
+ case TEST_FPREGS:
+ DPRINTF("Call SETFPREGS for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_SETFPREGS, child, &fpr, 0)
+ != -1);
+ break;
+ case TEST_XSTATE:
+ DPRINTF("Call SETXSTATE for the child process\n");
+ SYSCALL_REQUIRE(ptrace(PT_SETXSTATE, child, &iov, 0)
+ != -1);
+ break;
+ }
+ break;
+ }
- DPRINTF("Call SETXSTATE for the child process\n");
- SYSCALL_REQUIRE(ptrace(PT_SETXSTATE, child, &iov, 0) != -1);
+#undef MM_REG
DPRINTF("Before resuming the child process where it left off and "
"without signal to be sent\n");
@@ -3686,6 +3394,75 @@ ATF_TC_BODY(x86_xstate_ymm_write, tc)
TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
}
+#define X86_REGISTER_TEST(test, regset, regs, regmode, descr) \
+ATF_TC(test); \
+ATF_TC_HEAD(test, tc) \
+{ \
+ atf_tc_set_md_var(tc, "descr", descr); \
+} \
+ \
+ATF_TC_BODY(test, tc) \
+{ \
+ x86_register_test(regset, regs, regmode); \
+}
+
+X86_REGISTER_TEST(x86_gpregs32_read, TEST_GPREGS, GPREGS_32, TEST_GETREGS,
+ "Test reading basic 32-bit gp registers from debugged program "
+ "via PT_GETREGS.");
+X86_REGISTER_TEST(x86_gpregs32_write, TEST_GPREGS, GPREGS_32, TEST_SETREGS,
+ "Test writing basic 32-bit gp registers into debugged program "
+ "via PT_SETREGS.");
+X86_REGISTER_TEST(x86_gpregs32_ebp_esp_read, TEST_GPREGS, GPREGS_32_EBP_ESP,
+ TEST_GETREGS, "Test reading ebp & esp registers from debugged program "
+ "via PT_GETREGS.");
+X86_REGISTER_TEST(x86_gpregs32_ebp_esp_write, TEST_GPREGS, GPREGS_32_EBP_ESP,
+ TEST_SETREGS, "Test writing ebp & esp registers into debugged program "
+ "via PT_SETREGS.");
+
+X86_REGISTER_TEST(x86_gpregs64_read, TEST_GPREGS, GPREGS_64, TEST_GETREGS,
+ "Test reading basic 64-bit gp registers from debugged program "
+ "via PT_GETREGS.");
+X86_REGISTER_TEST(x86_gpregs64_write, TEST_GPREGS, GPREGS_64, TEST_SETREGS,
+ "Test writing basic 64-bit gp registers into debugged program "
+ "via PT_SETREGS.");
+X86_REGISTER_TEST(x86_gpregs64_r8_read, TEST_GPREGS, GPREGS_64_R8,
TEST_GETREGS,
+ "Test reading r8..r15 registers from debugged program via PT_GETREGS.");
+X86_REGISTER_TEST(x86_gpregs64_r8_write, TEST_GPREGS, GPREGS_64_R8,
+ TEST_SETREGS, "Test writing r8..r15 registers into debugged program "
+ "via PT_SETREGS.");
+
+X86_REGISTER_TEST(x86_fpregs_mm_read, TEST_FPREGS, FPREGS_MM, TEST_GETREGS,
+ "Test reading mm0..mm7 registers from debugged program "
+ "via PT_GETFPREGS.");
+X86_REGISTER_TEST(x86_fpregs_mm_write, TEST_FPREGS, FPREGS_MM, TEST_SETREGS,
+ "Test writing mm0..mm7 registers into debugged program "
+ "via PT_SETFPREGS.");
+X86_REGISTER_TEST(x86_fpregs_xmm_read, TEST_XMMREGS, FPREGS_XMM, TEST_GETREGS,
+ "Test reading xmm0..xmm15 (..xmm7 on i386) from debugged program "
+ "via PT_GETFPREGS (PT_GETXMMREGS on i386).");
+X86_REGISTER_TEST(x86_fpregs_xmm_write, TEST_XMMREGS, FPREGS_XMM, TEST_SETREGS,
+ "Test writing xmm0..xmm15 (..xmm7 on i386) into debugged program "
+ "via PT_SETFPREGS (PT_SETXMMREGS on i386).");
+
+X86_REGISTER_TEST(x86_xstate_mm_read, TEST_XSTATE, FPREGS_MM, TEST_GETREGS,
+ "Test reading mm0..mm7 registers from debugged program "
+ "via PT_GETXSTATE.");
+X86_REGISTER_TEST(x86_xstate_mm_write, TEST_XSTATE, FPREGS_MM, TEST_SETREGS,
+ "Test writing mm0..mm7 registers into debugged program "
+ "via PT_SETXSTATE.");
+X86_REGISTER_TEST(x86_xstate_xmm_read, TEST_XSTATE, FPREGS_XMM, TEST_GETREGS,
+ "Test reading xmm0..xmm15 (..xmm7 on i386) from debugged program "
+ "via PT_GETXSTATE.");
+X86_REGISTER_TEST(x86_xstate_xmm_write, TEST_XSTATE, FPREGS_XMM, TEST_SETREGS,
+ "Test writing xmm0..xmm15 (..xmm7 on i386) into debugged program "
+ "via PT_SETXSTATE.");
+X86_REGISTER_TEST(x86_xstate_ymm_read, TEST_XSTATE, FPREGS_YMM, TEST_GETREGS,
+ "Test reading ymm0..ymm15 (..ymm7 on i386) from debugged program "
+ "via PT_GETXSTATE.");
+X86_REGISTER_TEST(x86_xstate_ymm_write, TEST_XSTATE, FPREGS_YMM, TEST_SETREGS,
+ "Test writing ymm0..ymm15 (..ymm7 on i386) into debugged program "
+ "via PT_SETXSTATE.");
+
///
----------------------------------------------------------------------------
#define ATF_TP_ADD_TCS_PTRACE_WAIT_X86() \
@@ -3751,10 +3528,18 @@ ATF_TC_BODY(x86_xstate_ymm_write, tc)
ATF_TP_ADD_TC_HAVE_DBREGS(tp, dbregs_dr2_dont_inherit_execve); \
ATF_TP_ADD_TC_HAVE_DBREGS(tp, dbregs_dr3_dont_inherit_execve); \
ATF_TP_ADD_TC_HAVE_DBREGS(tp, x86_cve_2018_8897); \
- ATF_TP_ADD_TC_HAVE_FPREGS(tp, x86_regs_mm_read); \
- ATF_TP_ADD_TC_HAVE_FPREGS(tp, x86_regs_mm_write); \
- ATF_TP_ADD_TC_HAVE_FPREGS(tp, x86_regs_xmm_read); \
- ATF_TP_ADD_TC_HAVE_FPREGS(tp, x86_regs_xmm_write); \
+ ATF_TP_ADD_TC(tp, x86_gpregs32_read); \
+ ATF_TP_ADD_TC(tp, x86_gpregs32_write); \
+ ATF_TP_ADD_TC(tp, x86_gpregs32_ebp_esp_read); \
+ ATF_TP_ADD_TC(tp, x86_gpregs32_ebp_esp_write); \
+ ATF_TP_ADD_TC(tp, x86_gpregs64_read); \
+ ATF_TP_ADD_TC(tp, x86_gpregs64_write); \
+ ATF_TP_ADD_TC(tp, x86_gpregs64_r8_read); \
+ ATF_TP_ADD_TC(tp, x86_gpregs64_r8_write); \
+ ATF_TP_ADD_TC(tp, x86_fpregs_mm_read); \
+ ATF_TP_ADD_TC(tp, x86_fpregs_mm_write); \
+ ATF_TP_ADD_TC(tp, x86_fpregs_xmm_read); \
+ ATF_TP_ADD_TC(tp, x86_fpregs_xmm_write); \
ATF_TP_ADD_TC(tp, x86_xstate_mm_read); \
ATF_TP_ADD_TC(tp, x86_xstate_mm_write); \
ATF_TP_ADD_TC(tp, x86_xstate_xmm_read); \
--
2.24.1
