From 913ae97e0760f28e027a82828b1f38702f157407 Mon Sep 17 00:00:00 2001 From: Philippe Waroquiers Date: Tue, 14 Feb 2012 21:35:46 +0000 Subject: [PATCH] * fix Bug 290655 - Add support for AESKEYGENASSIST instruction (Valgrind part : test for AES instructions (AESKEYGENASSIST, AESIMC, AESENC, AESENCLAST, AESDEC, AESDECLAST). git-svn-id: svn://svn.valgrind.org/valgrind/trunk@12384 --- NEWS | 4 + none/tests/amd64/Makefile.am | 3 +- none/tests/amd64/aes.c | 373 ++++++++++++++++++++++++++++++++ none/tests/amd64/aes.stderr.exp | 0 none/tests/amd64/aes.stdout.exp | 72 ++++++ none/tests/amd64/aes.vgtest | 3 + 6 files changed, 454 insertions(+), 1 deletion(-) create mode 100644 none/tests/amd64/aes.c create mode 100644 none/tests/amd64/aes.stderr.exp create mode 100644 none/tests/amd64/aes.stdout.exp create mode 100644 none/tests/amd64/aes.vgtest diff --git a/NEWS b/NEWS index f16b25c529..3e8ba02aff 100644 --- a/NEWS +++ b/NEWS @@ -3,6 +3,9 @@ Release 3.8.0 (????) * ================== PLATFORM CHANGES ================= +* Support for AES instructions (AESKEYGENASSIST, AESENC, AESENCLAST, + AESDEC, AESDECLAST, AESIMC). + * ==================== TOOL CHANGES ==================== * Memcheck: @@ -51,6 +54,7 @@ where XXXXXX is the bug number as listed below. 287858 VG_(strerror): unknown error 289699 vgdb connection in relay mode erroneously closed due to buffer overrun 289939 wish: complete monitor cmd 'leak_check' with details about leaked or reachable blocks +290655 Add support for AESKEYGENASSIST instruction 290974 vgdb must align pages to VKI_SHMLBA (16KB) on ARM Release 3.7.0 (5 November 2011) diff --git a/none/tests/amd64/Makefile.am b/none/tests/amd64/Makefile.am index 535335428e..a9f6e547d9 100644 --- a/none/tests/amd64/Makefile.am +++ b/none/tests/amd64/Makefile.am @@ -21,6 +21,7 @@ endif # which failed the BUILD_SSE3_TESTS test in configure.in. EXTRA_DIST = \ + aes.vgtest aes.stdout.exp aes.stderr.exp \ amd64locked.vgtest amd64locked.stdout.exp amd64locked.stderr.exp \ asorep.stderr.exp asorep.stdout.exp asorep.vgtest \ bug127521-64.vgtest bug127521-64.stdout.exp bug127521-64.stderr.exp \ @@ -91,7 +92,7 @@ if BUILD_LZCNT_TESTS check_PROGRAMS += lzcnt64 endif if BUILD_SSE42_TESTS - check_PROGRAMS += pcmpstr64 pcmpxstrx64 sse4-64 crc32 + check_PROGRAMS += pcmpstr64 pcmpxstrx64 sse4-64 crc32 aes endif # DDD: these need to be made to work on Darwin like the x86/ ones were. diff --git a/none/tests/amd64/aes.c b/none/tests/amd64/aes.c new file mode 100644 index 0000000000..a0c83c6b2b --- /dev/null +++ b/none/tests/amd64/aes.c @@ -0,0 +1,373 @@ + +#include +#include +#include + +typedef unsigned int UInt; +typedef signed int Int; +typedef unsigned char UChar; +typedef unsigned long long int ULong; +typedef UChar Bool; +#define False ((Bool)0) +#define True ((Bool)1) + +//typedef unsigned char V128[16]; +typedef + union { + UChar uChar[16]; + UInt uInt[4]; + } + V128; + +static UChar fromhex(char x) { + if (x >= '0' && x <= '9') { return(x - '0'); } + else if (x >= 'A' && x <= 'F') { return(x - 'A' + 10); } + else if (x >= 'a' && x <= 'f') { return(x - 'a' + 10); } + else assert(0); +} + +static void expand ( V128* dst, char* summary ) +{ + Int i; + assert( strlen(summary) == 32 ); + for (i = 0; i < 16; i++) { + UChar xx = 0; + UChar x = summary[31-2*i]; + UChar yy = 0; + UChar y = summary[31-2*i-1]; + xx = fromhex (x); + yy = fromhex (y); + + assert(xx < 16); + assert(yy < 16); + xx = (yy << 4) | xx; + assert(xx < 256); + dst->uChar[i] = xx; + } +} + +static int tohex (int nib) +{ + if (nib < 10) + return '0' + nib; + else + return 'a' + nib - 10; +} +static void unexpand ( V128* dst, char* summary ) +{ + Int i; + for (i = 0; i < 16; i++) { + *summary++ = tohex((dst->uChar[i] >> 4) & 0xf); + *summary++ = tohex(dst->uChar[i] & 0xf); + } + *summary = 0; +} + +static void AESDEC(char *s_argL, char *s_argR, char *s_exp) +{ + /* + ; xmm1 and xmm2 hold two 128-bit inputs (xmm1 = State; xmm2 = Round key). + ; The result is delivered in xmm1. + */ + V128 argL, argR; + V128 res; + char s_res[33]; + V128 exp; + expand(&argL, s_argL); + expand(&argR, s_argR); + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm1" "\n\t" + "movdqu %2, %%xmm2" "\n\t" + "aesdec %%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL), "m"/*in*/(argR) + : /*trash*/ "xmm1", "xmm2" + ); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aesdec %s %s result %s\n", s_argL, s_argR, s_res); +} + +static void AESDECLAST(char *s_argL, char *s_argR, char *s_exp) +{ + /* + ; xmm1 and xmm2 hold two 128-bit inputs (xmm1 = State; xmm2 = Round key). + ; The result is delivered in xmm1. + */ + V128 argL, argR; + V128 res; + char s_res[33]; + V128 exp; + expand(&argL, s_argL); + expand(&argR, s_argR); + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm1" "\n\t" + "movdqu %2, %%xmm2" "\n\t" + "aesdeclast %%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL), "m"/*in*/(argR) + : /*trash*/ "xmm1", "xmm2" + ); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aesdeclast %s %s result %s\n", s_argL, s_argR, s_res); +} + +static void AESENC(char *s_argL, char *s_argR, char *s_exp) +{ + /* + ; xmm1 and xmm2 hold two 128-bit inputs (xmm1 = State; xmm2 = Round key). + ; The result is delivered in xmm1. + */ + V128 argL, argR; + V128 res; + char s_res[33]; + V128 exp; + expand(&argL, s_argL); + expand(&argR, s_argR); + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm1" "\n\t" + "movdqu %2, %%xmm2" "\n\t" + "aesenc %%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL), "m"/*in*/(argR) + : /*trash*/ "xmm1", "xmm2" + ); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aesenc %s %s result %s\n", s_argL, s_argR, s_res); +} + +static void AESENCLAST(char *s_argL, char *s_argR, char *s_exp) +{ + /* + ; xmm1 and xmm2 hold two 128-bit inputs (xmm1 = State; xmm2 = Round key) + ; The result delivered in xmm1 + */ + V128 argL, argR; + V128 res; + char s_res[33]; + V128 exp; + expand(&argL, s_argL); + expand(&argR, s_argR); + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm1" "\n\t" + "movdqu %2, %%xmm2" "\n\t" + "aesenclast %%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL), "m"/*in*/(argR) + : /*trash*/ "xmm1", "xmm2" + ); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aesenclast %s %s result %s\n", s_argL, s_argR, s_res); +} + +static void AESIMC(char *s_argR, char *s_exp) +{ + /* We test another way to pass input and get results */ + /* ; argR hold one 128-bit inputs (argR = Round key) + ; result delivered in xmm5 */ + + V128 argR; + V128 res; + char s_res[33]; + V128 exp; + expand(&argR, s_argR); + + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "aesimc %1, %%xmm5" "\n\t" + "movdqu %%xmm5, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argR) + : /*trash*/ "xmm5" + ); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aesimc %s result %s\n", s_argR, s_res); +} + +static void AESKEYGENASSIST(int imm, char* s_argL, char* s_exp) +{ + /* + ; xmm2 holds a 128-bit input; imm8 holds the RCON value + ; result delivered in xmm1 + */ + + V128 argL; + V128 res; + char s_res[33]; + V128 exp; + expand(&argL, s_argL); + if (imm == 1) + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm2" "\n\t" + "aeskeygenassist $1,%%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL) + : /*trash*/ "xmm1", "xmm2" + ); + else if (imm == 2) + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm2" "\n\t" + "aeskeygenassist $2,%%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL) + : /*trash*/ "xmm1", "xmm2" + ); + else if (imm == 8) + __asm__ __volatile__( + "subq $1024, %%rsp" "\n\t" + "movdqu %1, %%xmm2" "\n\t" + "aeskeygenassist $8,%%xmm2, %%xmm1" "\n\t" + "movdqu %%xmm1, %0" "\n\t" + "addq $1024, %%rsp" "\n\t" + : /*out*/ "=m"(res) + : "m"/*in*/(argL) + : /*trash*/ "xmm1", "xmm2" + ); + else assert (0); + + if (strlen(s_exp) > 0) { + expand(&exp, s_exp); + assert (0 == memcmp(&res, &exp, 16)); + } + unexpand (&res, s_res); + printf ("aeskeygenassist %d %s result %s\n", imm, s_argL, s_res); +} + +typedef struct Aes_Args { + char* argL; + char* argR; + int imm; // only for aeskeygenassist +} Aes_Args; + +/* Just a bunch of various data to compare a native run + with a run under Valgrind. */ +static const Aes_Args aes_args[] = { + {"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + 8}, + {"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + 8}, + {"3243f6a8885a308d313198a2e0370734", + "2b7e151628aed2a6abf7158809cf4f3c", + 2}, + {"193de3bea0f4e22b9ac68d2ae9f84808", + "d42711aee0bf98f1b8b45de51e415230", + 2}, + {"d4bf5d30e0b452aeb84111f11e2798e5", + "046681e5e0cb199a48f8d37a2806264c", + 1}, + {"a0fafe1788542cb123a339392a6c7605", + "a49c7ff2689f352b6b5bea43026a5049", + 1}, + {"49ded28945db96f17f39871a7702533b", + "49db873b453953897f02d2f177de961a", + 8}, + {"584dcaf11b4b5aacdbe7caa81b6bb0e5", + "f2c295f27a96b9435935807a7359f67f", + 8}, + {"aa8f5f0361dde3ef82d24ad26832469a", + "ac73cf7befc111df13b5d6b545235ab8", + 2}, + {"acc1d6b8efb55a7b1323cfdf457311b5", + "75ec0993200b633353c0cf7cbb25d0dc", + 2}, + {"e9317db5cb322c723d2e895faf090794", + "d014f9a8c9ee2589e13f0cc8b6630ca6", + 1}, + {NULL, + NULL, + 0} +}; + +int main ( void ) +{ + int i; + + /* test the various instructions, using the examples provided + in "White Paper Intel Advanced Encryption Standard AES + instruction set" January 2010 (26/1/2010) + Rev. 3.0 + by Shay Gueron */ + AESKEYGENASSIST(1, + "3c4fcf098815f7aba6d2ae2816157e2b", + "01eb848beb848a013424b5e524b5e434"); + AESENC("7b5b54657374566563746f725d53475d", + "48692853686179295b477565726f6e5d", + "a8311c2f9fdba3c58b104b58ded7e595"); + AESENCLAST("7b5b54657374566563746f725d53475d", + "48692853686179295b477565726f6e5d", + "c7fb881e938c5964177ec42553fdc611"); + AESDEC("7b5b54657374566563746f725d53475d", + "48692853686179295b477565726f6e5d", + "138ac342faea2787b58eb95eb730392a"); + AESDECLAST("7b5b54657374566563746f725d53475d", + "48692853686179295b477565726f6e5d", + "c5a391ef6b317f95d410637b72a593d0"); + /* ??? the AESIMC example given in the Intel White paper + seems wrong. + The below fails both under Valgrind and natively. + AESIMC("48692853686179295b477565726f6e5d", + "627a6f6644b109c82b18330a81c3b3e5"); + So we use the example given for the InvMixColums + transformation. */ + AESIMC("8dcab9dc035006bc8f57161e00cafd8d", + "d635a667928b5eaeeec9cc3bc55f5777"); + + + /* and now a bunch of other calls. The below are verified + using the aes.stdout.exp (produced by a native run). */ + + for (i = 0; aes_args[i].argL != NULL; i++) { + AESKEYGENASSIST(aes_args[i].imm, aes_args[i].argL, ""); + AESENC(aes_args[i].argL, aes_args[i].argR, ""); + AESENCLAST(aes_args[i].argL, aes_args[i].argR, ""); + AESDEC(aes_args[i].argL, aes_args[i].argR, ""); + AESDECLAST(aes_args[i].argL, aes_args[i].argR, ""); + AESIMC(aes_args[i].argL, ""); + } + return 0; +} diff --git a/none/tests/amd64/aes.stderr.exp b/none/tests/amd64/aes.stderr.exp new file mode 100644 index 0000000000..e69de29bb2 diff --git a/none/tests/amd64/aes.stdout.exp b/none/tests/amd64/aes.stdout.exp new file mode 100644 index 0000000000..f9bb2e2502 --- /dev/null +++ b/none/tests/amd64/aes.stdout.exp @@ -0,0 +1,72 @@ +aeskeygenassist 1 3c4fcf098815f7aba6d2ae2816157e2b result 34e4b524e5b52434018a84eb8b84eb01 +aesenc 7b5b54657374566563746f725d53475d 48692853686179295b477565726f6e5d result 95e5d7de584b108bc5a3db9f2f1c31a8 +aesenclast 7b5b54657374566563746f725d53475d 48692853686179295b477565726f6e5d result 11c6fd5325c47e1764598c931e88fbc7 +aesdec 7b5b54657374566563746f725d53475d 48692853686179295b477565726f6e5d result 2a3930b75eb98eb58727eafa42c38a13 +aesdeclast 7b5b54657374566563746f725d53475d 48692853686179295b477565726f6e5d result d093a5727b6310d4957f316bef91a3c5 +aesimc 8dcab9dc035006bc8f57161e00cafd8d result 77575fc53bccc9eeae5e8b9267a635d6 +aeskeygenassist 8 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result acacacaca4acacacacacacaca4acacac +aesenc aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result 17171717171717171717171717171717 +aesenclast aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result 17171717171717171717171717171717 +aesdec aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9 +aesdeclast aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9d9 +aesimc aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +aeskeygenassist 8 bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result eaeaeaeae2eaeaeaeaeaeaeae2eaeaea +aesenc bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result 40404040404040404040404040404040 +aesenclast bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result 40404040404040404040404040404040 +aesdec bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result 54545454545454545454545454545454 +aesdeclast bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa result 54545454545454545454545454545454 +aesimc bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb result bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +aeskeygenassist 2 3243f6a8885a308d313198a2e0370734 result 3a46c7c744c7c73ac2421a23401a23c2 +aesenc 3243f6a8885a308d313198a2e0370734 2b7e151628aed2a6abf7158809cf4f3c result 5b21939f0be8c5228779cc82ded0bbe7 +aesenclast 3243f6a8885a308d313198a2e0370734 2b7e151628aed2a6abf7158809cf4f3c result 2409712ab211ed4afb9034efd4d0b9ef +aesdec 3243f6a8885a308d313198a2e0370734 2b7e151628aed2a6abf7158809cf4f3c result 1a25b0ac361c8eb4fddc79ef4827a878 +aesdeclast 3243f6a8885a308d313198a2e0370734 2b7e151628aed2a6abf7158809cf4f3c result 14998927922d933c12301c89791d508b +aesimc 3243f6a8885a308d313198a2e0370734 result db530b675db2ba6fa708ae6ed9f66c6c +aeskeygenassist 2 193de3bea0f4e22b9ac68d2ae9f84808 result e55db4b85fb4b8e5ae1127d41327d4ae +aesenc 193de3bea0f4e22b9ac68d2ae9f84808 d42711aee0bf98f1b8b45de51e415230 result dcd62e1fbee4a50fc2300ed34b3c9300 +aesenclast 193de3bea0f4e22b9ac68d2ae9f84808 d42711aee0bf98f1b8b45de51e415230 result 000ffeca00c593a60089fe5800439334 +aesdec 193de3bea0f4e22b9ac68d2ae9f84808 d42711aee0bf98f1b8b45de51e415230 result ceb3447b03c44db310640f9d67b7e938 +aesdeclast 193de3bea0f4e22b9ac68d2ae9f84808 d42711aee0bf98f1b8b45de51e415230 result 8f1ffb2970893ffffa2c5e6ef42ae03f +aesimc 193de3bea0f4e22b9ac68d2ae9f84808 result 8a6ed86d802581dfeac414a7a21dd315 +aeskeygenassist 1 d4bf5d30e0b452aeb84111f11e2798e5 result a182836c83836ca1044c08484d084804 +aesenc d4bf5d30e0b452aeb84111f11e2798e5 046681e5e0cb199a48f8d37a2806264c result bd2484c75918df5c3d46548f45760114 +aesenclast d4bf5d30e0b452aeb84111f11e2798e5 046681e5e0cb199a48f8d37a2806264c result 95a48b60dbd3f03a7e55078ce1c7e5e5 +aesdec d4bf5d30e0b452aeb84111f11e2798e5 046681e5e0cb199a48f8d37a2806264c result cc0387f79017ecef380418f56fefbe69 +aesdeclast d4bf5d30e0b452aeb84111f11e2798e5 046681e5e0cb199a48f8d37a2806264c result 66abc0b251310ce824faf6f9edc99eed +aesimc d4bf5d30e0b452aeb84111f11e2798e5 result 6881228f0df28f69bae4eb1dd6a65523 +aeskeygenassist 1 a0fafe1788542cb123a339392a6c7605 result 12120a26130a2612f0bb2de0ba2de0f0 +aesenc a0fafe1788542cb123a339392a6c7605 a49c7ff2689f352b6b5bea43026a5049 result 699f68563c8856d00046268c8f25170e +aesenclast a0fafe1788542cb123a339392a6c7605 a49c7ff2689f352b6b5bea43026a5049 result 22424ae2519b768ee38ecf4e02479660 +aesdec a0fafe1788542cb123a339392a6c7605 a49c7ff2689f352b6b5bea43026a5049 result 16410fdca2b0401cd1e0745e2318f956 +aesdeclast a0fafe1788542cb123a339392a6c7605 a49c7ff2689f352b6b5bea43026a5049 result 7f5c973018e54ffc7d6e272f753ded31 +aesimc a0fafe1788542cb123a339392a6c7605 result daafd9998b920a93560531231bc98bea +aeskeygenassist 8 49ded28945db96f17f39871a7702533b result a21712d21f12d2a2a7b51d3bbd1d3ba7 +aesenc 49ded28945db96f17f39871a7702533b 49db873b453953897f02d2f177de961a result 7eb10f92ed990efeb1c8aec03eb90798 +aesenclast 49ded28945db96f17f39871a7702533b 49db873b453953897f02d2f177de961a result f881674c53421f8a28e64e979c6ac927 +aesdec 49ded28945db96f17f39871a7702533b 49db873b453953897f02d2f177de961a result c2ea4f805b7fa23f53f6bcb0ccb0a26e +aesdeclast 49ded28945db96f17f39871a7702533b 49db873b453953897f02d2f177de961a result 53e9411cb2829e17a2b953e1c9b2804b +aesimc 49ded28945db96f17f39871a7702533b result fa94f98aee746021e71d24278e665a7e +aeskeygenassist 8 584dcaf11b4b5aacdbe7caa81b6bb0e5 result c27494b97c94b9c2a174e36a7ce36aa1 +aesenc 584dcaf11b4b5aacdbe7caa81b6bb0e5 f2c295f27a96b9435935807a7359f67f result 9363371070b47e1c20f85db0a2e95d3c +aesenclast 584dcaf11b4b5aacdbe7caa81b6bb0e5 f2c295f27a96b9435935807a7359f67f result a682ea19b83ed6f6d2cde9c35372565d +aesdec 584dcaf11b4b5aacdbe7caa81b6bb0e5 f2c295f27a96b9435935807a7359f67f result 98438a9b55d66fc8a408075c6411e65d +aesdeclast 584dcaf11b4b5aacdbe7caa81b6bb0e5 f2c295f27a96b9435935807a7359f67f result 55e695ec157c501de9a99324d9d372b6 +aesimc 584dcaf11b4b5aacdbe7caa81b6bb0e5 result 57919370d34c20e10b86bb9004e4e42a +aeskeygenassist 2 aa8f5f0361dde3ef82d24ad26832469a result b5d6b513d4b513b57bcf73accd73ac7b +aesenc aa8f5f0361dde3ef82d24ad26832469a ac73cf7befc111df13b5d6b545235ab8 result dfa13bc2c191383f003da25f392b090b +aesenclast aa8f5f0361dde3ef82d24ad26832469a ac73cf7befc111df13b5d6b545235ab8 result 008ce2e900c7c65600dee2fc0095c643 +aesdec aa8f5f0361dde3ef82d24ad26832469a ac73cf7befc111df13b5d6b545235ab8 result 39388a643582a19fa61b9f3c8ba80951 +aesdeclast aa8f5f0361dde3ef82d24ad26832469a ac73cf7befc111df13b5d6b545235ab8 result 8fdeea54ca4ec6cbbe4d608dae820c5b +aesimc aa8f5f0361dde3ef82d24ad26832469a result 75cccaf52bbea0fd78e6311f21815f86 +aeskeygenassist 2 acc1d6b8efb55a7b1323cfdf457311b5 result 9e8a267d88267d9e6cf67891f478916c +aesenc acc1d6b8efb55a7b1323cfdf457311b5 75ec0993200b633353c0cf7cbb25d0dc result acff63b994d0a2f082425ec02fcf34c0 +aesenclast acc1d6b8efb55a7b1323cfdf457311b5 75ec0993200b633353c0cf7cbb25d0dc result 095af02ae271b83d1295845dff8bcaaa +aesdec acc1d6b8efb55a7b1323cfdf457311b5 75ec0993200b633353c0cf7cbb25d0dc result f76e85460429f14c12e254a6e6c52680 +aesdeclast acc1d6b8efb55a7b1323cfdf457311b5 75ec0993200b633353c0cf7cbb25d0dc result 0e9af739932c1d32303c848a094fde1d +aesimc acc1d6b8efb55a7b1323cfdf457311b5 result bdf0449b196aa5f6a2f39ab08010ff6c +aeskeygenassist 1 e9317db5cb322c723d2e895faf090794 result cfa73127a63127cfd5ffc71efec71ed5 +aesenc e9317db5cb322c723d2e895faf090794 d014f9a8c9ee2589e13f0cc8b6630ca6 result 2d008268600a9fef35a43ab963f1477e +aesenclast e9317db5cb322c723d2e895faf090794 d014f9a8c9ee2589e13f0cc8b6630ca6 result 84ab40a8077df898c9daefee7d3c25cf +aesdec e9317db5cb322c723d2e895faf090794 d014f9a8c9ee2589e13f0cc8b6630ca6 result c542e1c7784ea84f7e85c9fe3be30603 +aesdeclast e9317db5cb322c723d2e895faf090794 d014f9a8c9ee2589e13f0cc8b6630ca6 result 411fc23d4c3411b897d7ae227abbd7cb +aesimc e9317db5cb322c723d2e895faf090794 result 6d0b9ac9808d60a83d4928fb88132ca7 diff --git a/none/tests/amd64/aes.vgtest b/none/tests/amd64/aes.vgtest new file mode 100644 index 0000000000..9117d698f1 --- /dev/null +++ b/none/tests/amd64/aes.vgtest @@ -0,0 +1,3 @@ +prog: aes +prereq: ../../../tests/x86_amd64_features amd64-sse42 +vgopts: -q -- 2.47.2