Tue Oct 27 08:32:36 2020 UTC ()
Add tests for AVX-512 registers (zmm0..zmm31, k0..7)

Thanks to David Seifert <soap@gentoo.org> for providing a VM
on an AVX-512 capable hardware

Reviewed by kamil


(mgorny)
diff -r1.30 -r1.31 src/tests/lib/libc/sys/t_ptrace_x86_wait.h
cvs diff -r1.30 -r1.31 src/tests/lib/libc/sys/t_ptrace_x86_wait.h (expand / switch to unified diff)

--- src/tests/lib/libc/sys/t_ptrace_x86_wait.h 2020/10/24 07:14:30 1.30
+++ src/tests/lib/libc/sys/t_ptrace_x86_wait.h 2020/10/27 08:32:36 1.31
@@ -1,14 +1,14 @@ @@ -1,14 +1,14 @@
1/* $NetBSD: t_ptrace_x86_wait.h,v 1.30 2020/10/24 07:14:30 mgorny Exp $ */ 1/* $NetBSD: t_ptrace_x86_wait.h,v 1.31 2020/10/27 08:32:36 mgorny Exp $ */
2 2
3/*- 3/*-
4 * Copyright (c) 2016, 2017, 2018, 2019 The NetBSD Foundation, Inc. 4 * Copyright (c) 2016, 2017, 2018, 2019 The NetBSD Foundation, Inc.
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * Redistribution and use in source and binary forms, with or without 7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions 8 * modification, are permitted provided that the following conditions
9 * are met: 9 * are met:
10 * 1. Redistributions of source code must retain the above copyright 10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer. 11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright 12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the 13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution. 14 * documentation and/or other materials provided with the distribution.
@@ -2167,26 +2167,29 @@ ATF_TC_BODY(x86_cve_2018_8897, tc) @@ -2167,26 +2167,29 @@ ATF_TC_BODY(x86_cve_2018_8897, tc)
2167 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2167 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
2168 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 2168 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
2169 2169
2170 validate_status_signaled(status, SIGKILL, 0); 2170 validate_status_signaled(status, SIGKILL, 0);
2171 2171
2172 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 2172 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
2173 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0)); 2173 TWAIT_REQUIRE_FAILURE(ECHILD, wpid = TWAIT_GENERIC(child, &status, 0));
2174} 2174}
2175 2175
2176/// ---------------------------------------------------------------------------- 2176/// ----------------------------------------------------------------------------
2177 2177
2178union x86_test_register { 2178union x86_test_register {
2179 struct { 2179 struct {
 2180 uint64_t a, b, c, d, e, f, g, h;
 2181 } zmm;
 2182 struct {
2180 uint64_t a, b, c, d; 2183 uint64_t a, b, c, d;
2181 } ymm; 2184 } ymm;
2182 struct { 2185 struct {
2183 uint64_t a, b; 2186 uint64_t a, b;
2184 } xmm; 2187 } xmm;
2185 uint64_t u64; 2188 uint64_t u64;
2186 uint32_t u32; 2189 uint32_t u32;
2187}; 2190};
2188 2191
2189struct x86_test_fpu_registers { 2192struct x86_test_fpu_registers {
2190 struct { 2193 struct {
2191 uint64_t mantissa; 2194 uint64_t mantissa;
2192 uint16_t sign_exp; 2195 uint16_t sign_exp;
@@ -2210,27 +2213,28 @@ enum x86_test_regset { @@ -2210,27 +2213,28 @@ enum x86_test_regset {
2210 2213
2211/* Please keep them grouped by acceptable x86_test_regset. */ 2214/* Please keep them grouped by acceptable x86_test_regset. */
2212enum x86_test_registers { 2215enum x86_test_registers {
2213 /* TEST_GPREGS */ 2216 /* TEST_GPREGS */
2214 GPREGS_32, 2217 GPREGS_32,
2215 GPREGS_32_EBP_ESP, 2218 GPREGS_32_EBP_ESP,
2216 GPREGS_64, 2219 GPREGS_64,
2217 GPREGS_64_R8, 2220 GPREGS_64_R8,
2218 /* TEST_FPREGS/TEST_XMMREGS */ 2221 /* TEST_FPREGS/TEST_XMMREGS */
2219 FPREGS_FPU, 2222 FPREGS_FPU,
2220 FPREGS_MM, 2223 FPREGS_MM,
2221 FPREGS_XMM, 2224 FPREGS_XMM,
2222 /* TEST_XSTATE */ 2225 /* TEST_XSTATE */
2223 FPREGS_YMM 2226 FPREGS_YMM,
 2227 FPREGS_ZMM
2224}; 2228};
2225 2229
2226enum x86_test_regmode { 2230enum x86_test_regmode {
2227 TEST_GETREGS, 2231 TEST_GETREGS,
2228 TEST_SETREGS, 2232 TEST_SETREGS,
2229 TEST_COREDUMP 2233 TEST_COREDUMP
2230}; 2234};
2231 2235
2232static __inline void get_gp32_regs(union x86_test_register out[]) 2236static __inline void get_gp32_regs(union x86_test_register out[])
2233{ 2237{
2234#if defined(__i386__) 2238#if defined(__i386__)
2235 const uint32_t fill = 0x0F0F0F0F; 2239 const uint32_t fill = 0x0F0F0F0F;
2236 2240
@@ -2386,55 +2390,55 @@ static __inline void get_gp64_r8_regs(un @@ -2386,55 +2390,55 @@ static __inline void get_gp64_r8_regs(un
2386 __asm__ __volatile__( 2390 __asm__ __volatile__(
2387 /* fill registers with clobber pattern */ 2391 /* fill registers with clobber pattern */
2388 "movq %1, %%r8\n\t" 2392 "movq %1, %%r8\n\t"
2389 "movq %1, %%r9\n\t" 2393 "movq %1, %%r9\n\t"
2390 "movq %1, %%r10\n\t" 2394 "movq %1, %%r10\n\t"
2391 "movq %1, %%r11\n\t" 2395 "movq %1, %%r11\n\t"
2392 "movq %1, %%r12\n\t" 2396 "movq %1, %%r12\n\t"
2393 "movq %1, %%r13\n\t" 2397 "movq %1, %%r13\n\t"
2394 "movq %1, %%r14\n\t" 2398 "movq %1, %%r14\n\t"
2395 "movq %1, %%r15\n\t" 2399 "movq %1, %%r15\n\t"
2396 "\n\t" 2400 "\n\t"
2397 "int3\n\t" 2401 "int3\n\t"
2398 "\n\t" 2402 "\n\t"
2399 "movq %%r8, 0x00(%0)\n\t" 2403 "movq %%r8, 0x000(%0)\n\t"
2400 "movq %%r9, 0x20(%0)\n\t" 2404 "movq %%r9, 0x040(%0)\n\t"
2401 "movq %%r10, 0x40(%0)\n\t" 2405 "movq %%r10, 0x080(%0)\n\t"
2402 "movq %%r11, 0x60(%0)\n\t" 2406 "movq %%r11, 0x0C0(%0)\n\t"
2403 "movq %%r12, 0x80(%0)\n\t" 2407 "movq %%r12, 0x100(%0)\n\t"
2404 "movq %%r13, 0xA0(%0)\n\t" 2408 "movq %%r13, 0x140(%0)\n\t"
2405 "movq %%r14, 0xC0(%0)\n\t" 2409 "movq %%r14, 0x180(%0)\n\t"
2406 "movq %%r15, 0xE0(%0)\n\t" 2410 "movq %%r15, 0x1C0(%0)\n\t"
2407 : 2411 :
2408 : "a"(out), "m"(fill) 2412 : "a"(out), "m"(fill)
2409 : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 2413 : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2410 ); 2414 );
2411#else 2415#else
2412 __unreachable(); 2416 __unreachable();
2413#endif 2417#endif
2414} 2418}
2415 2419
2416static __inline void set_gp64_r8_regs(const union x86_test_register data[]) 2420static __inline void set_gp64_r8_regs(const union x86_test_register data[])
2417{ 2421{
2418#if defined(__x86_64__) 2422#if defined(__x86_64__)
2419 __asm__ __volatile__( 2423 __asm__ __volatile__(
2420 "movq 0x00(%0), %%r8\n\t" 2424 "movq 0x000(%0), %%r8\n\t"
2421 "movq 0x20(%0), %%r9\n\t" 2425 "movq 0x040(%0), %%r9\n\t"
2422 "movq 0x40(%0), %%r10\n\t" 2426 "movq 0x080(%0), %%r10\n\t"
2423 "movq 0x60(%0), %%r11\n\t" 2427 "movq 0x0C0(%0), %%r11\n\t"
2424 "movq 0x80(%0), %%r12\n\t" 2428 "movq 0x100(%0), %%r12\n\t"
2425 "movq 0xA0(%0), %%r13\n\t" 2429 "movq 0x140(%0), %%r13\n\t"
2426 "movq 0xC0(%0), %%r14\n\t" 2430 "movq 0x180(%0), %%r14\n\t"
2427 "movq 0xE0(%0), %%r15\n\t" 2431 "movq 0x1C0(%0), %%r15\n\t"
2428 "int3\n\t" 2432 "int3\n\t"
2429 : 2433 :
2430 : "b"(data) 2434 : "b"(data)
2431 : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 2435 : "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2432 ); 2436 );
2433#else 2437#else
2434 __unreachable(); 2438 __unreachable();
2435#endif 2439#endif
2436} 2440}
2437 2441
2438static __inline void get_fpu_regs(struct x86_test_fpu_registers *out) 2442static __inline void get_fpu_regs(struct x86_test_fpu_registers *out)
2439{ 2443{
2440 struct save87 fsave; 2444 struct save87 fsave;
@@ -2516,52 +2520,52 @@ static __inline void get_mm_regs(union x @@ -2516,52 +2520,52 @@ static __inline void get_mm_regs(union x
2516 __asm__ __volatile__( 2520 __asm__ __volatile__(
2517 /* fill registers with clobber pattern */ 2521 /* fill registers with clobber pattern */
2518 "movq %1, %%mm0\n\t" 2522 "movq %1, %%mm0\n\t"
2519 "movq %1, %%mm1\n\t" 2523 "movq %1, %%mm1\n\t"
2520 "movq %1, %%mm2\n\t" 2524 "movq %1, %%mm2\n\t"
2521 "movq %1, %%mm3\n\t" 2525 "movq %1, %%mm3\n\t"
2522 "movq %1, %%mm4\n\t" 2526 "movq %1, %%mm4\n\t"
2523 "movq %1, %%mm5\n\t" 2527 "movq %1, %%mm5\n\t"
2524 "movq %1, %%mm6\n\t" 2528 "movq %1, %%mm6\n\t"
2525 "movq %1, %%mm7\n\t" 2529 "movq %1, %%mm7\n\t"
2526 "\n\t" 2530 "\n\t"
2527 "int3\n\t" 2531 "int3\n\t"
2528 "\n\t" 2532 "\n\t"
2529 "movq %%mm0, 0x00(%0)\n\t" 2533 "movq %%mm0, 0x000(%0)\n\t"
2530 "movq %%mm1, 0x20(%0)\n\t" 2534 "movq %%mm1, 0x040(%0)\n\t"
2531 "movq %%mm2, 0x40(%0)\n\t" 2535 "movq %%mm2, 0x080(%0)\n\t"
2532 "movq %%mm3, 0x60(%0)\n\t" 2536 "movq %%mm3, 0x0C0(%0)\n\t"
2533 "movq %%mm4, 0x80(%0)\n\t" 2537 "movq %%mm4, 0x100(%0)\n\t"
2534 "movq %%mm5, 0xA0(%0)\n\t" 2538 "movq %%mm5, 0x140(%0)\n\t"
2535 "movq %%mm6, 0xC0(%0)\n\t" 2539 "movq %%mm6, 0x180(%0)\n\t"
2536 "movq %%mm7, 0xE0(%0)\n\t" 2540 "movq %%mm7, 0x1C0(%0)\n\t"
2537 : 2541 :
2538 : "a"(out), "m"(fill) 2542 : "a"(out), "m"(fill)
2539 : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" 2543 : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
2540 ); 2544 );
2541} 2545}
2542 2546
2543__attribute__((target("mmx"))) 2547__attribute__((target("mmx")))
2544static __inline void set_mm_regs(const union x86_test_register data[]) 2548static __inline void set_mm_regs(const union x86_test_register data[])
2545{ 2549{
2546 __asm__ __volatile__( 2550 __asm__ __volatile__(
2547 "movq 0x00(%0), %%mm0\n\t" 2551 "movq 0x000(%0), %%mm0\n\t"
2548 "movq 0x20(%0), %%mm1\n\t" 2552 "movq 0x040(%0), %%mm1\n\t"
2549 "movq 0x40(%0), %%mm2\n\t" 2553 "movq 0x080(%0), %%mm2\n\t"
2550 "movq 0x60(%0), %%mm3\n\t" 2554 "movq 0x0C0(%0), %%mm3\n\t"
2551 "movq 0x80(%0), %%mm4\n\t" 2555 "movq 0x100(%0), %%mm4\n\t"
2552 "movq 0xA0(%0), %%mm5\n\t" 2556 "movq 0x140(%0), %%mm5\n\t"
2553 "movq 0xC0(%0), %%mm6\n\t" 2557 "movq 0x180(%0), %%mm6\n\t"
2554 "movq 0xE0(%0), %%mm7\n\t" 2558 "movq 0x1C0(%0), %%mm7\n\t"
2555 "int3\n\t" 2559 "int3\n\t"
2556 : 2560 :
2557 : "b"(data) 2561 : "b"(data)
2558 : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7" 2562 : "%mm0", "%mm1", "%mm2", "%mm3", "%mm4", "%mm5", "%mm6", "%mm7"
2559 ); 2563 );
2560} 2564}
2561 2565
2562__attribute__((target("sse"))) 2566__attribute__((target("sse")))
2563static __inline void get_xmm_regs(union x86_test_register out[]) 2567static __inline void get_xmm_regs(union x86_test_register out[])
2564{ 2568{
2565 union x86_test_register fill __aligned(32) = { 2569 union x86_test_register fill __aligned(32) = {
2566 .xmm={ 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F } 2570 .xmm={ 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F }
2567 }; 2571 };
@@ -2580,235 +2584,513 @@ static __inline void get_xmm_regs(union  @@ -2580,235 +2584,513 @@ static __inline void get_xmm_regs(union
2580 "movaps %1, %%xmm8\n\t" 2584 "movaps %1, %%xmm8\n\t"
2581 "movaps %1, %%xmm9\n\t" 2585 "movaps %1, %%xmm9\n\t"
2582 "movaps %1, %%xmm10\n\t" 2586 "movaps %1, %%xmm10\n\t"
2583 "movaps %1, %%xmm11\n\t" 2587 "movaps %1, %%xmm11\n\t"
2584 "movaps %1, %%xmm12\n\t" 2588 "movaps %1, %%xmm12\n\t"
2585 "movaps %1, %%xmm13\n\t" 2589 "movaps %1, %%xmm13\n\t"
2586 "movaps %1, %%xmm14\n\t" 2590 "movaps %1, %%xmm14\n\t"
2587 "movaps %1, %%xmm15\n\t" 2591 "movaps %1, %%xmm15\n\t"
2588#endif 2592#endif
2589 "\n\t" 2593 "\n\t"
2590 "int3\n\t" 2594 "int3\n\t"
2591 "\n\t" 2595 "\n\t"
2592 "movaps %%xmm0, 0x000(%0)\n\t" 2596 "movaps %%xmm0, 0x000(%0)\n\t"
2593 "movaps %%xmm1, 0x020(%0)\n\t" 2597 "movaps %%xmm1, 0x040(%0)\n\t"
2594 "movaps %%xmm2, 0x040(%0)\n\t" 2598 "movaps %%xmm2, 0x080(%0)\n\t"
2595 "movaps %%xmm3, 0x060(%0)\n\t" 2599 "movaps %%xmm3, 0x0C0(%0)\n\t"
2596 "movaps %%xmm4, 0x080(%0)\n\t" 2600 "movaps %%xmm4, 0x100(%0)\n\t"
2597 "movaps %%xmm5, 0x0A0(%0)\n\t" 2601 "movaps %%xmm5, 0x140(%0)\n\t"
2598 "movaps %%xmm6, 0x0C0(%0)\n\t" 2602 "movaps %%xmm6, 0x180(%0)\n\t"
2599 "movaps %%xmm7, 0x0E0(%0)\n\t" 2603 "movaps %%xmm7, 0x1C0(%0)\n\t"
2600#if defined(__x86_64__) 2604#if defined(__x86_64__)
2601 "movaps %%xmm8, 0x100(%0)\n\t" 2605 "movaps %%xmm8, 0x200(%0)\n\t"
2602 "movaps %%xmm9, 0x120(%0)\n\t" 2606 "movaps %%xmm9, 0x240(%0)\n\t"
2603 "movaps %%xmm10, 0x140(%0)\n\t" 2607 "movaps %%xmm10, 0x280(%0)\n\t"
2604 "movaps %%xmm11, 0x160(%0)\n\t" 2608 "movaps %%xmm11, 0x2C0(%0)\n\t"
2605 "movaps %%xmm12, 0x180(%0)\n\t" 2609 "movaps %%xmm12, 0x300(%0)\n\t"
2606 "movaps %%xmm13, 0x1A0(%0)\n\t" 2610 "movaps %%xmm13, 0x340(%0)\n\t"
2607 "movaps %%xmm14, 0x1C0(%0)\n\t" 2611 "movaps %%xmm14, 0x380(%0)\n\t"
2608 "movaps %%xmm15, 0x1E0(%0)\n\t" 2612 "movaps %%xmm15, 0x3C0(%0)\n\t"
2609#endif 2613#endif
2610 : 2614 :
2611 : "a"(out), "m"(fill) 2615 : "a"(out), "m"(fill)
2612 : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7" 2616 : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", "%xmm7"
2613#if defined(__x86_64__) 2617#if defined(__x86_64__)
2614 , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14", 2618 , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", "%xmm14",
2615 "%xmm15" 2619 "%xmm15"
2616#endif 2620#endif
2617 ); 2621 );
2618} 2622}
2619 2623
2620__attribute__((target("sse"))) 2624__attribute__((target("sse")))
2621static __inline void set_xmm_regs(const union x86_test_register data[]) 2625static __inline void set_xmm_regs(const union x86_test_register data[])
2622{ 2626{
2623 __asm__ __volatile__( 2627 __asm__ __volatile__(
2624 "movaps 0x000(%0), %%xmm0\n\t" 2628 "movaps 0x000(%0), %%xmm0\n\t"
2625 "movaps 0x020(%0), %%xmm1\n\t" 2629 "movaps 0x040(%0), %%xmm1\n\t"
2626 "movaps 0x040(%0), %%xmm2\n\t" 2630 "movaps 0x080(%0), %%xmm2\n\t"
2627 "movaps 0x060(%0), %%xmm3\n\t" 2631 "movaps 0x0C0(%0), %%xmm3\n\t"
2628 "movaps 0x080(%0), %%xmm4\n\t" 2632 "movaps 0x100(%0), %%xmm4\n\t"
2629 "movaps 0x0A0(%0), %%xmm5\n\t" 2633 "movaps 0x140(%0), %%xmm5\n\t"
2630 "movaps 0x0C0(%0), %%xmm6\n\t" 2634 "movaps 0x180(%0), %%xmm6\n\t"
2631 "movaps 0x0E0(%0), %%xmm7\n\t" 2635 "movaps 0x1C0(%0), %%xmm7\n\t"
2632#if defined(__x86_64__) 2636#if defined(__x86_64__)
2633 "movaps 0x100(%0), %%xmm8\n\t" 2637 "movaps 0x200(%0), %%xmm8\n\t"
2634 "movaps 0x120(%0), %%xmm9\n\t" 2638 "movaps 0x240(%0), %%xmm9\n\t"
2635 "movaps 0x140(%0), %%xmm10\n\t" 2639 "movaps 0x280(%0), %%xmm10\n\t"
2636 "movaps 0x160(%0), %%xmm11\n\t" 2640 "movaps 0x2C0(%0), %%xmm11\n\t"
2637 "movaps 0x180(%0), %%xmm12\n\t" 2641 "movaps 0x300(%0), %%xmm12\n\t"
2638 "movaps 0x1A0(%0), %%xmm13\n\t" 2642 "movaps 0x340(%0), %%xmm13\n\t"
2639 "movaps 0x1C0(%0), %%xmm14\n\t" 2643 "movaps 0x380(%0), %%xmm14\n\t"
2640 "movaps 0x1E0(%0), %%xmm15\n\t" 2644 "movaps 0x3C0(%0), %%xmm15\n\t"
2641#endif 2645#endif
2642 "int3\n\t" 2646 "int3\n\t"
2643 : 2647 :
2644 : "b"(data) 2648 : "b"(data)
2645 : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6", 2649 : "%xmm0", "%xmm1", "%xmm2", "%xmm3", "%xmm4", "%xmm5", "%xmm6",
2646 "%xmm7" 2650 "%xmm7"
2647#if defined(__x86_64__) 2651#if defined(__x86_64__)
2648 , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13", 2652 , "%xmm8", "%xmm9", "%xmm10", "%xmm11", "%xmm12", "%xmm13",
2649 "%xmm14", "%xmm15" 2653 "%xmm14", "%xmm15"
2650#endif 2654#endif
2651 ); 2655 );
2652} 2656}
2653 2657
2654__attribute__((target("avx"))) 2658__attribute__((target("avx")))
2655static __inline void get_ymm_regs(union x86_test_register out[]) 2659static __inline void get_ymm_regs(union x86_test_register out[])
2656{ 2660{
2657 union x86_test_register fill __aligned(32) = { 2661 union x86_test_register fill __aligned(32) = {
2658 { 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F, 2662 .ymm = {
2659 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F } 2663 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
 2664 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F
 2665 }
2660 }; 2666 };
2661 2667
2662 __asm__ __volatile__( 2668 __asm__ __volatile__(
2663 /* fill registers with clobber pattern */ 2669 /* fill registers with clobber pattern */
2664 "vmovaps %1, %%ymm0\n\t" 2670 "vmovaps %1, %%ymm0\n\t"
2665 "vmovaps %1, %%ymm1\n\t" 2671 "vmovaps %1, %%ymm1\n\t"
2666 "vmovaps %1, %%ymm2\n\t" 2672 "vmovaps %1, %%ymm2\n\t"
2667 "vmovaps %1, %%ymm3\n\t" 2673 "vmovaps %1, %%ymm3\n\t"
2668 "vmovaps %1, %%ymm4\n\t" 2674 "vmovaps %1, %%ymm4\n\t"
2669 "vmovaps %1, %%ymm5\n\t" 2675 "vmovaps %1, %%ymm5\n\t"
2670 "vmovaps %1, %%ymm6\n\t" 2676 "vmovaps %1, %%ymm6\n\t"
2671 "vmovaps %1, %%ymm7\n\t" 2677 "vmovaps %1, %%ymm7\n\t"
2672#if defined(__x86_64__) 2678#if defined(__x86_64__)
2673 "vmovaps %1, %%ymm8\n\t" 2679 "vmovaps %1, %%ymm8\n\t"
2674 "vmovaps %1, %%ymm9\n\t" 2680 "vmovaps %1, %%ymm9\n\t"
2675 "vmovaps %1, %%ymm10\n\t" 2681 "vmovaps %1, %%ymm10\n\t"
2676 "vmovaps %1, %%ymm11\n\t" 2682 "vmovaps %1, %%ymm11\n\t"
2677 "vmovaps %1, %%ymm12\n\t" 2683 "vmovaps %1, %%ymm12\n\t"
2678 "vmovaps %1, %%ymm13\n\t" 2684 "vmovaps %1, %%ymm13\n\t"
2679 "vmovaps %1, %%ymm14\n\t" 2685 "vmovaps %1, %%ymm14\n\t"
2680 "vmovaps %1, %%ymm15\n\t" 2686 "vmovaps %1, %%ymm15\n\t"
2681#endif 2687#endif
2682 "\n\t" 2688 "\n\t"
2683 "int3\n\t" 2689 "int3\n\t"
2684 "\n\t" 2690 "\n\t"
2685 "vmovaps %%ymm0, 0x000(%0)\n\t" 2691 "vmovaps %%ymm0, 0x000(%0)\n\t"
2686 "vmovaps %%ymm1, 0x020(%0)\n\t" 2692 "vmovaps %%ymm1, 0x040(%0)\n\t"
2687 "vmovaps %%ymm2, 0x040(%0)\n\t" 2693 "vmovaps %%ymm2, 0x080(%0)\n\t"
2688 "vmovaps %%ymm3, 0x060(%0)\n\t" 2694 "vmovaps %%ymm3, 0x0C0(%0)\n\t"
2689 "vmovaps %%ymm4, 0x080(%0)\n\t" 2695 "vmovaps %%ymm4, 0x100(%0)\n\t"
2690 "vmovaps %%ymm5, 0x0A0(%0)\n\t" 2696 "vmovaps %%ymm5, 0x140(%0)\n\t"
2691 "vmovaps %%ymm6, 0x0C0(%0)\n\t" 2697 "vmovaps %%ymm6, 0x180(%0)\n\t"
2692 "vmovaps %%ymm7, 0x0E0(%0)\n\t" 2698 "vmovaps %%ymm7, 0x1C0(%0)\n\t"
2693#if defined(__x86_64__) 2699#if defined(__x86_64__)
2694 "vmovaps %%ymm8, 0x100(%0)\n\t" 2700 "vmovaps %%ymm8, 0x200(%0)\n\t"
2695 "vmovaps %%ymm9, 0x120(%0)\n\t" 2701 "vmovaps %%ymm9, 0x240(%0)\n\t"
2696 "vmovaps %%ymm10, 0x140(%0)\n\t" 2702 "vmovaps %%ymm10, 0x280(%0)\n\t"
2697 "vmovaps %%ymm11, 0x160(%0)\n\t" 2703 "vmovaps %%ymm11, 0x2C0(%0)\n\t"
2698 "vmovaps %%ymm12, 0x180(%0)\n\t" 2704 "vmovaps %%ymm12, 0x300(%0)\n\t"
2699 "vmovaps %%ymm13, 0x1A0(%0)\n\t" 2705 "vmovaps %%ymm13, 0x340(%0)\n\t"
2700 "vmovaps %%ymm14, 0x1C0(%0)\n\t" 2706 "vmovaps %%ymm14, 0x380(%0)\n\t"
2701 "vmovaps %%ymm15, 0x1E0(%0)\n\t" 2707 "vmovaps %%ymm15, 0x3C0(%0)\n\t"
2702#endif 2708#endif
2703 : 2709 :
2704 : "a"(out), "m"(fill) 2710 : "a"(out), "m"(fill)
2705 : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6", "%ymm7" 2711 : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6", "%ymm7"
2706#if defined(__x86_64__) 2712#if defined(__x86_64__)
2707 , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13", "%ymm14", 2713 , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13", "%ymm14",
2708 "%ymm15" 2714 "%ymm15"
2709#endif 2715#endif
2710 ); 2716 );
2711} 2717}
2712 2718
2713__attribute__((target("avx"))) 2719__attribute__((target("avx")))
2714static __inline void set_ymm_regs(const union x86_test_register data[]) 2720static __inline void set_ymm_regs(const union x86_test_register data[])
2715{ 2721{
2716 __asm__ __volatile__( 2722 __asm__ __volatile__(
2717 "vmovaps 0x000(%0), %%ymm0\n\t" 2723 "vmovaps 0x000(%0), %%ymm0\n\t"
2718 "vmovaps 0x020(%0), %%ymm1\n\t" 2724 "vmovaps 0x040(%0), %%ymm1\n\t"
2719 "vmovaps 0x040(%0), %%ymm2\n\t" 2725 "vmovaps 0x080(%0), %%ymm2\n\t"
2720 "vmovaps 0x060(%0), %%ymm3\n\t" 2726 "vmovaps 0x0C0(%0), %%ymm3\n\t"
2721 "vmovaps 0x080(%0), %%ymm4\n\t" 2727 "vmovaps 0x100(%0), %%ymm4\n\t"
2722 "vmovaps 0x0A0(%0), %%ymm5\n\t" 2728 "vmovaps 0x140(%0), %%ymm5\n\t"
2723 "vmovaps 0x0C0(%0), %%ymm6\n\t" 2729 "vmovaps 0x180(%0), %%ymm6\n\t"
2724 "vmovaps 0x0E0(%0), %%ymm7\n\t" 2730 "vmovaps 0x1C0(%0), %%ymm7\n\t"
2725#if defined(__x86_64__) 2731#if defined(__x86_64__)
2726 "vmovaps 0x100(%0), %%ymm8\n\t" 2732 "vmovaps 0x200(%0), %%ymm8\n\t"
2727 "vmovaps 0x120(%0), %%ymm9\n\t" 2733 "vmovaps 0x240(%0), %%ymm9\n\t"
2728 "vmovaps 0x140(%0), %%ymm10\n\t" 2734 "vmovaps 0x280(%0), %%ymm10\n\t"
2729 "vmovaps 0x160(%0), %%ymm11\n\t" 2735 "vmovaps 0x2C0(%0), %%ymm11\n\t"
2730 "vmovaps 0x180(%0), %%ymm12\n\t" 2736 "vmovaps 0x300(%0), %%ymm12\n\t"
2731 "vmovaps 0x1A0(%0), %%ymm13\n\t" 2737 "vmovaps 0x340(%0), %%ymm13\n\t"
2732 "vmovaps 0x1C0(%0), %%ymm14\n\t" 2738 "vmovaps 0x380(%0), %%ymm14\n\t"
2733 "vmovaps 0x1E0(%0), %%ymm15\n\t" 2739 "vmovaps 0x3C0(%0), %%ymm15\n\t"
2734#endif 2740#endif
2735 "int3\n\t" 2741 "int3\n\t"
2736 : 2742 :
2737 : "b"(data) 2743 : "b"(data)
2738 : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6", 2744 : "%ymm0", "%ymm1", "%ymm2", "%ymm3", "%ymm4", "%ymm5", "%ymm6",
2739 "%ymm7" 2745 "%ymm7"
2740#if defined(__x86_64__) 2746#if defined(__x86_64__)
2741 , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13", 2747 , "%ymm8", "%ymm9", "%ymm10", "%ymm11", "%ymm12", "%ymm13",
2742 "%ymm14", "%ymm15" 2748 "%ymm14", "%ymm15"
2743#endif 2749#endif
2744 ); 2750 );
2745} 2751}
2746 2752
 2753__attribute__((target("avx512f")))
 2754static __inline void get_zmm_regs(union x86_test_register out[])
 2755{
 2756 union x86_test_register fill __aligned(64) = {
 2757 .zmm = {
 2758 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
 2759 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
 2760 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F,
 2761 0x0F0F0F0F0F0F0F0F, 0x0F0F0F0F0F0F0F0F
 2762 }
 2763 };
 2764
 2765 __asm__ __volatile__(
 2766 /* fill registers with clobber pattern */
 2767 "vmovaps %1, %%zmm0\n\t"
 2768 "vmovaps %1, %%zmm1\n\t"
 2769 "vmovaps %1, %%zmm2\n\t"
 2770 "vmovaps %1, %%zmm3\n\t"
 2771 "vmovaps %1, %%zmm4\n\t"
 2772 "vmovaps %1, %%zmm5\n\t"
 2773 "vmovaps %1, %%zmm6\n\t"
 2774 "vmovaps %1, %%zmm7\n\t"
 2775#if defined(__x86_64__)
 2776 "vmovaps %1, %%zmm8\n\t"
 2777 "vmovaps %1, %%zmm9\n\t"
 2778 "vmovaps %1, %%zmm10\n\t"
 2779 "vmovaps %1, %%zmm11\n\t"
 2780 "vmovaps %1, %%zmm12\n\t"
 2781 "vmovaps %1, %%zmm13\n\t"
 2782 "vmovaps %1, %%zmm14\n\t"
 2783 "vmovaps %1, %%zmm15\n\t"
 2784 "vmovaps %1, %%zmm16\n\t"
 2785 "vmovaps %1, %%zmm17\n\t"
 2786 "vmovaps %1, %%zmm18\n\t"
 2787 "vmovaps %1, %%zmm19\n\t"
 2788 "vmovaps %1, %%zmm20\n\t"
 2789 "vmovaps %1, %%zmm21\n\t"
 2790 "vmovaps %1, %%zmm22\n\t"
 2791 "vmovaps %1, %%zmm23\n\t"
 2792 "vmovaps %1, %%zmm24\n\t"
 2793 "vmovaps %1, %%zmm25\n\t"
 2794 "vmovaps %1, %%zmm26\n\t"
 2795 "vmovaps %1, %%zmm27\n\t"
 2796 "vmovaps %1, %%zmm28\n\t"
 2797 "vmovaps %1, %%zmm29\n\t"
 2798 "vmovaps %1, %%zmm30\n\t"
 2799 "vmovaps %1, %%zmm31\n\t"
 2800#endif
 2801 "kmovq %1, %%k0\n\t"
 2802 "kmovq %1, %%k1\n\t"
 2803 "kmovq %1, %%k2\n\t"
 2804 "kmovq %1, %%k3\n\t"
 2805 "kmovq %1, %%k4\n\t"
 2806 "kmovq %1, %%k5\n\t"
 2807 "kmovq %1, %%k6\n\t"
 2808 "kmovq %1, %%k7\n\t"
 2809 "\n\t"
 2810 "int3\n\t"
 2811 "\n\t"
 2812 "vmovaps %%zmm0, 0x000(%0)\n\t"
 2813 "vmovaps %%zmm1, 0x040(%0)\n\t"
 2814 "vmovaps %%zmm2, 0x080(%0)\n\t"
 2815 "vmovaps %%zmm3, 0x0C0(%0)\n\t"
 2816 "vmovaps %%zmm4, 0x100(%0)\n\t"
 2817 "vmovaps %%zmm5, 0x140(%0)\n\t"
 2818 "vmovaps %%zmm6, 0x180(%0)\n\t"
 2819 "vmovaps %%zmm7, 0x1C0(%0)\n\t"
 2820#if defined(__x86_64__)
 2821 "vmovaps %%zmm8, 0x200(%0)\n\t"
 2822 "vmovaps %%zmm9, 0x240(%0)\n\t"
 2823 "vmovaps %%zmm10, 0x280(%0)\n\t"
 2824 "vmovaps %%zmm11, 0x2C0(%0)\n\t"
 2825 "vmovaps %%zmm12, 0x300(%0)\n\t"
 2826 "vmovaps %%zmm13, 0x340(%0)\n\t"
 2827 "vmovaps %%zmm14, 0x380(%0)\n\t"
 2828 "vmovaps %%zmm15, 0x3C0(%0)\n\t"
 2829 "vmovaps %%zmm16, 0x400(%0)\n\t"
 2830 "vmovaps %%zmm17, 0x440(%0)\n\t"
 2831 "vmovaps %%zmm18, 0x480(%0)\n\t"
 2832 "vmovaps %%zmm19, 0x4C0(%0)\n\t"
 2833 "vmovaps %%zmm20, 0x500(%0)\n\t"
 2834 "vmovaps %%zmm21, 0x540(%0)\n\t"
 2835 "vmovaps %%zmm22, 0x580(%0)\n\t"
 2836 "vmovaps %%zmm23, 0x5C0(%0)\n\t"
 2837 "vmovaps %%zmm24, 0x600(%0)\n\t"
 2838 "vmovaps %%zmm25, 0x640(%0)\n\t"
 2839 "vmovaps %%zmm26, 0x680(%0)\n\t"
 2840 "vmovaps %%zmm27, 0x6C0(%0)\n\t"
 2841 "vmovaps %%zmm28, 0x700(%0)\n\t"
 2842 "vmovaps %%zmm29, 0x740(%0)\n\t"
 2843 "vmovaps %%zmm30, 0x780(%0)\n\t"
 2844 "vmovaps %%zmm31, 0x7C0(%0)\n\t"
 2845#endif
 2846 "kmovq %%k0, 0x800(%0)\n\t"
 2847 "kmovq %%k1, 0x808(%0)\n\t"
 2848 "kmovq %%k2, 0x810(%0)\n\t"
 2849 "kmovq %%k3, 0x818(%0)\n\t"
 2850 "kmovq %%k4, 0x820(%0)\n\t"
 2851 "kmovq %%k5, 0x828(%0)\n\t"
 2852 "kmovq %%k6, 0x830(%0)\n\t"
 2853 "kmovq %%k7, 0x838(%0)\n\t"
 2854 :
 2855 : "a"(out), "m"(fill)
 2856 : "%zmm0", "%zmm1", "%zmm2", "%zmm3", "%zmm4", "%zmm5", "%zmm6", "%zmm7"
 2857#if defined(__x86_64__)
 2858 , "%zmm8", "%zmm9", "%zmm10", "%zmm11", "%zmm12", "%zmm13", "%zmm14",
 2859 "%zmm15", "%zmm16", "%zmm17", "%zmm18", "%zmm19", "%zmm20", "%zmm21",
 2860 "%zmm22", "%zmm23", "%zmm24", "%zmm25", "%zmm26", "%zmm27", "%zmm28",
 2861 "%zmm29", "%zmm30", "%zmm31"
 2862#endif
 2863 , "%k0", "%k1", "%k2", "%k3", "%k4", "%k5", "%k6", "%k7"
 2864 );
 2865}
 2866
 2867__attribute__((target("avx512f")))
 2868static __inline void set_zmm_regs(const union x86_test_register data[])
 2869{
 2870 __asm__ __volatile__(
 2871 "vmovaps 0x000(%0), %%zmm0\n\t"
 2872 "vmovaps 0x040(%0), %%zmm1\n\t"
 2873 "vmovaps 0x080(%0), %%zmm2\n\t"
 2874 "vmovaps 0x0C0(%0), %%zmm3\n\t"
 2875 "vmovaps 0x100(%0), %%zmm4\n\t"
 2876 "vmovaps 0x140(%0), %%zmm5\n\t"
 2877 "vmovaps 0x180(%0), %%zmm6\n\t"
 2878 "vmovaps 0x1C0(%0), %%zmm7\n\t"
 2879#if defined(__x86_64__)
 2880 "vmovaps 0x200(%0), %%zmm8\n\t"
 2881 "vmovaps 0x240(%0), %%zmm9\n\t"
 2882 "vmovaps 0x280(%0), %%zmm10\n\t"
 2883 "vmovaps 0x2C0(%0), %%zmm11\n\t"
 2884 "vmovaps 0x300(%0), %%zmm12\n\t"
 2885 "vmovaps 0x340(%0), %%zmm13\n\t"
 2886 "vmovaps 0x380(%0), %%zmm14\n\t"
 2887 "vmovaps 0x3C0(%0), %%zmm15\n\t"
 2888 "vmovaps 0x400(%0), %%zmm16\n\t"
 2889 "vmovaps 0x440(%0), %%zmm17\n\t"
 2890 "vmovaps 0x480(%0), %%zmm18\n\t"
 2891 "vmovaps 0x4C0(%0), %%zmm19\n\t"
 2892 "vmovaps 0x500(%0), %%zmm20\n\t"
 2893 "vmovaps 0x540(%0), %%zmm21\n\t"
 2894 "vmovaps 0x580(%0), %%zmm22\n\t"
 2895 "vmovaps 0x5C0(%0), %%zmm23\n\t"
 2896 "vmovaps 0x600(%0), %%zmm24\n\t"
 2897 "vmovaps 0x640(%0), %%zmm25\n\t"
 2898 "vmovaps 0x680(%0), %%zmm26\n\t"
 2899 "vmovaps 0x6C0(%0), %%zmm27\n\t"
 2900 "vmovaps 0x700(%0), %%zmm28\n\t"
 2901 "vmovaps 0x740(%0), %%zmm29\n\t"
 2902 "vmovaps 0x780(%0), %%zmm30\n\t"
 2903 "vmovaps 0x7C0(%0), %%zmm31\n\t"
 2904#endif
 2905 "kmovq 0x800(%0), %%k0\n\t"
 2906 "kmovq 0x808(%0), %%k1\n\t"
 2907 "kmovq 0x810(%0), %%k2\n\t"
 2908 "kmovq 0x818(%0), %%k3\n\t"
 2909 "kmovq 0x820(%0), %%k4\n\t"
 2910 "kmovq 0x828(%0), %%k5\n\t"
 2911 "kmovq 0x830(%0), %%k6\n\t"
 2912 "kmovq 0x838(%0), %%k7\n\t"
 2913 "int3\n\t"
 2914 :
 2915 : "b"(data)
 2916 : "%zmm0", "%zmm1", "%zmm2", "%zmm3", "%zmm4", "%zmm5", "%zmm6", "%zmm7"
 2917#if defined(__x86_64__)
 2918 , "%zmm8", "%zmm9", "%zmm10", "%zmm11", "%zmm12", "%zmm13", "%zmm14",
 2919 "%zmm15", "%zmm16", "%zmm17", "%zmm18", "%zmm19", "%zmm20", "%zmm21",
 2920 "%zmm22", "%zmm23", "%zmm24", "%zmm25", "%zmm26", "%zmm27", "%zmm28",
 2921 "%zmm29", "%zmm30", "%zmm31"
 2922#endif
 2923 , "%k0", "%k1", "%k2", "%k3", "%k4",
 2924 "%k5", "%k6", "%k7"
 2925 );
 2926}
 2927
2747static void 2928static void
2748x86_register_test(enum x86_test_regset regset, enum x86_test_registers regs, 2929x86_register_test(enum x86_test_regset regset, enum x86_test_registers regs,
2749 enum x86_test_regmode regmode) 2930 enum x86_test_regmode regmode)
2750{ 2931{
2751 const int exitval = 5; 2932 const int exitval = 5;
2752 pid_t child, wpid; 2933 pid_t child, wpid;
2753#if defined(TWAIT_HAVE_STATUS) 2934#if defined(TWAIT_HAVE_STATUS)
2754 const int sigval = SIGTRAP; 2935 const int sigval = SIGTRAP;
2755 int status; 2936 int status;
2756#endif 2937#endif
2757 struct reg gpr; 2938 struct reg gpr;
2758 struct fpreg fpr; 2939 struct fpreg fpr;
2759#if defined(__i386__) 2940#if defined(__i386__)
2760 struct xmmregs xmm; 2941 struct xmmregs xmm;
2761#endif 2942#endif
2762 struct xstate xst; 2943 struct xstate xst;
2763 struct iovec iov; 2944 struct iovec iov;
2764 struct fxsave* fxs = NULL; 2945 struct fxsave* fxs = NULL;
2765 uint64_t xst_flags = 0; 2946 uint64_t xst_flags = 0;
2766 char core_path[] = "/tmp/core.XXXXXX"; 2947 char core_path[] = "/tmp/core.XXXXXX";
2767 int core_fd; 2948 int core_fd;
2768 2949
2769 const union x86_test_register expected[] __aligned(32) = { 2950 const union x86_test_register expected[] __aligned(64) = {
2770 {{ 0x0706050403020100, 0x0F0E0D0C0B0A0908, 2951 {{ 0x0706050403020100, 0x0F0E0D0C0B0A0908,
2771 0x1716151413121110, 0x1F1E1D1C1B1A1918, }}, 2952 0x1716151413121110, 0x1F1E1D1C1B1A1918,
 2953 0x2726252423222120, 0x2F2E2D2C2B2A2928,
 2954 0x3736353433323130, 0x3F3E3D3C3B3A3938, }},
2772 {{ 0x0807060504030201, 0x100F0E0D0C0B0A09, 2955 {{ 0x0807060504030201, 0x100F0E0D0C0B0A09,
2773 0x1817161514131211, 0x201F1E1D1C1B1A19, }}, 2956 0x1817161514131211, 0x201F1E1D1C1B1A19,
 2957 0x2827262524232221, 0x302F2E2D2C2B2A29,
 2958 0x3837363534333231, 0x403F3E3D3C3B3A39, }},
2774 {{ 0x0908070605040302, 0x11100F0E0D0C0B0A, 2959 {{ 0x0908070605040302, 0x11100F0E0D0C0B0A,
2775 0x1918171615141312, 0x21201F1E1D1C1B1A, }}, 2960 0x1918171615141312, 0x21201F1E1D1C1B1A,
 2961 0x2928272625242322, 0x31302F2E2D2C2B2A,
 2962 0x3938373635343332, 0x41403F3E3D3C3B3A, }},
2776 {{ 0x0A09080706050403, 0x1211100F0E0D0C0B, 2963 {{ 0x0A09080706050403, 0x1211100F0E0D0C0B,
2777 0x1A19181716151413, 0x2221201F1E1D1C1B, }}, 2964 0x1A19181716151413, 0x2221201F1E1D1C1B,
 2965 0x2A29282726252423, 0x3231302F2E2D2C2B,
 2966 0x3A39383736353433, 0x4241403F3E3D3C3B, }},
2778 {{ 0x0B0A090807060504, 0x131211100F0E0D0C, 2967 {{ 0x0B0A090807060504, 0x131211100F0E0D0C,
2779 0x1B1A191817161514, 0x232221201F1E1D1C, }}, 2968 0x1B1A191817161514, 0x232221201F1E1D1C,
 2969 0x2B2A292827262524, 0x333231302F2E2D2C,
 2970 0x3B3A393837363534, 0x434241403F3E3D3C, }},
2780 {{ 0x0C0B0A0908070605, 0x14131211100F0E0D, 2971 {{ 0x0C0B0A0908070605, 0x14131211100F0E0D,
2781 0x1C1B1A1918171615, 0x24232221201F1E1D, }}, 2972 0x1C1B1A1918171615, 0x24232221201F1E1D,
 2973 0x2C2B2A2928272625, 0x34333231302F2E2D,
 2974 0x3C3B3A3938373635, 0x44434241403F3E3D, }},
2782 {{ 0x0D0C0B0A09080706, 0x1514131211100F0E, 2975 {{ 0x0D0C0B0A09080706, 0x1514131211100F0E,
2783 0x1D1C1B1A19181716, 0x2524232221201F1E, }}, 2976 0x1D1C1B1A19181716, 0x2524232221201F1E,
 2977 0x2D2C2B2A29282726, 0x3534333231302F2E,
 2978 0x3D3C3B3A39383736, 0x4544434241403F3E, }},
2784 {{ 0x0E0D0C0B0A090807, 0x161514131211100F, 2979 {{ 0x0E0D0C0B0A090807, 0x161514131211100F,
2785 0x1E1D1C1B1A191817, 0x262524232221201F, }}, 2980 0x1E1D1C1B1A191817, 0x262524232221201F,
 2981 0x2E2D2C2B2A292827, 0x363534333231302F,
 2982 0x3E3D3C3B3A393837, 0x464544434241403F, }},
2786 {{ 0x0F0E0D0C0B0A0908, 0x1716151413121110, 2983 {{ 0x0F0E0D0C0B0A0908, 0x1716151413121110,
2787 0x1F1E1D1C1B1A1918, 0x2726252423222120, }}, 2984 0x1F1E1D1C1B1A1918, 0x2726252423222120,
 2985 0x2F2E2D2C2B2A2928, 0x3736353433323130,
 2986 0x3F3E3D3C3B3A3938, 0x4746454443424140, }},
2788 {{ 0x100F0E0D0C0B0A09, 0x1817161514131211, 2987 {{ 0x100F0E0D0C0B0A09, 0x1817161514131211,
2789 0x201F1E1D1C1B1A19, 0x2827262524232221, }}, 2988 0x201F1E1D1C1B1A19, 0x2827262524232221,
 2989 0x302F2E2D2C2B2A29, 0x3837363534333231,
 2990 0x403F3E3D3C3B3A39, 0x4847464544434241, }},
2790 {{ 0x11100F0E0D0C0B0A, 0x1918171615141312, 2991 {{ 0x11100F0E0D0C0B0A, 0x1918171615141312,
2791 0x21201F1E1D1C1B1A, 0x2928272625242322, }}, 2992 0x21201F1E1D1C1B1A, 0x2928272625242322,
 2993 0x31302F2E2D2C2B2A, 0x3938373635343332,
 2994 0x41403F3E3D3C3B3A, 0x4948474645444342, }},
2792 {{ 0x1211100F0E0D0C0B, 0x1A19181716151413, 2995 {{ 0x1211100F0E0D0C0B, 0x1A19181716151413,
2793 0x2221201F1E1D1C1B, 0x2A29282726252423, }}, 2996 0x2221201F1E1D1C1B, 0x2A29282726252423,
 2997 0x3231302F2E2D2C2B, 0x3A39383736353433,
 2998 0x4241403F3E3D3C3B, 0x4A49484746454443, }},
2794 {{ 0x131211100F0E0D0C, 0x1B1A191817161514, 2999 {{ 0x131211100F0E0D0C, 0x1B1A191817161514,
2795 0x232221201F1E1D1C, 0x2B2A292827262524, }}, 3000 0x232221201F1E1D1C, 0x2B2A292827262524,
 3001 0x333231302F2E2D2C, 0x3B3A393837363534,
 3002 0x434241403F3E3D3C, 0x4B4A494847464544, }},
2796 {{ 0x14131211100F0E0D, 0x1C1B1A1918171615, 3003 {{ 0x14131211100F0E0D, 0x1C1B1A1918171615,
2797 0x24232221201F1E1D, 0x2C2B2A2928272625, }}, 3004 0x24232221201F1E1D, 0x2C2B2A2928272625,
 3005 0x34333231302F2E2D, 0x3C3B3A3938373635,
 3006 0x44434241403F3E3D, 0x4C4B4A4948474645, }},
2798 {{ 0x1514131211100F0E, 0x1D1C1B1A19181716, 3007 {{ 0x1514131211100F0E, 0x1D1C1B1A19181716,
2799 0x2524232221201F1E, 0x2D2C2B2A29282726, }}, 3008 0x2524232221201F1E, 0x2D2C2B2A29282726,
 3009 0x3534333231302F2E, 0x3D3C3B3A39383736,
 3010 0x4544434241403F3E, 0x4D4C4B4A49484746, }},
2800 {{ 0x161514131211100F, 0x1E1D1C1B1A191817, 3011 {{ 0x161514131211100F, 0x1E1D1C1B1A191817,
2801 0x262524232221201F, 0x2E2D2C2B2A292827, }}, 3012 0x262524232221201F, 0x2E2D2C2B2A292827,
 3013 0x363534333231302F, 0x3E3D3C3B3A393837,
 3014 0x464544434241403F, 0x4E4D4C4B4A494847, }},
 3015 {{ 0x1716151413121110, 0x1F1E1D1C1B1A1918,
 3016 0x2726252423222120, 0x2F2E2D2C2B2A2928,
 3017 0x3736353433323130, 0x3F3E3D3C3B3A3938,
 3018 0x4746454443424140, 0x4F4E4D4C4B4A4948, }},
 3019 {{ 0x1817161514131211, 0x201F1E1D1C1B1A19,
 3020 0x2827262524232221, 0x302F2E2D2C2B2A29,
 3021 0x3837363534333231, 0x403F3E3D3C3B3A39,
 3022 0x4847464544434241, 0x504F4E4D4C4B4A49, }},
 3023 {{ 0x1918171615141312, 0x21201F1E1D1C1B1A,
 3024 0x2928272625242322, 0x31302F2E2D2C2B2A,
 3025 0x3938373635343332, 0x41403F3E3D3C3B3A,
 3026 0x4948474645444342, 0x51504F4E4D4C4B4A, }},
 3027 {{ 0x1A19181716151413, 0x2221201F1E1D1C1B,
 3028 0x2A29282726252423, 0x3231302F2E2D2C2B,
 3029 0x3A39383736353433, 0x4241403F3E3D3C3B,
 3030 0x4A49484746454443, 0x5251504F4E4D4C4B, }},
 3031 {{ 0x1B1A191817161514, 0x232221201F1E1D1C,
 3032 0x2B2A292827262524, 0x333231302F2E2D2C,
 3033 0x3B3A393837363534, 0x434241403F3E3D3C,
 3034 0x4B4A494847464544, 0x535251504F4E4D4C, }},
 3035 {{ 0x1C1B1A1918171615, 0x24232221201F1E1D,
 3036 0x2C2B2A2928272625, 0x34333231302F2E2D,
 3037 0x3C3B3A3938373635, 0x44434241403F3E3D,
 3038 0x4C4B4A4948474645, 0x54535251504F4E4D, }},
 3039 {{ 0x1D1C1B1A19181716, 0x2524232221201F1E,
 3040 0x2D2C2B2A29282726, 0x3534333231302F2E,
 3041 0x3D3C3B3A39383736, 0x4544434241403F3E,
 3042 0x4D4C4B4A49484746, 0x5554535251504F4E, }},
 3043 {{ 0x1E1D1C1B1A191817, 0x262524232221201F,
 3044 0x2E2D2C2B2A292827, 0x363534333231302F,
 3045 0x3E3D3C3B3A393837, 0x464544434241403F,
 3046 0x4E4D4C4B4A494847, 0x565554535251504F, }},
 3047 {{ 0x1F1E1D1C1B1A1918, 0x2726252423222120,
 3048 0x2F2E2D2C2B2A2928, 0x3736353433323130,
 3049 0x3F3E3D3C3B3A3938, 0x4746454443424140,
 3050 0x4F4E4D4C4B4A4948, 0x5756555453525150, }},
 3051 {{ 0x201F1E1D1C1B1A19, 0x2827262524232221,
 3052 0x302F2E2D2C2B2A29, 0x3837363534333231,
 3053 0x403F3E3D3C3B3A39, 0x4847464544434241,
 3054 0x504F4E4D4C4B4A49, 0x5857565554535251, }},
 3055 {{ 0x21201F1E1D1C1B1A, 0x2928272625242322,
 3056 0x31302F2E2D2C2B2A, 0x3938373635343332,
 3057 0x41403F3E3D3C3B3A, 0x4948474645444342,
 3058 0x51504F4E4D4C4B4A, 0x5958575655545352, }},
 3059 {{ 0x2221201F1E1D1C1B, 0x2A29282726252423,
 3060 0x3231302F2E2D2C2B, 0x3A39383736353433,
 3061 0x4241403F3E3D3C3B, 0x4A49484746454443,
 3062 0x5251504F4E4D4C4B, 0x5A59585756555453, }},
 3063 {{ 0x232221201F1E1D1C, 0x2B2A292827262524,
 3064 0x333231302F2E2D2C, 0x3B3A393837363534,
 3065 0x434241403F3E3D3C, 0x4B4A494847464544,
 3066 0x535251504F4E4D4C, 0x5B5A595857565554, }},
 3067 {{ 0x24232221201F1E1D, 0x2C2B2A2928272625,
 3068 0x34333231302F2E2D, 0x3C3B3A3938373635,
 3069 0x44434241403F3E3D, 0x4C4B4A4948474645,
 3070 0x54535251504F4E4D, 0x5C5B5A5958575655, }},
 3071 {{ 0x2524232221201F1E, 0x2D2C2B2A29282726,
 3072 0x3534333231302F2E, 0x3D3C3B3A39383736,
 3073 0x4544434241403F3E, 0x4D4C4B4A49484746,
 3074 0x5554535251504F4E, 0x5D5C5B5A59585756, }},
 3075 {{ 0x262524232221201F, 0x2E2D2C2B2A292827,
 3076 0x363534333231302F, 0x3E3D3C3B3A393837,
 3077 0x464544434241403F, 0x4E4D4C4B4A494847,
 3078 0x565554535251504F, 0x5E5D5C5B5A595857, }},
 3079 /* k0..k7 */
 3080 {{ 0x2726252423222120, 0x2F2E2D2C2B2A2928,
 3081 0x3736353433323130, 0x3F3E3D3C3B3A3938,
 3082 0x4746454443424140, 0x4F4E4D4C4B4A4948,
 3083 0x5756555453525150, 0x5F5E5D5C5B5A5958, }},
2802 }; 3084 };
2803 3085
2804 const struct x86_test_fpu_registers expected_fpu = { 3086 const struct x86_test_fpu_registers expected_fpu = {
2805 .st = { 3087 .st = {
2806 {0x8000000000000000, 0x4000}, /* +2.0 */ 3088 {0x8000000000000000, 0x4000}, /* +2.0 */
2807 {0x3f00000000000000, 0x0000}, /* 1.654785e-4932 */ 3089 {0x3f00000000000000, 0x0000}, /* 1.654785e-4932 */
2808 {0x0000000000000000, 0x0000}, /* +0 */ 3090 {0x0000000000000000, 0x0000}, /* +0 */
2809 {0x0000000000000000, 0x8000}, /* -0 */ 3091 {0x0000000000000000, 0x8000}, /* -0 */
2810 {0x8000000000000000, 0x7fff}, /* +inf */ 3092 {0x8000000000000000, 0x7fff}, /* +inf */
2811 {0x8000000000000000, 0xffff}, /* -inf */ 3093 {0x8000000000000000, 0xffff}, /* -inf */
2812 {0xc000000000000000, 0xffff}, /* nan */ 3094 {0xc000000000000000, 0xffff}, /* nan */
2813 /* st(7) will be freed to test tag word better */ 3095 /* st(7) will be freed to test tag word better */
2814 {0x0000000000000000, 0x0000}, /* +0 */ 3096 {0x0000000000000000, 0x0000}, /* +0 */
@@ -2855,77 +3137,89 @@ x86_register_test(enum x86_test_regset r @@ -2855,77 +3137,89 @@ x86_register_test(enum x86_test_regset r
2855 case GPREGS_32: 3137 case GPREGS_32:
2856 case GPREGS_32_EBP_ESP: 3138 case GPREGS_32_EBP_ESP:
2857 need_32 = true; 3139 need_32 = true;
2858 break; 3140 break;
2859 case GPREGS_64: 3141 case GPREGS_64:
2860 case GPREGS_64_R8: 3142 case GPREGS_64_R8:
2861 need_64 = true; 3143 need_64 = true;
2862 break; 3144 break;
2863 case FPREGS_FPU: 3145 case FPREGS_FPU:
2864 break; 3146 break;
2865 case FPREGS_MM: 3147 case FPREGS_MM:
2866 case FPREGS_XMM: 3148 case FPREGS_XMM:
2867 case FPREGS_YMM: 3149 case FPREGS_YMM:
 3150 case FPREGS_ZMM:
2868 need_cpuid = true; 3151 need_cpuid = true;
2869 break; 3152 break;
2870 } 3153 }
2871 3154
2872 if (need_32) { 3155 if (need_32) {
2873#if defined(__x86_64__) 3156#if defined(__x86_64__)
2874 atf_tc_skip("Test requires 32-bit mode"); 3157 atf_tc_skip("Test requires 32-bit mode");
2875#endif 3158#endif
2876 } 3159 }
2877 if (need_64) { 3160 if (need_64) {
2878#if defined(__i386__) 3161#if defined(__i386__)
2879 atf_tc_skip("Test requires 64-bit mode"); 3162 atf_tc_skip("Test requires 64-bit mode");
2880#endif 3163#endif
2881 } 3164 }
2882 3165
2883 if (need_cpuid) { 3166 if (need_cpuid) {
2884 /* verify whether needed instruction sets are supported here */ 3167 /* verify whether needed instruction sets are supported here */
2885 unsigned int eax, ebx, ecx, edx; 3168 unsigned int eax, ebx, ecx, edx;
 3169 unsigned int eax7, ebx7, ecx7, edx7;
2886 3170
2887 DPRINTF("Before invoking cpuid\n"); 3171 DPRINTF("Before invoking cpuid\n");
2888 if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx)) 3172 if (!__get_cpuid(1, &eax, &ebx, &ecx, &edx))
2889 atf_tc_skip("CPUID is not supported by the CPU"); 3173 atf_tc_skip("CPUID is not supported by the CPU");
2890 3174
2891 DPRINTF("cpuid: ECX = %08x, EDX = %08xd\n", ecx, edx); 3175 DPRINTF("cpuid[eax=1]: ECX = %08x, EDX = %08xd\n", ecx, edx);
2892 3176
2893 switch (regs) { 3177 switch (regs) {
 3178 case FPREGS_ZMM:
 3179 /* ZMM is in EAX=7, ECX=0 */
 3180 if (!__get_cpuid_count(7, 0, &eax7, &ebx7, &ecx7, &edx7))
 3181 atf_tc_skip(
 3182 "AVX512F is not supported by the CPU");
 3183 DPRINTF("cpuid[eax=7,ecx=0]: EBX = %08x\n", ebx7);
 3184 if (!(ebx7 & bit_AVX512F))
 3185 atf_tc_skip(
 3186 "AVX512F is not supported by the CPU");
 3187 /*FALLTHROUGH*/
2894 case FPREGS_YMM: 3188 case FPREGS_YMM:
2895 if (!(ecx & bit_AVX)) 3189 if (!(ecx & bit_AVX))
2896 atf_tc_skip("AVX is not supported by the CPU"); 3190 atf_tc_skip("AVX is not supported by the CPU");
2897 /*FALLTHROUGH*/ 3191 /*FALLTHROUGH*/
2898 case FPREGS_XMM: 3192 case FPREGS_XMM:
2899 if (!(edx & bit_SSE)) 3193 if (!(edx & bit_SSE))
2900 atf_tc_skip("SSE is not supported by the CPU"); 3194 atf_tc_skip("SSE is not supported by the CPU");
2901 break; 3195 break;
2902 case FPREGS_MM: 3196 case FPREGS_MM:
2903 if (!(edx & bit_MMX)) 3197 if (!(edx & bit_MMX))
2904 atf_tc_skip("MMX is not supported by the CPU"); 3198 atf_tc_skip("MMX is not supported by the CPU");
2905 break; 3199 break;
2906 case GPREGS_32: 3200 case GPREGS_32:
2907 case GPREGS_32_EBP_ESP: 3201 case GPREGS_32_EBP_ESP:
2908 case GPREGS_64: 3202 case GPREGS_64:
2909 case GPREGS_64_R8: 3203 case GPREGS_64_R8:
2910 case FPREGS_FPU: 3204 case FPREGS_FPU:
2911 __unreachable(); 3205 __unreachable();
2912 } 3206 }
2913 } 3207 }
2914 3208
2915 DPRINTF("Before forking process PID=%d\n", getpid()); 3209 DPRINTF("Before forking process PID=%d\n", getpid());
2916 SYSCALL_REQUIRE((child = fork()) != -1); 3210 SYSCALL_REQUIRE((child = fork()) != -1);
2917 if (child == 0) { 3211 if (child == 0) {
2918 union x86_test_register vals[16] __aligned(32); 3212 union x86_test_register vals[__arraycount(expected)] __aligned(64);
2919 struct x86_test_fpu_registers vals_fpu; 3213 struct x86_test_fpu_registers vals_fpu;
2920 3214
2921 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid()); 3215 DPRINTF("Before calling PT_TRACE_ME from child %d\n", getpid());
2922 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1); 3216 FORKEE_ASSERT(ptrace(PT_TRACE_ME, 0, NULL, 0) != -1);
2923 3217
2924 DPRINTF("Before running assembly from child\n"); 3218 DPRINTF("Before running assembly from child\n");
2925 switch (regmode) { 3219 switch (regmode) {
2926 case TEST_GETREGS: 3220 case TEST_GETREGS:
2927 case TEST_COREDUMP: 3221 case TEST_COREDUMP:
2928 switch (regs) { 3222 switch (regs) {
2929 case GPREGS_32: 3223 case GPREGS_32:
2930 set_gp32_regs(expected); 3224 set_gp32_regs(expected);
2931 break; 3225 break;
@@ -2940,26 +3234,29 @@ x86_register_test(enum x86_test_regset r @@ -2940,26 +3234,29 @@ x86_register_test(enum x86_test_regset r
2940 break; 3234 break;
2941 case FPREGS_FPU: 3235 case FPREGS_FPU:
2942 set_fpu_regs(&expected_fpu); 3236 set_fpu_regs(&expected_fpu);
2943 break; 3237 break;
2944 case FPREGS_MM: 3238 case FPREGS_MM:
2945 set_mm_regs(expected); 3239 set_mm_regs(expected);
2946 break; 3240 break;
2947 case FPREGS_XMM: 3241 case FPREGS_XMM:
2948 set_xmm_regs(expected); 3242 set_xmm_regs(expected);
2949 break; 3243 break;
2950 case FPREGS_YMM: 3244 case FPREGS_YMM:
2951 set_ymm_regs(expected); 3245 set_ymm_regs(expected);
2952 break; 3246 break;
 3247 case FPREGS_ZMM:
 3248 set_zmm_regs(expected);
 3249 break;
2953 } 3250 }
2954 break; 3251 break;
2955 case TEST_SETREGS: 3252 case TEST_SETREGS:
2956 switch (regs) { 3253 switch (regs) {
2957 case GPREGS_32: 3254 case GPREGS_32:
2958 get_gp32_regs(vals); 3255 get_gp32_regs(vals);
2959 break; 3256 break;
2960 case GPREGS_32_EBP_ESP: 3257 case GPREGS_32_EBP_ESP:
2961 get_gp32_ebp_esp_regs(vals); 3258 get_gp32_ebp_esp_regs(vals);
2962 break; 3259 break;
2963 case GPREGS_64: 3260 case GPREGS_64:
2964 get_gp64_regs(vals); 3261 get_gp64_regs(vals);
2965 break; 3262 break;
@@ -2968,26 +3265,29 @@ x86_register_test(enum x86_test_regset r @@ -2968,26 +3265,29 @@ x86_register_test(enum x86_test_regset r
2968 break; 3265 break;
2969 case FPREGS_FPU: 3266 case FPREGS_FPU:
2970 get_fpu_regs(&vals_fpu); 3267 get_fpu_regs(&vals_fpu);
2971 break; 3268 break;
2972 case FPREGS_MM: 3269 case FPREGS_MM:
2973 get_mm_regs(vals); 3270 get_mm_regs(vals);
2974 break; 3271 break;
2975 case FPREGS_XMM: 3272 case FPREGS_XMM:
2976 get_xmm_regs(vals); 3273 get_xmm_regs(vals);
2977 break; 3274 break;
2978 case FPREGS_YMM: 3275 case FPREGS_YMM:
2979 get_ymm_regs(vals); 3276 get_ymm_regs(vals);
2980 break; 3277 break;
 3278 case FPREGS_ZMM:
 3279 get_zmm_regs(vals);
 3280 break;
2981 } 3281 }
2982 3282
2983 DPRINTF("Before comparing results\n"); 3283 DPRINTF("Before comparing results\n");
2984 switch (regs) { 3284 switch (regs) {
2985 case GPREGS_32: 3285 case GPREGS_32:
2986 FORKEE_ASSERT(!memcmp(&vals[5].u32, 3286 FORKEE_ASSERT(!memcmp(&vals[5].u32,
2987 &expected[5].u32, sizeof(vals->u32))); 3287 &expected[5].u32, sizeof(vals->u32)));
2988 FORKEE_ASSERT(!memcmp(&vals[4].u32, 3288 FORKEE_ASSERT(!memcmp(&vals[4].u32,
2989 &expected[4].u32, sizeof(vals->u32))); 3289 &expected[4].u32, sizeof(vals->u32)));
2990 FORKEE_ASSERT(!memcmp(&vals[3].u32, 3290 FORKEE_ASSERT(!memcmp(&vals[3].u32,
2991 &expected[3].u32, sizeof(vals->u32))); 3291 &expected[3].u32, sizeof(vals->u32)));
2992 FORKEE_ASSERT(!memcmp(&vals[2].u32, 3292 FORKEE_ASSERT(!memcmp(&vals[2].u32,
2993 &expected[2].u32, sizeof(vals->u32))); 3293 &expected[2].u32, sizeof(vals->u32)));
@@ -3121,46 +3421,129 @@ x86_register_test(enum x86_test_regset r @@ -3121,46 +3421,129 @@ x86_register_test(enum x86_test_regset r
3121 &expected[10].ymm, sizeof(vals->ymm))); 3421 &expected[10].ymm, sizeof(vals->ymm)));
3122 FORKEE_ASSERT(!memcmp(&vals[11].ymm, 3422 FORKEE_ASSERT(!memcmp(&vals[11].ymm,
3123 &expected[11].ymm, sizeof(vals->ymm))); 3423 &expected[11].ymm, sizeof(vals->ymm)));
3124 FORKEE_ASSERT(!memcmp(&vals[12].ymm, 3424 FORKEE_ASSERT(!memcmp(&vals[12].ymm,
3125 &expected[12].ymm, sizeof(vals->ymm))); 3425 &expected[12].ymm, sizeof(vals->ymm)));
3126 FORKEE_ASSERT(!memcmp(&vals[13].ymm, 3426 FORKEE_ASSERT(!memcmp(&vals[13].ymm,
3127 &expected[13].ymm, sizeof(vals->ymm))); 3427 &expected[13].ymm, sizeof(vals->ymm)));
3128 FORKEE_ASSERT(!memcmp(&vals[14].ymm, 3428 FORKEE_ASSERT(!memcmp(&vals[14].ymm,
3129 &expected[14].ymm, sizeof(vals->ymm))); 3429 &expected[14].ymm, sizeof(vals->ymm)));
3130 FORKEE_ASSERT(!memcmp(&vals[15].ymm, 3430 FORKEE_ASSERT(!memcmp(&vals[15].ymm,
3131 &expected[15].ymm, sizeof(vals->ymm))); 3431 &expected[15].ymm, sizeof(vals->ymm)));
3132#endif 3432#endif
3133 break; 3433 break;
 3434 case FPREGS_ZMM:
 3435 FORKEE_ASSERT(!memcmp(&vals[0].zmm,
 3436 &expected[0].zmm, sizeof(vals->zmm)));
 3437 FORKEE_ASSERT(!memcmp(&vals[1].zmm,
 3438 &expected[1].zmm, sizeof(vals->zmm)));
 3439 FORKEE_ASSERT(!memcmp(&vals[2].zmm,
 3440 &expected[2].zmm, sizeof(vals->zmm)));
 3441 FORKEE_ASSERT(!memcmp(&vals[3].zmm,
 3442 &expected[3].zmm, sizeof(vals->zmm)));
 3443 FORKEE_ASSERT(!memcmp(&vals[4].zmm,
 3444 &expected[4].zmm, sizeof(vals->zmm)));
 3445 FORKEE_ASSERT(!memcmp(&vals[5].zmm,
 3446 &expected[5].zmm, sizeof(vals->zmm)));
 3447 FORKEE_ASSERT(!memcmp(&vals[6].zmm,
 3448 &expected[6].zmm, sizeof(vals->zmm)));
 3449 FORKEE_ASSERT(!memcmp(&vals[7].zmm,
 3450 &expected[7].zmm, sizeof(vals->zmm)));
 3451#if defined(__x86_64__)
 3452 FORKEE_ASSERT(!memcmp(&vals[8].zmm,
 3453 &expected[8].zmm, sizeof(vals->zmm)));
 3454 FORKEE_ASSERT(!memcmp(&vals[9].zmm,
 3455 &expected[9].zmm, sizeof(vals->zmm)));
 3456 FORKEE_ASSERT(!memcmp(&vals[10].zmm,
 3457 &expected[10].zmm, sizeof(vals->zmm)));
 3458 FORKEE_ASSERT(!memcmp(&vals[11].zmm,
 3459 &expected[11].zmm, sizeof(vals->zmm)));
 3460 FORKEE_ASSERT(!memcmp(&vals[12].zmm,
 3461 &expected[12].zmm, sizeof(vals->zmm)));
 3462 FORKEE_ASSERT(!memcmp(&vals[13].zmm,
 3463 &expected[13].zmm, sizeof(vals->zmm)));
 3464 FORKEE_ASSERT(!memcmp(&vals[14].zmm,
 3465 &expected[14].zmm, sizeof(vals->zmm)));
 3466 FORKEE_ASSERT(!memcmp(&vals[15].zmm,
 3467 &expected[15].zmm, sizeof(vals->zmm)));
 3468 FORKEE_ASSERT(!memcmp(&vals[16].zmm,
 3469 &expected[16].zmm, sizeof(vals->zmm)));
 3470 FORKEE_ASSERT(!memcmp(&vals[17].zmm,
 3471 &expected[17].zmm, sizeof(vals->zmm)));
 3472 FORKEE_ASSERT(!memcmp(&vals[18].zmm,
 3473 &expected[18].zmm, sizeof(vals->zmm)));
 3474 FORKEE_ASSERT(!memcmp(&vals[19].zmm,
 3475 &expected[19].zmm, sizeof(vals->zmm)));
 3476 FORKEE_ASSERT(!memcmp(&vals[20].zmm,
 3477 &expected[20].zmm, sizeof(vals->zmm)));
 3478 FORKEE_ASSERT(!memcmp(&vals[21].zmm,
 3479 &expected[21].zmm, sizeof(vals->zmm)));
 3480 FORKEE_ASSERT(!memcmp(&vals[22].zmm,
 3481 &expected[22].zmm, sizeof(vals->zmm)));
 3482 FORKEE_ASSERT(!memcmp(&vals[23].zmm,
 3483 &expected[23].zmm, sizeof(vals->zmm)));
 3484 FORKEE_ASSERT(!memcmp(&vals[24].zmm,
 3485 &expected[24].zmm, sizeof(vals->zmm)));
 3486 FORKEE_ASSERT(!memcmp(&vals[25].zmm,
 3487 &expected[25].zmm, sizeof(vals->zmm)));
 3488 FORKEE_ASSERT(!memcmp(&vals[26].zmm,
 3489 &expected[26].zmm, sizeof(vals->zmm)));
 3490 FORKEE_ASSERT(!memcmp(&vals[27].zmm,
 3491 &expected[27].zmm, sizeof(vals->zmm)));
 3492 FORKEE_ASSERT(!memcmp(&vals[28].zmm,
 3493 &expected[28].zmm, sizeof(vals->zmm)));
 3494 FORKEE_ASSERT(!memcmp(&vals[29].zmm,
 3495 &expected[29].zmm, sizeof(vals->zmm)));
 3496 FORKEE_ASSERT(!memcmp(&vals[30].zmm,
 3497 &expected[30].zmm, sizeof(vals->zmm)));
 3498 FORKEE_ASSERT(!memcmp(&vals[31].zmm,
 3499 &expected[31].zmm, sizeof(vals->zmm)));
 3500#endif
 3501 /* k0..k7 */
 3502 FORKEE_ASSERT(vals[32].zmm.a == expected[32].zmm.a);
 3503 FORKEE_ASSERT(vals[32].zmm.b == expected[32].zmm.b);
 3504 FORKEE_ASSERT(vals[32].zmm.c == expected[32].zmm.c);
 3505 FORKEE_ASSERT(vals[32].zmm.d == expected[32].zmm.d);
 3506 FORKEE_ASSERT(vals[32].zmm.e == expected[32].zmm.e);
 3507 FORKEE_ASSERT(vals[32].zmm.f == expected[32].zmm.f);
 3508 FORKEE_ASSERT(vals[32].zmm.g == expected[32].zmm.g);
 3509 FORKEE_ASSERT(vals[32].zmm.h == expected[32].zmm.h);
 3510 break;
3134 } 3511 }
3135 break; 3512 break;
3136 } 3513 }
3137 3514
3138 DPRINTF("Before exiting of the child process\n"); 3515 DPRINTF("Before exiting of the child process\n");
3139 _exit(exitval); 3516 _exit(exitval);
3140 } 3517 }
3141 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child); 3518 DPRINTF("Parent process PID=%d, child's PID=%d\n", getpid(), child);
3142 3519
3143 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME); 3520 DPRINTF("Before calling %s() for the child\n", TWAIT_FNAME);
3144 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child); 3521 TWAIT_REQUIRE_SUCCESS(wpid = TWAIT_GENERIC(child, &status, 0), child);
3145 3522
3146 validate_status_stopped(status, sigval); 3523 validate_status_stopped(status, sigval);
3147 3524
3148 if (regset == TEST_XSTATE) { 3525 if (regset == TEST_XSTATE) {
3149 switch (regs) { 3526 switch (regs) {
3150 case FPREGS_FPU: 3527 case FPREGS_FPU:
3151 case FPREGS_MM: 3528 case FPREGS_MM:
3152 xst_flags |= XCR0_X87; 3529 xst_flags |= XCR0_X87;
3153 break; 3530 break;
 3531 case FPREGS_ZMM:
 3532 xst_flags |= XCR0_Opmask | XCR0_ZMM_Hi256;
 3533#if defined(__x86_64__)
 3534 xst_flags |= XCR0_Hi16_ZMM;
 3535#endif
 3536 /*FALLTHROUGH*/
3154 case FPREGS_YMM: 3537 case FPREGS_YMM:
3155 xst_flags |= XCR0_YMM_Hi128; 3538 xst_flags |= XCR0_YMM_Hi128;
3156 /*FALLTHROUGH*/ 3539 /*FALLTHROUGH*/
3157 case FPREGS_XMM: 3540 case FPREGS_XMM:
3158 xst_flags |= XCR0_SSE; 3541 xst_flags |= XCR0_SSE;
3159 break; 3542 break;
3160 case GPREGS_32: 3543 case GPREGS_32:
3161 case GPREGS_32_EBP_ESP: 3544 case GPREGS_32_EBP_ESP:
3162 case GPREGS_64: 3545 case GPREGS_64:
3163 case GPREGS_64_R8: 3546 case GPREGS_64_R8:
3164 __unreachable(); 3547 __unreachable();
3165 break; 3548 break;
3166 } 3549 }
@@ -3417,26 +3800,105 @@ x86_register_test(enum x86_test_regset r @@ -3417,26 +3800,105 @@ x86_register_test(enum x86_test_regset r
3417 ATF_CHECK_EQ(ST_EXP(7), expected_fpu.st[7].sign_exp); 3800 ATF_CHECK_EQ(ST_EXP(7), expected_fpu.st[7].sign_exp);
3418 ATF_CHECK_EQ(ST_MAN(7), expected_fpu.st[7].mantissa); 3801 ATF_CHECK_EQ(ST_MAN(7), expected_fpu.st[7].mantissa);
3419 break; 3802 break;
3420 case FPREGS_MM: 3803 case FPREGS_MM:
3421 ATF_CHECK_EQ(ST_MAN(0), expected[0].u64); 3804 ATF_CHECK_EQ(ST_MAN(0), expected[0].u64);
3422 ATF_CHECK_EQ(ST_MAN(1), expected[1].u64); 3805 ATF_CHECK_EQ(ST_MAN(1), expected[1].u64);
3423 ATF_CHECK_EQ(ST_MAN(2), expected[2].u64); 3806 ATF_CHECK_EQ(ST_MAN(2), expected[2].u64);
3424 ATF_CHECK_EQ(ST_MAN(3), expected[3].u64); 3807 ATF_CHECK_EQ(ST_MAN(3), expected[3].u64);
3425 ATF_CHECK_EQ(ST_MAN(4), expected[4].u64); 3808 ATF_CHECK_EQ(ST_MAN(4), expected[4].u64);
3426 ATF_CHECK_EQ(ST_MAN(5), expected[5].u64); 3809 ATF_CHECK_EQ(ST_MAN(5), expected[5].u64);
3427 ATF_CHECK_EQ(ST_MAN(6), expected[6].u64); 3810 ATF_CHECK_EQ(ST_MAN(6), expected[6].u64);
3428 ATF_CHECK_EQ(ST_MAN(7), expected[7].u64); 3811 ATF_CHECK_EQ(ST_MAN(7), expected[7].u64);
3429 break; 3812 break;
 3813 case FPREGS_ZMM:
 3814 /* zmm0..zmm15 are split between xmm, ymm_hi128 and zmm_hi256 */
 3815 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[0],
 3816 &expected[0].zmm.e, sizeof(expected->zmm)/2));
 3817 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[1],
 3818 &expected[1].zmm.e, sizeof(expected->zmm)/2));
 3819 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[2],
 3820 &expected[2].zmm.e, sizeof(expected->zmm)/2));
 3821 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[3],
 3822 &expected[3].zmm.e, sizeof(expected->zmm)/2));
 3823 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[4],
 3824 &expected[4].zmm.e, sizeof(expected->zmm)/2));
 3825 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[5],
 3826 &expected[5].zmm.e, sizeof(expected->zmm)/2));
 3827 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[6],
 3828 &expected[6].zmm.e, sizeof(expected->zmm)/2));
 3829 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[7],
 3830 &expected[7].zmm.e, sizeof(expected->zmm)/2));
 3831#if defined(__x86_64__)
 3832 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[8],
 3833 &expected[8].zmm.e, sizeof(expected->zmm)/2));
 3834 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[9],
 3835 &expected[9].zmm.e, sizeof(expected->zmm)/2));
 3836 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[10],
 3837 &expected[10].zmm.e, sizeof(expected->zmm)/2));
 3838 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[11],
 3839 &expected[11].zmm.e, sizeof(expected->zmm)/2));
 3840 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[12],
 3841 &expected[12].zmm.e, sizeof(expected->zmm)/2));
 3842 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[13],
 3843 &expected[13].zmm.e, sizeof(expected->zmm)/2));
 3844 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[14],
 3845 &expected[14].zmm.e, sizeof(expected->zmm)/2));
 3846 ATF_CHECK(!memcmp(&xst.xs_zmm_hi256.xs_zmm[15],
 3847 &expected[15].zmm.e, sizeof(expected->zmm)/2));
 3848 /* zmm16..zmm31 are stored as a whole */
 3849 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[0],
 3850 &expected[16].zmm, sizeof(expected->zmm)));
 3851 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[1],
 3852 &expected[17].zmm, sizeof(expected->zmm)));
 3853 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[2],
 3854 &expected[18].zmm, sizeof(expected->zmm)));
 3855 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[3],
 3856 &expected[19].zmm, sizeof(expected->zmm)));
 3857 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[4],
 3858 &expected[20].zmm, sizeof(expected->zmm)));
 3859 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[5],
 3860 &expected[21].zmm, sizeof(expected->zmm)));
 3861 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[6],
 3862 &expected[22].zmm, sizeof(expected->zmm)));
 3863 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[7],
 3864 &expected[23].zmm, sizeof(expected->zmm)));
 3865 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[8],
 3866 &expected[24].zmm, sizeof(expected->zmm)));
 3867 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[9],
 3868 &expected[25].zmm, sizeof(expected->zmm)));
 3869 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[10],
 3870 &expected[26].zmm, sizeof(expected->zmm)));
 3871 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[11],
 3872 &expected[27].zmm, sizeof(expected->zmm)));
 3873 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[12],
 3874 &expected[28].zmm, sizeof(expected->zmm)));
 3875 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[13],
 3876 &expected[29].zmm, sizeof(expected->zmm)));
 3877 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[14],
 3878 &expected[30].zmm, sizeof(expected->zmm)));
 3879 ATF_CHECK(!memcmp(&xst.xs_hi16_zmm.xs_hi16_zmm[15],
 3880 &expected[31].zmm, sizeof(expected->zmm)));
 3881#endif
 3882 /* k0..k7 */
 3883 ATF_CHECK(xst.xs_opmask.xs_k[0] == expected[32].zmm.a);
 3884 ATF_CHECK(xst.xs_opmask.xs_k[1] == expected[32].zmm.b);
 3885 ATF_CHECK(xst.xs_opmask.xs_k[2] == expected[32].zmm.c);
 3886 ATF_CHECK(xst.xs_opmask.xs_k[3] == expected[32].zmm.d);
 3887 ATF_CHECK(xst.xs_opmask.xs_k[4] == expected[32].zmm.e);
 3888 ATF_CHECK(xst.xs_opmask.xs_k[5] == expected[32].zmm.f);
 3889 ATF_CHECK(xst.xs_opmask.xs_k[6] == expected[32].zmm.g);
 3890 ATF_CHECK(xst.xs_opmask.xs_k[7] == expected[32].zmm.h);
 3891 /*FALLTHROUGH*/
3430 case FPREGS_YMM: 3892 case FPREGS_YMM:
3431 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[0], 3893 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[0],
3432 &expected[0].ymm.c, sizeof(expected->ymm)/2)); 3894 &expected[0].ymm.c, sizeof(expected->ymm)/2));
3433 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[1], 3895 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[1],
3434 &expected[1].ymm.c, sizeof(expected->ymm)/2)); 3896 &expected[1].ymm.c, sizeof(expected->ymm)/2));
3435 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[2], 3897 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[2],
3436 &expected[2].ymm.c, sizeof(expected->ymm)/2)); 3898 &expected[2].ymm.c, sizeof(expected->ymm)/2));
3437 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[3], 3899 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[3],
3438 &expected[3].ymm.c, sizeof(expected->ymm)/2)); 3900 &expected[3].ymm.c, sizeof(expected->ymm)/2));
3439 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[4], 3901 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[4],
3440 &expected[4].ymm.c, sizeof(expected->ymm)/2)); 3902 &expected[4].ymm.c, sizeof(expected->ymm)/2));
3441 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[5], 3903 ATF_CHECK(!memcmp(&xst.xs_ymm_hi128.xs_ymm[5],
3442 &expected[5].ymm.c, sizeof(expected->ymm)/2)); 3904 &expected[5].ymm.c, sizeof(expected->ymm)/2));
@@ -3582,26 +4044,105 @@ x86_register_test(enum x86_test_regset r @@ -3582,26 +4044,105 @@ x86_register_test(enum x86_test_regset r
3582 ST_EXP(7) = expected_fpu.st[7].sign_exp; 4044 ST_EXP(7) = expected_fpu.st[7].sign_exp;
3583 ST_MAN(7) = expected_fpu.st[7].mantissa; 4045 ST_MAN(7) = expected_fpu.st[7].mantissa;
3584 break; 4046 break;
3585 case FPREGS_MM: 4047 case FPREGS_MM:
3586 ST_MAN(0) = expected[0].u64; 4048 ST_MAN(0) = expected[0].u64;
3587 ST_MAN(1) = expected[1].u64; 4049 ST_MAN(1) = expected[1].u64;
3588 ST_MAN(2) = expected[2].u64; 4050 ST_MAN(2) = expected[2].u64;
3589 ST_MAN(3) = expected[3].u64; 4051 ST_MAN(3) = expected[3].u64;
3590 ST_MAN(4) = expected[4].u64; 4052 ST_MAN(4) = expected[4].u64;
3591 ST_MAN(5) = expected[5].u64; 4053 ST_MAN(5) = expected[5].u64;
3592 ST_MAN(6) = expected[6].u64; 4054 ST_MAN(6) = expected[6].u64;
3593 ST_MAN(7) = expected[7].u64; 4055 ST_MAN(7) = expected[7].u64;
3594 break; 4056 break;
 4057 case FPREGS_ZMM:
 4058 /* zmm0..zmm15 are split between xmm, ymm_hi128, zmm_hi256 */
 4059 memcpy(&xst.xs_zmm_hi256.xs_zmm[0],
 4060 &expected[0].zmm.e, sizeof(expected->zmm)/2);
 4061 memcpy(&xst.xs_zmm_hi256.xs_zmm[1],
 4062 &expected[1].zmm.e, sizeof(expected->zmm)/2);
 4063 memcpy(&xst.xs_zmm_hi256.xs_zmm[2],
 4064 &expected[2].zmm.e, sizeof(expected->zmm)/2);
 4065 memcpy(&xst.xs_zmm_hi256.xs_zmm[3],
 4066 &expected[3].zmm.e, sizeof(expected->zmm)/2);
 4067 memcpy(&xst.xs_zmm_hi256.xs_zmm[4],
 4068 &expected[4].zmm.e, sizeof(expected->zmm)/2);
 4069 memcpy(&xst.xs_zmm_hi256.xs_zmm[5],
 4070 &expected[5].zmm.e, sizeof(expected->zmm)/2);
 4071 memcpy(&xst.xs_zmm_hi256.xs_zmm[6],
 4072 &expected[6].zmm.e, sizeof(expected->zmm)/2);
 4073 memcpy(&xst.xs_zmm_hi256.xs_zmm[7],
 4074 &expected[7].zmm.e, sizeof(expected->zmm)/2);
 4075#if defined(__x86_64__)
 4076 memcpy(&xst.xs_zmm_hi256.xs_zmm[8],
 4077 &expected[8].zmm.e, sizeof(expected->zmm)/2);
 4078 memcpy(&xst.xs_zmm_hi256.xs_zmm[9],
 4079 &expected[9].zmm.e, sizeof(expected->zmm)/2);
 4080 memcpy(&xst.xs_zmm_hi256.xs_zmm[10],
 4081 &expected[10].zmm.e, sizeof(expected->zmm)/2);
 4082 memcpy(&xst.xs_zmm_hi256.xs_zmm[11],
 4083 &expected[11].zmm.e, sizeof(expected->zmm)/2);
 4084 memcpy(&xst.xs_zmm_hi256.xs_zmm[12],
 4085 &expected[12].zmm.e, sizeof(expected->zmm)/2);
 4086 memcpy(&xst.xs_zmm_hi256.xs_zmm[13],
 4087 &expected[13].zmm.e, sizeof(expected->zmm)/2);
 4088 memcpy(&xst.xs_zmm_hi256.xs_zmm[14],
 4089 &expected[14].zmm.e, sizeof(expected->zmm)/2);
 4090 memcpy(&xst.xs_zmm_hi256.xs_zmm[15],
 4091 &expected[15].zmm.e, sizeof(expected->zmm)/2);
 4092 /* zmm16..zmm31 are stored as a whole */
 4093 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[0],
 4094 &expected[16].zmm, sizeof(expected->zmm));
 4095 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[1],
 4096 &expected[17].zmm, sizeof(expected->zmm));
 4097 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[2],
 4098 &expected[18].zmm, sizeof(expected->zmm));
 4099 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[3],
 4100 &expected[19].zmm, sizeof(expected->zmm));
 4101 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[4],
 4102 &expected[20].zmm, sizeof(expected->zmm));
 4103 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[5],
 4104 &expected[21].zmm, sizeof(expected->zmm));
 4105 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[6],
 4106 &expected[22].zmm, sizeof(expected->zmm));
 4107 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[7],
 4108 &expected[23].zmm, sizeof(expected->zmm));
 4109 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[8],
 4110 &expected[24].zmm, sizeof(expected->zmm));
 4111 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[9],
 4112 &expected[25].zmm, sizeof(expected->zmm));
 4113 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[10],
 4114 &expected[26].zmm, sizeof(expected->zmm));
 4115 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[11],
 4116 &expected[27].zmm, sizeof(expected->zmm));
 4117 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[12],
 4118 &expected[28].zmm, sizeof(expected->zmm));
 4119 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[13],
 4120 &expected[29].zmm, sizeof(expected->zmm));
 4121 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[14],
 4122 &expected[30].zmm, sizeof(expected->zmm));
 4123 memcpy(&xst.xs_hi16_zmm.xs_hi16_zmm[15],
 4124 &expected[31].zmm, sizeof(expected->zmm));
 4125#endif
 4126 /* k0..k7 */
 4127 xst.xs_opmask.xs_k[0] = expected[32].zmm.a;
 4128 xst.xs_opmask.xs_k[1] = expected[32].zmm.b;
 4129 xst.xs_opmask.xs_k[2] = expected[32].zmm.c;
 4130 xst.xs_opmask.xs_k[3] = expected[32].zmm.d;
 4131 xst.xs_opmask.xs_k[4] = expected[32].zmm.e;
 4132 xst.xs_opmask.xs_k[5] = expected[32].zmm.f;
 4133 xst.xs_opmask.xs_k[6] = expected[32].zmm.g;
 4134 xst.xs_opmask.xs_k[7] = expected[32].zmm.h;
 4135 /*FALLTHROUGH*/
3595 case FPREGS_YMM: 4136 case FPREGS_YMM:
3596 memcpy(&xst.xs_ymm_hi128.xs_ymm[0], 4137 memcpy(&xst.xs_ymm_hi128.xs_ymm[0],
3597 &expected[0].ymm.c, sizeof(expected->ymm)/2); 4138 &expected[0].ymm.c, sizeof(expected->ymm)/2);
3598 memcpy(&xst.xs_ymm_hi128.xs_ymm[1], 4139 memcpy(&xst.xs_ymm_hi128.xs_ymm[1],
3599 &expected[1].ymm.c, sizeof(expected->ymm)/2); 4140 &expected[1].ymm.c, sizeof(expected->ymm)/2);
3600 memcpy(&xst.xs_ymm_hi128.xs_ymm[2], 4141 memcpy(&xst.xs_ymm_hi128.xs_ymm[2],
3601 &expected[2].ymm.c, sizeof(expected->ymm)/2); 4142 &expected[2].ymm.c, sizeof(expected->ymm)/2);
3602 memcpy(&xst.xs_ymm_hi128.xs_ymm[3], 4143 memcpy(&xst.xs_ymm_hi128.xs_ymm[3],
3603 &expected[3].ymm.c, sizeof(expected->ymm)/2); 4144 &expected[3].ymm.c, sizeof(expected->ymm)/2);
3604 memcpy(&xst.xs_ymm_hi128.xs_ymm[4], 4145 memcpy(&xst.xs_ymm_hi128.xs_ymm[4],
3605 &expected[4].ymm.c, sizeof(expected->ymm)/2); 4146 &expected[4].ymm.c, sizeof(expected->ymm)/2);
3606 memcpy(&xst.xs_ymm_hi128.xs_ymm[5], 4147 memcpy(&xst.xs_ymm_hi128.xs_ymm[5],
3607 &expected[5].ymm.c, sizeof(expected->ymm)/2); 4148 &expected[5].ymm.c, sizeof(expected->ymm)/2);
@@ -3799,26 +4340,35 @@ X86_REGISTER_TEST(x86_xstate_xmm_read, T @@ -3799,26 +4340,35 @@ X86_REGISTER_TEST(x86_xstate_xmm_read, T
3799X86_REGISTER_TEST(x86_xstate_xmm_write, TEST_XSTATE, FPREGS_XMM, TEST_SETREGS, 4340X86_REGISTER_TEST(x86_xstate_xmm_write, TEST_XSTATE, FPREGS_XMM, TEST_SETREGS,
3800 "Test writing xmm0..xmm15 (..xmm7 on i386) into debugged program " 4341 "Test writing xmm0..xmm15 (..xmm7 on i386) into debugged program "
3801 "via PT_SETXSTATE."); 4342 "via PT_SETXSTATE.");
3802X86_REGISTER_TEST(x86_xstate_xmm_core, TEST_XSTATE, FPREGS_XMM, TEST_COREDUMP, 4343X86_REGISTER_TEST(x86_xstate_xmm_core, TEST_XSTATE, FPREGS_XMM, TEST_COREDUMP,
3803 "Test reading xmm0..xmm15 (..xmm7 on i386) from coredump via XSTATE note."); 4344 "Test reading xmm0..xmm15 (..xmm7 on i386) from coredump via XSTATE note.");
3804X86_REGISTER_TEST(x86_xstate_ymm_read, TEST_XSTATE, FPREGS_YMM, TEST_GETREGS, 4345X86_REGISTER_TEST(x86_xstate_ymm_read, TEST_XSTATE, FPREGS_YMM, TEST_GETREGS,
3805 "Test reading ymm0..ymm15 (..ymm7 on i386) from debugged program " 4346 "Test reading ymm0..ymm15 (..ymm7 on i386) from debugged program "
3806 "via PT_GETXSTATE."); 4347 "via PT_GETXSTATE.");
3807X86_REGISTER_TEST(x86_xstate_ymm_write, TEST_XSTATE, FPREGS_YMM, TEST_SETREGS, 4348X86_REGISTER_TEST(x86_xstate_ymm_write, TEST_XSTATE, FPREGS_YMM, TEST_SETREGS,
3808 "Test writing ymm0..ymm15 (..ymm7 on i386) into debugged program " 4349 "Test writing ymm0..ymm15 (..ymm7 on i386) into debugged program "
3809 "via PT_SETXSTATE."); 4350 "via PT_SETXSTATE.");
3810X86_REGISTER_TEST(x86_xstate_ymm_core, TEST_XSTATE, FPREGS_YMM, TEST_COREDUMP, 4351X86_REGISTER_TEST(x86_xstate_ymm_core, TEST_XSTATE, FPREGS_YMM, TEST_COREDUMP,
3811 "Test reading ymm0..ymm15 (..ymm7 on i386) from coredump via XSTATE note."); 4352 "Test reading ymm0..ymm15 (..ymm7 on i386) from coredump via XSTATE note.");
 4353X86_REGISTER_TEST(x86_xstate_zmm_read, TEST_XSTATE, FPREGS_ZMM, TEST_GETREGS,
 4354 "Test reading zmm0..zmm31 (..zmm7 on i386), k0..k7 from debugged program "
 4355 "via PT_GETXSTATE.");
 4356X86_REGISTER_TEST(x86_xstate_zmm_write, TEST_XSTATE, FPREGS_ZMM, TEST_SETREGS,
 4357 "Test writing zmm0..zmm31 (..zmm7 on i386), k0..k7 into debugged program "
 4358 "via PT_SETXSTATE.");
 4359X86_REGISTER_TEST(x86_xstate_zmm_core, TEST_XSTATE, FPREGS_ZMM, TEST_COREDUMP,
 4360 "Test reading zmm0..zmm31 (..zmm7 on i386), k0..k7 from coredump "
 4361 "via XSTATE note.");
3812 4362
3813/// ---------------------------------------------------------------------------- 4363/// ----------------------------------------------------------------------------
3814 4364
3815#if defined(TWAIT_HAVE_STATUS) 4365#if defined(TWAIT_HAVE_STATUS)
3816 4366
3817static void 4367static void
3818thread_concurrent_lwp_setup(pid_t child, lwpid_t lwpid) 4368thread_concurrent_lwp_setup(pid_t child, lwpid_t lwpid)
3819{ 4369{
3820 struct dbreg r; 4370 struct dbreg r;
3821 union u dr7; 4371 union u dr7;
3822 4372
3823 /* We need to set debug registers for every child */ 4373 /* We need to set debug registers for every child */
3824 DPRINTF("Call GETDBREGS for LWP %d\n", lwpid); 4374 DPRINTF("Call GETDBREGS for LWP %d\n", lwpid);
@@ -3985,17 +4535,20 @@ thread_concurrent_handle_sigtrap(pid_t c @@ -3985,17 +4535,20 @@ thread_concurrent_handle_sigtrap(pid_t c
3985 ATF_TP_ADD_TC(tp, x86_fpregs_xmm_write); \ 4535 ATF_TP_ADD_TC(tp, x86_fpregs_xmm_write); \
3986 ATF_TP_ADD_TC(tp, x86_fpregs_xmm_core); \ 4536 ATF_TP_ADD_TC(tp, x86_fpregs_xmm_core); \
3987 ATF_TP_ADD_TC(tp, x86_xstate_fpu_read); \ 4537 ATF_TP_ADD_TC(tp, x86_xstate_fpu_read); \
3988 ATF_TP_ADD_TC(tp, x86_xstate_fpu_write); \ 4538 ATF_TP_ADD_TC(tp, x86_xstate_fpu_write); \
3989 ATF_TP_ADD_TC(tp, x86_xstate_fpu_core); \ 4539 ATF_TP_ADD_TC(tp, x86_xstate_fpu_core); \
3990 ATF_TP_ADD_TC(tp, x86_xstate_mm_read); \ 4540 ATF_TP_ADD_TC(tp, x86_xstate_mm_read); \
3991 ATF_TP_ADD_TC(tp, x86_xstate_mm_write); \ 4541 ATF_TP_ADD_TC(tp, x86_xstate_mm_write); \
3992 ATF_TP_ADD_TC(tp, x86_xstate_mm_core); \ 4542 ATF_TP_ADD_TC(tp, x86_xstate_mm_core); \
3993 ATF_TP_ADD_TC(tp, x86_xstate_xmm_read); \ 4543 ATF_TP_ADD_TC(tp, x86_xstate_xmm_read); \
3994 ATF_TP_ADD_TC(tp, x86_xstate_xmm_write); \ 4544 ATF_TP_ADD_TC(tp, x86_xstate_xmm_write); \
3995 ATF_TP_ADD_TC(tp, x86_xstate_xmm_core); \ 4545 ATF_TP_ADD_TC(tp, x86_xstate_xmm_core); \
3996 ATF_TP_ADD_TC(tp, x86_xstate_ymm_read); \ 4546 ATF_TP_ADD_TC(tp, x86_xstate_ymm_read); \
3997 ATF_TP_ADD_TC(tp, x86_xstate_ymm_write); \ 4547 ATF_TP_ADD_TC(tp, x86_xstate_ymm_write); \
3998 ATF_TP_ADD_TC(tp, x86_xstate_ymm_core); 4548 ATF_TP_ADD_TC(tp, x86_xstate_ymm_core); \
 4549 ATF_TP_ADD_TC(tp, x86_xstate_zmm_read); \
 4550 ATF_TP_ADD_TC(tp, x86_xstate_zmm_write); \
 4551 ATF_TP_ADD_TC(tp, x86_xstate_zmm_core);
3999#else 4552#else
4000#define ATF_TP_ADD_TCS_PTRACE_WAIT_X86() 4553#define ATF_TP_ADD_TCS_PTRACE_WAIT_X86()
4001#endif 4554#endif