diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a91987b28..808239ae6 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -106,6 +106,7 @@ jobs: - -mavx - -mfma - -mavx2 + - -maes include: - target: tgl - isax: -mavx512bw -mavx512vl -mavx512cd -mavx512dq -mavx512vbmi -mavx512ifma -mavx512vpopcntdq -mavx512bitalg -mavx512vnni -mvpclmulqdq -mavx512fp16 diff --git a/meson.build b/meson.build index 3f72de356..b537dbe50 100644 --- a/meson.build +++ b/meson.build @@ -393,6 +393,7 @@ if not meson.is_subproject() install_headers( files([ + 'simde/x86/aes.h', 'simde/x86/avx512.h', 'simde/x86/avx2.h', 'simde/x86/avx.h', diff --git a/simde/simde-arch.h b/simde/simde-arch.h index c85f20ffd..26e796830 100644 --- a/simde/simde-arch.h +++ b/simde/simde-arch.h @@ -339,6 +339,9 @@ # if defined(__F16C__) || (defined(HEDLEY_MSVC_VERSION) && HEDLEY_MSVC_VERSION_CHECK(19,30,0) && defined(SIMDE_ARCH_X86_AVX2) ) # define SIMDE_ARCH_X86_F16C 1 # endif +# if defined(__AES__) +# define SIMDE_ARCH_X86_AES 1 +# endif #endif /* Itanium diff --git a/simde/simde-features.h b/simde/simde-features.h index 0fb3d4aa2..449c8c5e4 100644 --- a/simde/simde-features.h +++ b/simde/simde-features.h @@ -241,6 +241,15 @@ #define SIMDE_X86_SSE2_NATIVE #endif +#if !defined(SIMDE_X86_AES_NATIVE) && !defined(SIMDE_X86_AES_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) + #if defined(SIMDE_ARCH_X86_AES) + #define SIMDE_X86_AES_NATIVE + #endif +#endif +#if defined(SIMDE_X86_AES_NATIVE) && !defined(SIMDE_X86_SSE2_NATIVE) + #define SIMDE_X86_SSE2_NATIVE +#endif + #if !defined(SIMDE_X86_SSE2_NATIVE) && !defined(SIMDE_X86_SSE2_NO_NATIVE) && !defined(SIMDE_NO_NATIVE) #if defined(SIMDE_ARCH_X86_SSE2) #define SIMDE_X86_SSE2_NATIVE @@ -324,6 +333,10 @@ #endif #endif +#if defined(SIMDE_X86_AES_NATIVE) + #include +#endif + #if defined(HEDLEY_MSVC_VERSION) #pragma warning(pop) #endif @@ -647,6 +660,9 @@ #if !defined(SIMDE_X86_F16C_NATIVE) #define SIMDE_X86_F16C_ENABLE_NATIVE_ALIASES #endif + #if !defined(SIMDE_X86_AES_NATIVE) + #define SIMDE_X86_AES_ENABLE_NATIVE_ALIASES + #endif #if !defined(SIMDE_ARM_NEON_A32V7_NATIVE) #define SIMDE_ARM_NEON_A32V7_ENABLE_NATIVE_ALIASES diff --git a/simde/x86/aes.h b/simde/x86/aes.h new file mode 100644 index 000000000..e1c6a10f1 --- /dev/null +++ b/simde/x86/aes.h @@ -0,0 +1,605 @@ +/* MIT License + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#if !defined(SIMDE_X86_AES_H) +#define SIMDE_X86_AES_H + +/* + * Advanced Encryption Standard + * @author Dani Huertas + * @email huertas.dani@gmail.com + * + * Based on the document FIPS PUB 197 + */ + +#include "sse2.h" + +/* + * Multiplication in GF(2^8) + * http://en.wikipedia.org/wiki/Finite_field_arithmetic + * Irreducible polynomial m(x) = x8 + x4 + x3 + x + 1 + * + * NOTE: This function can be easily replaced with a look up table for a speed + * boost, at the expense of an increase in memory size. + +SIMDE_FUNCTION_ATTRIBUTES +uint8_t gmult(uint8_t a, uint8_t b) { + uint8_t p = 0, i = 0, hbs = 0; + + for (i = 0; i < 8; i++) { + if (b & 1) { + p ^= a; + } + + hbs = a & 0x80; + a <<= 1; + if (hbs) a ^= 0x1b; // 0000 0001 0001 1011 + b >>= 1; + } + + return (uint8_t)p; +} + */ + +static uint8_t simde_x_aes_gmult_lookup_table[8][256] = { +{ // gmult(0x02, b); + 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, + 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, + 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, + 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 0x78, 0x7a, 0x7c, 0x7e, + 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, + 0xa0, 0xa2, 0xa4, 0xa6, 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, + 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 0xd8, 0xda, 0xdc, 0xde, + 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, + 0x1b, 0x19, 0x1f, 0x1d, 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05, + 0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 0x23, 0x21, 0x27, 0x25, + 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, + 0x7b, 0x79, 0x7f, 0x7d, 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65, + 0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 0x83, 0x81, 0x87, 0x85, + 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, + 0xdb, 0xd9, 0xdf, 0xdd, 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5, + 0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 0xe3, 0xe1, 0xe7, 0xe5 +}, +{ // gmult(0x01, b); + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, +}, +{ // gmult(0x01, b); + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, + 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, + 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, + 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, + 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, + 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, + 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff, +}, +{ // gmult(0x03, b); + 0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 0x14, 0x17, 0x12, 0x11, + 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, + 0x60, 0x63, 0x66, 0x65, 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71, + 0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 0x44, 0x47, 0x42, 0x41, + 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, + 0xf0, 0xf3, 0xf6, 0xf5, 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1, + 0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 0xb4, 0xb7, 0xb2, 0xb1, + 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, + 0x9b, 0x98, 0x9d, 0x9e, 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a, + 0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 0xbf, 0xbc, 0xb9, 0xba, + 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, + 0xcb, 0xc8, 0xcd, 0xce, 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda, + 0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 0x4f, 0x4c, 0x49, 0x4a, + 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, + 0x3b, 0x38, 0x3d, 0x3e, 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a, + 0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 0x1f, 0x1c, 0x19, 0x1a, +}, +{ // gmult(0x0e, b); + 0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 0x48, 0x46, 0x54, 0x5a, + 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, + 0xdb, 0xd5, 0xc7, 0xc9, 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81, + 0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 0x73, 0x7d, 0x6f, 0x61, + 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, + 0x4d, 0x43, 0x51, 0x5f, 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17, + 0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 0x3e, 0x30, 0x22, 0x2c, + 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, + 0x41, 0x4f, 0x5d, 0x53, 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b, + 0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 0xe9, 0xe7, 0xf5, 0xfb, + 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, + 0x7a, 0x74, 0x66, 0x68, 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20, + 0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e, 0xa4, 0xaa, 0xb8, 0xb6, + 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, + 0x37, 0x39, 0x2b, 0x25, 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d, + 0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 0x9f, 0x91, 0x83, 0x8d, +}, +{ // gmult(0x09, b); + 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 0x6c, 0x65, 0x7e, 0x77, + 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, + 0x3b, 0x32, 0x29, 0x20, 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c, + 0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 0xc7, 0xce, 0xd5, 0xdc, + 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, + 0xe6, 0xef, 0xf4, 0xfd, 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91, + 0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e, 0x21, 0x28, 0x33, 0x3a, + 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, + 0xec, 0xe5, 0xfe, 0xf7, 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b, + 0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 0x10, 0x19, 0x02, 0x0b, + 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, + 0x47, 0x4e, 0x55, 0x5c, 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30, + 0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 0xf6, 0xff, 0xe4, 0xed, + 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, + 0xa1, 0xa8, 0xb3, 0xba, 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6, + 0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 0x5d, 0x54, 0x4f, 0x46, + +}, +{ // gmult(0x0d, b); + 0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 0x5c, 0x51, 0x46, 0x4b, + 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, + 0xbb, 0xb6, 0xa1, 0xac, 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0, + 0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 0x37, 0x3a, 0x2d, 0x20, + 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, + 0xbd, 0xb0, 0xa7, 0xaa, 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6, + 0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 0x8a, 0x87, 0x90, 0x9d, + 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, + 0xda, 0xd7, 0xc0, 0xcd, 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91, + 0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 0x56, 0x5b, 0x4c, 0x41, + 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, + 0xb1, 0xbc, 0xab, 0xa6, 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa, + 0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 0xeb, 0xe6, 0xf1, 0xfc, + 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, + 0x0c, 0x01, 0x16, 0x1b, 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47, + 0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 0x80, 0x8d, 0x9a, 0x97, +}, +{ // gmult(0x0b, b); + 0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 0x74, 0x7f, 0x62, 0x69, + 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, + 0x7b, 0x70, 0x6d, 0x66, 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12, + 0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 0xbf, 0xb4, 0xa9, 0xa2, + 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, + 0x46, 0x4d, 0x50, 0x5b, 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f, + 0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 0xf9, 0xf2, 0xef, 0xe4, + 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, + 0xf7, 0xfc, 0xe1, 0xea, 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e, + 0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 0x33, 0x38, 0x25, 0x2e, + 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, + 0x3c, 0x37, 0x2a, 0x21, 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55, + 0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 0x75, 0x7e, 0x63, 0x68, + 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, + 0x7a, 0x71, 0x6c, 0x67, 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13, + 0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 0xbe, 0xb5, 0xa8, 0xa3, +} +}; + +/* + * Multiplication of 4 byte words + * m(x) = x4+1 + +SIMDE_FUNCTION_ATTRIBUTES +void coef_mult(uint8_t *a, uint8_t *b, uint8_t *d) { + + d[0] = gmult(a[0],b[0])^gmult(a[3],b[1])^gmult(a[2],b[2])^gmult(a[1],b[3]); + d[1] = gmult(a[1],b[0])^gmult(a[0],b[1])^gmult(a[3],b[2])^gmult(a[2],b[3]); + d[2] = gmult(a[2],b[0])^gmult(a[1],b[1])^gmult(a[0],b[2])^gmult(a[3],b[3]); + d[3] = gmult(a[3],b[0])^gmult(a[2],b[1])^gmult(a[1],b[2])^gmult(a[0],b[3]); +} +*/ + +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_coef_mult_lookup(int lookup_table_offset, uint8_t *b, uint8_t *d) { + int o = lookup_table_offset; + + #define gmultl(o,b) simde_x_aes_gmult_lookup_table[o][b] + d[0] = gmultl(o+0,b[0])^gmultl(o+3,b[1])^gmultl(o+2,b[2])^gmultl(o+1,b[3]); + d[1] = gmultl(o+1,b[0])^gmultl(o+0,b[1])^gmultl(o+3,b[2])^gmultl(o+2,b[3]); + d[2] = gmultl(o+2,b[0])^gmultl(o+1,b[1])^gmultl(o+0,b[2])^gmultl(o+3,b[3]); + d[3] = gmultl(o+3,b[0])^gmultl(o+2,b[1])^gmultl(o+1,b[2])^gmultl(o+0,b[3]); + #undef gmultl +} + +/* + * Number of columns (32-bit words) comprising the State. For this + * standard, Nb = 4. + */ +#define simde_x_aes_Nb 4 + +/* + * S-box transformation table + */ +static uint8_t simde_x_aes_s_box[256] = { + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, // 0 + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, // 1 + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, // 2 + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, // 3 + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, // 4 + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, // 5 + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, // 6 + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, // 7 + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, // 8 + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, // 9 + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, // a + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, // b + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, // c + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, // d + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, // e + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16};// f + +/* + * Inverse S-box transformation table + */ +static uint8_t simde_x_aes_inv_s_box[256] = { + // 0 1 2 3 4 5 6 7 8 9 a b c d e f + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, // 0 + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, // 1 + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, // 2 + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, // 3 + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, // 4 + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, // 5 + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, // 6 + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, // 7 + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, // 8 + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, // 9 + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, // a + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, // b + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, // c + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, // d + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, // e + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d};// f + + +/* + * Transformation in the Cipher and Inverse Cipher in which a Round + * Key is added to the State using an XOR operation. The length of a + * Round Key equals the size of the State (i.e., for Nb = 4, the Round + * Key length equals 128 bits/16 bytes). + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_add_round_key(uint8_t *state, uint8_t *w, uint8_t r) { + + int Nb = simde_x_aes_Nb; + uint8_t c; + + for (c = 0; c < Nb; c++) { + state[Nb*0+c] = state[Nb*0+c]^w[4*Nb*r+4*c+0]; + state[Nb*1+c] = state[Nb*1+c]^w[4*Nb*r+4*c+1]; + state[Nb*2+c] = state[Nb*2+c]^w[4*Nb*r+4*c+2]; + state[Nb*3+c] = state[Nb*3+c]^w[4*Nb*r+4*c+3]; + } +} + +/* + * Transformation in the Cipher that takes all of the columns of the + * State and mixes their data (independently of one another) to + * produce new columns. + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_mix_columns(uint8_t *state) { + + int Nb = simde_x_aes_Nb; + // uint8_t k[] = {0x02, 0x01, 0x01, 0x03}; // a(x) = {02} + {01}x + {01}x2 + {03}x3 + uint8_t i, j, col[4], res[4]; + + for (j = 0; j < Nb; j++) { + for (i = 0; i < 4; i++) { + col[i] = state[Nb*i+j]; + } + + //coef_mult(k, col, res); + simde_x_aes_coef_mult_lookup(0, col, res); + + for (i = 0; i < 4; i++) { + state[Nb*i+j] = res[i]; + } + } +} + +/* + * Transformation in the Inverse Cipher that is the inverse of + * MixColumns(). + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_inv_mix_columns(uint8_t *state) { + + int Nb = simde_x_aes_Nb; + // uint8_t k[] = {0x0e, 0x09, 0x0d, 0x0b}; // a(x) = {0e} + {09}x + {0d}x2 + {0b}x3 + uint8_t i, j, col[4], res[4]; + + for (j = 0; j < Nb; j++) { + for (i = 0; i < 4; i++) { + col[i] = state[Nb*i+j]; + } + + //coef_mult(k, col, res); + simde_x_aes_coef_mult_lookup(4, col, res); + + for (i = 0; i < 4; i++) { + state[Nb*i+j] = res[i]; + } + } +} + +/* + * Transformation in the Cipher that processes the State by cyclically + * shifting the last three rows of the State by different offsets. + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_shift_rows(uint8_t *state) { + + int Nb = simde_x_aes_Nb; + uint8_t i, k, s, tmp; + + for (i = 1; i < 4; i++) { + // shift(1,4)=1; shift(2,4)=2; shift(3,4)=3 + // shift(r, 4) = r; + s = 0; + while (s < i) { + tmp = state[Nb*i+0]; + + for (k = 1; k < Nb; k++) { + state[Nb*i+k-1] = state[Nb*i+k]; + } + + state[Nb*i+Nb-1] = tmp; + s++; + } + } +} + +/* + * Transformation in the Inverse Cipher that is the inverse of + * ShiftRows(). + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_inv_shift_rows(uint8_t *state) { + + uint8_t Nb = simde_x_aes_Nb; + uint8_t i, k, s, tmp; + + for (i = 1; i < 4; i++) { + s = 0; + while (s < i) { + tmp = state[Nb*i+Nb-1]; + + for (k = Nb-1; k > 0; k--) { + state[Nb*i+k] = state[Nb*i+k-1]; + } + + state[Nb*i+0] = tmp; + s++; + } + } +} + +/* + * Transformation in the Cipher that processes the State using a non + * linear byte substitution table (S-box) that operates on each of the + * State bytes independently. + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_sub_bytes(uint8_t *state) { + + int Nb = simde_x_aes_Nb; + uint8_t i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + // s_box row: yyyy ---- + // s_box col: ---- xxxx + // s_box[16*(yyyy) + xxxx] == s_box[yyyyxxxx] + state[Nb*i+j] = simde_x_aes_s_box[state[Nb*i+j]]; + } + } +} + +/* + * Transformation in the Inverse Cipher that is the inverse of + * SubBytes(). + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_inv_sub_bytes(uint8_t *state) { + + int Nb = simde_x_aes_Nb; + uint8_t i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + state[Nb*i+j] = simde_x_aes_inv_s_box[state[Nb*i+j]]; + } + } +} + +/* + * Performs the AES cipher operation + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_enc(uint8_t *in, uint8_t *out, uint8_t *w, int is_last) { + + int Nb = simde_x_aes_Nb; + uint8_t state[4*simde_x_aes_Nb]; + uint8_t r = 0, i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + state[Nb*i+j] = in[i+4*j]; + } + } + + simde_x_aes_sub_bytes(state); + simde_x_aes_shift_rows(state); + + if (!is_last) + simde_x_aes_mix_columns(state); + + simde_x_aes_add_round_key(state, w, r); + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + out[i+4*j] = state[Nb*i+j]; + } + } +} + +/* + * Performs the AES inverse cipher operation + */ +SIMDE_FUNCTION_ATTRIBUTES +void simde_x_aes_dec(uint8_t *in, uint8_t *out, uint8_t *w, int is_last) { + + int Nb = simde_x_aes_Nb; + uint8_t state[4*simde_x_aes_Nb]; + uint8_t r = 0, i, j; + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + state[Nb*i+j] = in[i+4*j]; + } + } + + simde_x_aes_inv_shift_rows(state); + simde_x_aes_inv_sub_bytes(state); + + if (!is_last) + simde_x_aes_inv_mix_columns(state); + + simde_x_aes_add_round_key(state, w, r); + + for (i = 0; i < 4; i++) { + for (j = 0; j < Nb; j++) { + out[i+4*j] = state[Nb*i+j]; + } + } +} + +SIMDE_FUNCTION_ATTRIBUTES +simde__m128i simde_mm_aesenc_si128(simde__m128i a, simde__m128i round_key) { + #if defined(SIMDE_X86_AES_NATIVE) + return _mm_aesenc_si128(a, round_key); + #else + simde__m128i result; + simde_x_aes_enc(HEDLEY_REINTERPRET_CAST(uint8_t *, &a), HEDLEY_REINTERPRET_CAST(uint8_t *, &result), HEDLEY_REINTERPRET_CAST(uint8_t *, &round_key), 0); + return result; + #endif +} +#if defined(SIMDE_X86_AES_ENABLE_NATIVE_ALIASES) + #define _mm_aesenc_si128(a, b) simde_mm_aesenc_si128(a, b) +#endif + +SIMDE_FUNCTION_ATTRIBUTES +simde__m128i simde_mm_aesdec_si128(simde__m128i a, simde__m128i round_key) { + #if defined(SIMDE_X86_AES_NATIVE) + return _mm_aesdec_si128(a, round_key); + #else + simde__m128i result; + simde_x_aes_dec(HEDLEY_REINTERPRET_CAST(uint8_t *, &a), HEDLEY_REINTERPRET_CAST(uint8_t *, &result), HEDLEY_REINTERPRET_CAST(uint8_t *, &round_key), 0); + return result; + #endif +} +#if defined(SIMDE_X86_AES_ENABLE_NATIVE_ALIASES) + #define _mm_aesdec_si128(a, b) simde_mm_aesdec_si128(a, b) +#endif + +SIMDE_FUNCTION_ATTRIBUTES +simde__m128i simde_mm_aesenclast_si128(simde__m128i a, simde__m128i round_key) { + #if defined(SIMDE_X86_AES_NATIVE) + return _mm_aesenclast_si128(a, round_key); + #else + simde__m128i result; + simde_x_aes_enc(HEDLEY_REINTERPRET_CAST(uint8_t *, &a), HEDLEY_REINTERPRET_CAST(uint8_t *, &result), HEDLEY_REINTERPRET_CAST(uint8_t *, &round_key), 1); + return result; + #endif +} +#if defined(SIMDE_X86_AES_ENABLE_NATIVE_ALIASES) + #define _mm_aesenclast_si128(a, b) simde_mm_aesenclast_si128(a, b) +#endif + +SIMDE_FUNCTION_ATTRIBUTES +simde__m128i simde_mm_aesdeclast_si128(simde__m128i a, simde__m128i round_key) { + #if defined(SIMDE_X86_AES_NATIVE) + return _mm_aesdeclast_si128(a, round_key); + #else + simde__m128i result; + simde_x_aes_dec(HEDLEY_REINTERPRET_CAST(uint8_t *, &a), HEDLEY_REINTERPRET_CAST(uint8_t *, &result), HEDLEY_REINTERPRET_CAST(uint8_t *, &round_key), 1); + return result; + #endif +} +#if defined(SIMDE_X86_AES_ENABLE_NATIVE_ALIASES) + #define _mm_aesdeclast_si128(a, b) simde_mm_aesdeclast_si128(a, b) +#endif + +SIMDE_FUNCTION_ATTRIBUTES +simde__m128i simde_mm_aesimc_si128(simde__m128i a) { + #if defined(SIMDE_X86_AES_NATIVE) + return _mm_aesimc_si128(a); + #else + simde__m128i result; + + uint8_t *in = HEDLEY_REINTERPRET_CAST(uint8_t *, &a); + uint8_t *out = HEDLEY_REINTERPRET_CAST(uint8_t *, &result); + + int Nb = simde_x_aes_Nb; + // uint8_t k[] = {0x0e, 0x09, 0x0d, 0x0b}; // a(x) = {0e} + {09}x + {0d}x2 + {0b}x3 + uint8_t i, j, col[4], res[4]; + + for (j = 0; j < Nb; j++) { + for (i = 0; i < 4; i++) { + col[i] = in[Nb*j+i]; + } + + //coef_mult(k, col, res); + simde_x_aes_coef_mult_lookup(4, col, res); + + for (i = 0; i < 4; i++) { + out[Nb*j+i] = res[i]; + } + } + + return result; + #endif +} +#if defined(SIMDE_X86_AES_ENABLE_NATIVE_ALIASES) + #define _mm_aesimc_si128(a) simde_mm_aesimc_si128(a) +#endif + +#undef simde_x_aes_Nb + +#endif /* !defined(SIMDE_X86_AES_H) */ diff --git a/test/x86/aes.c b/test/x86/aes.c new file mode 100644 index 000000000..560e15f0f --- /dev/null +++ b/test/x86/aes.c @@ -0,0 +1,355 @@ +/* MIT License + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + * + */ + +#define SIMDE_TESTS_CURRENT_ISAX aes +#include +#include + +static int +test_simde_mm_aesenc_si128 (SIMDE_MUNIT_TEST_ARGS) { + static const struct { + const int8_t a[16]; + const int8_t b[16]; + const int8_t r[16]; + } test_vec[] = { + { { INT8_C( 37), INT8_C( 125), -INT8_C( 63), INT8_C( 116), INT8_C( 37), INT8_C( 50), INT8_C( 82), INT8_C( 13), + INT8_C( 3), -INT8_C( 37), -INT8_C( 38), INT8_C( 0), -INT8_C( 51), -INT8_C( 20), -INT8_C( 55), INT8_C( 120) }, + { -INT8_C( 45), -INT8_C( 61), INT8_C( 86), INT8_C( 0), INT8_C( 45), INT8_C( 18), INT8_C( 54), INT8_C( 25), + -INT8_C( 21), -INT8_C( 88), INT8_C( 117), INT8_C( 86), -INT8_C( 38), -INT8_C( 32), -INT8_C( 55), INT8_C( 0) }, + { INT8_C( 35), -INT8_C( 1), INT8_C( 59), INT8_C( 86), -INT8_C( 52), -INT8_C( 86), -INT8_C( 68), INT8_C( 3), + -INT8_C( 5), INT8_C( 11), INT8_C( 82), -INT8_C( 40), -INT8_C( 62), -INT8_C( 37), INT8_C( 46), -INT8_C( 27) } }, + { { INT8_C( 93), -INT8_C( 118), INT8_C( 116), -INT8_C( 126), -INT8_C( 67), -INT8_C( 58), -INT8_C( 113), -INT8_C( 64), + -INT8_C( 95), INT8_C( 105), -INT8_C( 64), INT8_C( 110), INT8_C( 85), -INT8_C( 119), -INT8_C( 25), INT8_C( 41) }, + { INT8_C( 76), INT8_C( 61), INT8_C( 41), INT8_C( 122), INT8_C( 79), INT8_C( 95), -INT8_C( 109), INT8_C( 58), + INT8_C( 8), INT8_C( 8), -INT8_C( 111), -INT8_C( 30), -INT8_C( 24), INT8_C( 90), -INT8_C( 30), INT8_C( 69) }, + { INT8_C( 12), INT8_C( 114), INT8_C( 74), -INT8_C( 15), INT8_C( 44), INT8_C( 120), INT8_C( 22), -INT8_C( 1), + -INT8_C( 74), INT8_C( 120), -INT8_C( 18), -INT8_C( 18), INT8_C( 101), INT8_C( 80), INT8_C( 60), INT8_C( 114) } }, + { { -INT8_C( 27), INT8_C( 86), -INT8_C( 57), -INT8_C( 94), INT8_C( 29), INT8_C( 86), INT8_C( 98), -INT8_C( 66), + -INT8_C( 65), INT8_C( 34), INT8_C( 45), INT8_C( 21), -INT8_C( 85), INT8_C( 20), INT8_C( 62), -INT8_C( 8) }, + { INT8_C( 81), INT8_C( 103), INT8_C( 114), -INT8_C( 95), -INT8_C( 57), INT8_C( 5), -INT8_C( 37), -INT8_C( 49), + INT8_C( 13), INT8_C( 108), -INT8_C( 79), -INT8_C( 11), -INT8_C( 57), -INT8_C( 108), INT8_C( 58), -INT8_C( 84) }, + { -INT8_C( 87), -INT8_C( 11), INT8_C( 114), INT8_C( 58), -INT8_C( 78), INT8_C( 107), -INT8_C( 35), INT8_C( 109), + INT8_C( 96), INT8_C( 116), INT8_C( 61), -INT8_C( 106), INT8_C( 56), INT8_C( 51), INT8_C( 77), -INT8_C( 93) } }, + { { -INT8_C( 22), INT8_C( 1), INT8_C( 78), INT8_C( 7), INT8_C( 87), -INT8_C( 80), -INT8_C( 58), INT8_C( 22), + -INT8_C( 46), -INT8_C( 13), INT8_C( 43), INT8_C( 125), INT8_C( 7), INT8_C( 105), INT8_C( 117), INT8_C( 88) }, + { -INT8_C( 47), -INT8_C( 25), -INT8_C( 7), -INT8_C( 104), -INT8_C( 20), -INT8_C( 43), INT8_C( 103), -INT8_C( 7), + INT8_C( 65), INT8_C( 24), -INT8_C( 18), INT8_C( 8), -INT8_C( 84), INT8_C( 40), -INT8_C( 76), -INT8_C( 105) }, + { INT8_C( 109), -INT8_C( 41), -INT8_C( 34), -INT8_C( 56), INT8_C( 21), -INT8_C( 19), INT8_C( 68), INT8_C( 21), + INT8_C( 72), INT8_C( 114), INT8_C( 53), -INT8_C( 108), -INT8_C( 14), INT8_C( 45), INT8_C( 100), -INT8_C( 18) } }, + { { INT8_C( 41), INT8_C( 2), -INT8_C( 98), INT8_MIN, -INT8_C( 78), INT8_C( 100), -INT8_C( 105), -INT8_C( 124), + INT8_C( 87), -INT8_C( 62), INT8_C( 2), INT8_C( 94), INT8_C( 44), INT8_C( 119), -INT8_C( 73), -INT8_C( 3) }, + { INT8_C( 95), -INT8_C( 80), -INT8_C( 107), INT8_C( 75), -INT8_C( 123), -INT8_C( 4), INT8_C( 69), -INT8_C( 57), + INT8_C( 20), INT8_C( 51), -INT8_C( 49), -INT8_C( 63), INT8_C( 92), -INT8_C( 124), INT8_C( 88), -INT8_C( 123) }, + { -INT8_C( 24), INT8_C( 94), INT8_C( 97), INT8_C( 35), -INT8_C( 32), -INT8_C( 84), INT8_C( 82), -INT8_C( 109), + -INT8_C( 14), -INT8_C( 37), -INT8_C( 106), INT8_C( 108), -INT8_C( 9), -INT8_C( 64), -INT8_C( 67), INT8_C( 89) } }, + { { -INT8_C( 122), -INT8_C( 10), INT8_C( 6), INT8_C( 57), INT8_C( 91), -INT8_C( 99), -INT8_C( 67), -INT8_C( 78), + INT8_C( 95), -INT8_C( 65), INT8_C( 17), -INT8_C( 117), INT8_C( 55), -INT8_C( 56), -INT8_C( 120), -INT8_C( 106) }, + { INT8_C( 120), INT8_C( 29), -INT8_C( 31), -INT8_C( 2), INT8_C( 25), INT8_C( 38), -INT8_C( 59), INT8_C( 46), + INT8_C( 90), -INT8_C( 108), -INT8_C( 17), -INT8_C( 74), INT8_C( 24), INT8_C( 71), INT8_C( 59), -INT8_C( 97) }, + { INT8_C( 0), -INT8_C( 24), INT8_C( 79), -INT8_C( 43), -INT8_C( 91), INT8_C( 74), INT8_C( 81), -INT8_C( 115), + -INT8_C( 92), INT8_C( 22), INT8_C( 79), INT8_C( 21), -INT8_C( 74), -INT8_C( 22), INT8_C( 80), INT8_C( 104) } }, + { { INT8_C( 61), INT8_C( 65), -INT8_C( 40), -INT8_C( 104), -INT8_C( 34), -INT8_C( 107), INT8_C( 75), INT8_C( 62), + INT8_C( 85), INT8_C( 92), -INT8_C( 55), -INT8_C( 116), INT8_C( 36), INT8_C( 82), INT8_C( 34), -INT8_C( 100) }, + { INT8_C( 111), INT8_C( 3), -INT8_C( 102), -INT8_C( 119), INT8_C( 42), INT8_C( 95), -INT8_C( 73), -INT8_C( 124), + -INT8_C( 12), -INT8_C( 90), INT8_C( 58), INT8_C( 12), -INT8_C( 19), INT8_C( 117), -INT8_C( 85), INT8_C( 42) }, + { INT8_C( 92), -INT8_C( 46), INT8_C( 79), -INT8_C( 80), INT8_C( 27), INT8_C( 62), INT8_C( 23), -INT8_C( 10), + -INT8_C( 60), INT8_C( 75), -INT8_C( 55), INT8_C( 13), -INT8_C( 56), -INT8_C( 12), -INT8_C( 49), -INT8_C( 120) } }, + { { -INT8_C( 73), -INT8_C( 125), -INT8_C( 61), -INT8_C( 107), INT8_C( 25), INT8_C( 14), -INT8_C( 45), INT8_C( 110), + INT8_C( 106), -INT8_C( 99), -INT8_C( 6), -INT8_C( 114), -INT8_C( 17), INT8_C( 28), INT8_C( 42), INT8_C( 94) }, + { INT8_C( 31), -INT8_C( 59), -INT8_C( 25), INT8_C( 73), INT8_C( 36), -INT8_C( 98), -INT8_C( 51), INT8_C( 24), + INT8_C( 68), INT8_C( 7), INT8_C( 37), INT8_C( 49), INT8_C( 125), -INT8_C( 48), INT8_C( 92), INT8_C( 52) }, + { -INT8_C( 59), INT8_C( 14), INT8_C( 87), -INT8_C( 97), -INT8_C( 70), -INT8_C( 24), -INT8_C( 24), -INT8_C( 112), + INT8_C( 78), -INT8_C( 53), INT8_C( 93), -INT8_C( 96), -INT8_C( 120), INT8_MAX, -INT8_C( 120), -INT8_C( 10) } }, + }; + + for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) { + simde__m128i a = simde_x_mm_loadu_epi8(test_vec[i].a); + simde__m128i b = simde_x_mm_loadu_epi8(test_vec[i].b); + simde__m128i r = simde_mm_aesenc_si128(a, b); + simde_test_x86_assert_equal_i8x16(r, simde_x_mm_loadu_epi8(test_vec[i].r)); + } + + return 0; +} + +static int +test_simde_mm_aesdec_si128 (SIMDE_MUNIT_TEST_ARGS) { + + static const struct { + const int8_t a[16]; + const int8_t b[16]; + const int8_t r[16]; + } test_vec[] = { + { { -INT8_C( 43), INT8_C( 108), INT8_C( 53), INT8_C( 64), -INT8_C( 13), -INT8_C( 126), -INT8_C( 116), -INT8_C( 116), + -INT8_C( 40), -INT8_C( 10), -INT8_C( 19), -INT8_C( 9), INT8_C( 93), -INT8_C( 43), INT8_C( 55), INT8_C( 38) }, + { INT8_C( 119), INT8_C( 40), -INT8_C( 23), INT8_C( 74), -INT8_C( 100), -INT8_C( 113), INT8_C( 36), INT8_C( 45), + -INT8_C( 97), -INT8_C( 65), -INT8_C( 115), -INT8_C( 17), INT8_C( 75), INT8_C( 105), -INT8_C( 3), INT8_C( 33) }, + { -INT8_C( 69), -INT8_C( 119), -INT8_C( 98), -INT8_C( 13), -INT8_C( 100), -INT8_C( 103), INT8_C( 76), INT8_C( 1), + -INT8_C( 101), INT8_C( 65), -INT8_C( 22), -INT8_C( 76), -INT8_C( 44), INT8_C( 30), -INT8_C( 74), INT8_C( 91) } }, + { { -INT8_C( 43), INT8_C( 50), INT8_C( 97), -INT8_C( 55), -INT8_C( 75), -INT8_C( 19), INT8_C( 85), -INT8_C( 115), + -INT8_C( 29), INT8_C( 66), -INT8_C( 124), INT8_C( 64), INT8_C( 23), -INT8_C( 68), INT8_C( 102), -INT8_C( 113) }, + { -INT8_C( 28), INT8_C( 80), -INT8_C( 39), -INT8_C( 127), -INT8_C( 33), -INT8_C( 3), -INT8_C( 82), INT8_MAX, + -INT8_C( 68), INT8_C( 59), INT8_C( 110), INT8_C( 7), -INT8_C( 92), INT8_C( 108), INT8_C( 40), INT8_C( 122) }, + { -INT8_C( 120), -INT8_C( 58), INT8_C( 35), -INT8_C( 73), -INT8_C( 9), -INT8_C( 63), INT8_C( 56), INT8_C( 47), + -INT8_C( 59), -INT8_C( 113), -INT8_C( 13), -INT8_C( 30), -INT8_C( 32), -INT8_C( 125), INT8_C( 1), INT8_C( 118) } }, + { { -INT8_C( 98), -INT8_C( 119), INT8_C( 67), INT8_C( 83), INT8_C( 118), -INT8_C( 104), -INT8_C( 32), INT8_C( 90), + -INT8_C( 38), INT8_C( 101), -INT8_C( 102), -INT8_C( 15), INT8_C( 33), INT8_C( 1), INT8_MIN, INT8_C( 5) }, + { INT8_C( 81), INT8_C( 89), -INT8_C( 122), INT8_C( 48), INT8_C( 86), INT8_C( 52), -INT8_C( 81), INT8_C( 18), + INT8_C( 111), INT8_C( 30), INT8_C( 26), INT8_C( 20), -INT8_C( 118), INT8_C( 66), -INT8_C( 114), INT8_C( 40) }, + { INT8_C( 92), -INT8_C( 29), INT8_C( 54), -INT8_C( 112), -INT8_C( 95), -INT8_C( 55), -INT8_C( 82), -INT8_C( 11), + -INT8_C( 122), INT8_C( 86), INT8_C( 98), INT8_C( 7), -INT8_C( 79), -INT8_C( 49), INT8_C( 0), INT8_C( 39) } }, + { { -INT8_C( 52), -INT8_C( 47), INT8_C( 124), INT8_C( 66), INT8_C( 105), INT8_C( 92), -INT8_C( 100), INT8_C( 67), + -INT8_C( 63), INT8_C( 55), INT8_C( 52), -INT8_C( 30), INT8_C( 56), -INT8_C( 75), -INT8_C( 24), -INT8_C( 119) }, + { INT8_C( 14), INT8_C( 110), -INT8_C( 71), INT8_C( 101), -INT8_C( 93), INT8_C( 105), INT8_C( 119), INT8_C( 18), + -INT8_C( 121), -INT8_C( 111), INT8_C( 38), INT8_C( 17), -INT8_C( 44), -INT8_C( 76), INT8_C( 57), -INT8_C( 96) }, + { -INT8_C( 30), -INT8_C( 69), INT8_C( 51), INT8_C( 111), -INT8_C( 58), -INT8_C( 30), -INT8_C( 78), INT8_MAX, + INT8_C( 94), -INT8_C( 125), INT8_C( 42), INT8_C( 95), -INT8_C( 57), INT8_C( 15), INT8_C( 28), INT8_C( 3) } }, + { { -INT8_C( 123), -INT8_C( 75), -INT8_C( 30), -INT8_C( 18), INT8_C( 18), INT8_MAX, INT8_C( 49), -INT8_C( 45), + -INT8_C( 74), INT8_C( 102), -INT8_C( 74), -INT8_C( 18), INT8_C( 27), -INT8_C( 98), INT8_C( 119), INT8_C( 41) }, + { INT8_C( 12), INT8_C( 48), -INT8_C( 114), -INT8_C( 81), -INT8_C( 103), INT8_C( 6), -INT8_C( 62), INT8_C( 32), + -INT8_C( 105), -INT8_C( 24), INT8_C( 49), INT8_C( 107), -INT8_C( 99), INT8_C( 107), INT8_C( 11), INT8_C( 34) }, + { INT8_C( 125), INT8_C( 126), INT8_C( 49), INT8_C( 71), INT8_C( 92), -INT8_C( 123), -INT8_C( 36), INT8_C( 8), + -INT8_C( 71), -INT8_C( 33), -INT8_C( 105), -INT8_C( 79), INT8_C( 100), INT8_C( 81), -INT8_C( 40), INT8_C( 18) } }, + { { INT8_C( 32), -INT8_C( 18), INT8_C( 17), INT8_C( 50), INT8_C( 109), INT8_C( 66), INT8_C( 6), INT8_C( 35), + -INT8_C( 88), -INT8_C( 68), INT8_C( 17), -INT8_C( 61), INT8_C( 90), -INT8_C( 120), -INT8_C( 19), INT8_C( 102) }, + { -INT8_C( 72), INT8_C( 123), INT8_C( 22), INT8_C( 82), -INT8_C( 127), -INT8_C( 40), INT8_C( 114), INT8_C( 25), + -INT8_C( 64), -INT8_C( 92), -INT8_C( 124), INT8_C( 93), INT8_C( 15), -INT8_C( 112), INT8_MIN, INT8_C( 47) }, + { INT8_C( 25), INT8_C( 36), INT8_C( 36), -INT8_C( 116), -INT8_C( 25), INT8_C( 124), INT8_C( 96), -INT8_C( 125), + INT8_C( 22), INT8_C( 122), -INT8_C( 105), -INT8_C( 17), INT8_C( 101), -INT8_C( 15), INT8_C( 125), -INT8_C( 29) } }, + { { INT8_C( 126), -INT8_C( 111), INT8_C( 98), -INT8_C( 21), -INT8_C( 45), INT8_C( 104), INT8_C( 14), INT8_C( 124), + INT8_C( 36), INT8_C( 31), INT8_C( 63), INT8_C( 126), -INT8_C( 89), INT8_C( 44), -INT8_C( 28), INT8_C( 95) }, + { -INT8_C( 88), -INT8_C( 6), -INT8_C( 79), INT8_C( 41), -INT8_C( 46), INT8_C( 36), INT8_C( 66), -INT8_C( 109), + -INT8_C( 56), -INT8_C( 57), -INT8_C( 16), -INT8_C( 41), INT8_C( 87), INT8_C( 112), INT8_C( 6), -INT8_C( 43) }, + { -INT8_C( 18), -INT8_C( 84), -INT8_C( 101), -INT8_C( 1), INT8_C( 95), INT8_C( 38), -INT8_C( 118), -INT8_C( 11), + INT8_C( 91), -INT8_C( 4), -INT8_C( 110), INT8_C( 99), -INT8_C( 81), -INT8_C( 28), -INT8_C( 23), -INT8_C( 1) } }, + { { INT8_C( 1), INT8_C( 104), -INT8_C( 64), -INT8_C( 43), -INT8_C( 48), -INT8_C( 50), INT8_C( 81), -INT8_C( 12), + -INT8_C( 19), -INT8_C( 112), INT8_C( 114), -INT8_C( 108), -INT8_C( 67), INT8_C( 87), -INT8_C( 13), INT8_C( 101) }, + { INT8_C( 81), -INT8_C( 91), -INT8_C( 114), INT8_C( 36), -INT8_C( 55), -INT8_C( 47), -INT8_C( 73), -INT8_C( 111), + -INT8_C( 104), -INT8_C( 89), INT8_C( 104), -INT8_C( 17), INT8_C( 24), INT8_C( 110), -INT8_C( 60), INT8_C( 25) }, + { INT8_C( 91), -INT8_C( 107), INT8_C( 125), -INT8_C( 102), -INT8_C( 102), INT8_C( 17), -INT8_C( 26), INT8_C( 93), + INT8_C( 121), INT8_C( 17), -INT8_C( 3), INT8_C( 49), -INT8_C( 93), -INT8_C( 95), -INT8_C( 27), -INT8_C( 46) } }, + }; + + for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) { + simde__m128i a = simde_x_mm_loadu_epi8(test_vec[i].a); + simde__m128i b = simde_x_mm_loadu_epi8(test_vec[i].b); + simde__m128i r = simde_mm_aesdec_si128(a, b); + simde_test_x86_assert_equal_i8x16(r, simde_x_mm_loadu_epi8(test_vec[i].r)); + } + + return 0; +} + +static int +test_simde_mm_aesenclast_si128 (SIMDE_MUNIT_TEST_ARGS) { + static const struct { + const int8_t a[16]; + const int8_t b[16]; + const int8_t r[16]; + } test_vec[] = { + { { -INT8_C( 103), -INT8_C( 11), -INT8_C( 16), -INT8_C( 107), INT8_C( 124), INT8_C( 121), -INT8_C( 15), -INT8_C( 8), + -INT8_C( 36), INT8_C( 89), INT8_C( 37), INT8_C( 86), -INT8_C( 25), INT8_C( 86), INT8_C( 30), -INT8_C( 103) }, + { -INT8_C( 111), -INT8_C( 57), -INT8_C( 123), INT8_C( 69), -INT8_C( 68), INT8_C( 104), INT8_C( 4), INT8_C( 9), + -INT8_C( 62), -INT8_C( 92), INT8_C( 81), -INT8_C( 14), INT8_C( 41), INT8_C( 59), -INT8_C( 56), -INT8_C( 62) }, + { INT8_MAX, INT8_C( 113), -INT8_C( 70), -INT8_C( 85), -INT8_C( 84), -INT8_C( 93), INT8_C( 118), INT8_C( 35), + INT8_C( 68), INT8_C( 21), -INT8_C( 35), -INT8_C( 77), -INT8_C( 67), -INT8_C( 35), INT8_C( 105), INT8_C( 115) } }, + { { INT8_C( 48), -INT8_C( 72), INT8_C( 87), -INT8_C( 84), INT8_C( 49), INT8_C( 72), -INT8_C( 91), INT8_C( 14), + -INT8_C( 95), -INT8_C( 54), INT8_C( 100), -INT8_C( 119), INT8_C( 32), -INT8_C( 126), INT8_C( 34), -INT8_C( 79) }, + { INT8_C( 73), -INT8_C( 88), -INT8_C( 10), INT8_C( 5), INT8_C( 16), -INT8_C( 5), INT8_C( 15), -INT8_C( 46), + -INT8_C( 97), INT8_C( 96), -INT8_C( 59), -INT8_C( 55), -INT8_C( 101), -INT8_C( 115), -INT8_C( 117), -INT8_C( 53) }, + { INT8_C( 77), -INT8_C( 6), -INT8_C( 75), -INT8_C( 51), -INT8_C( 41), -INT8_C( 113), -INT8_C( 100), INT8_C( 67), + -INT8_C( 83), INT8_C( 115), -INT8_C( 98), INT8_C( 98), INT8_C( 44), -INT8_C( 31), -INT8_C( 115), INT8_C( 108) } }, + { { INT8_C( 70), -INT8_C( 29), INT8_C( 120), INT8_C( 119), INT8_C( 43), INT8_C( 29), -INT8_C( 123), -INT8_C( 51), + -INT8_C( 25), -INT8_C( 22), INT8_C( 86), INT8_C( 7), INT8_C( 108), INT8_C( 120), -INT8_C( 71), -INT8_C( 74) }, + { INT8_C( 32), -INT8_C( 81), -INT8_C( 69), INT8_C( 49), -INT8_C( 86), -INT8_C( 54), INT8_C( 3), INT8_C( 74), + INT8_C( 42), -INT8_C( 56), INT8_C( 19), -INT8_C( 59), INT8_C( 86), -INT8_C( 98), -INT8_C( 111), -INT8_C( 100) }, + { INT8_C( 122), INT8_C( 11), INT8_C( 10), INT8_MAX, INT8_C( 91), INT8_C( 77), INT8_C( 85), -INT8_C( 65), + -INT8_C( 66), INT8_C( 116), -INT8_C( 81), INT8_C( 120), INT8_C( 6), -INT8_C( 113), INT8_C( 6), INT8_C( 89) } }, + { { -INT8_C( 127), INT8_C( 9), INT8_C( 19), -INT8_C( 83), INT8_C( 38), -INT8_C( 103), INT8_C( 122), INT8_C( 13), + -INT8_C( 125), -INT8_C( 48), INT8_C( 20), -INT8_C( 17), INT8_C( 72), -INT8_C( 51), -INT8_C( 91), INT8_C( 105) }, + { INT8_C( 125), INT8_C( 97), -INT8_C( 102), INT8_C( 39), INT8_C( 43), -INT8_C( 99), INT8_C( 113), INT8_C( 86), + INT8_C( 102), -INT8_C( 124), INT8_C( 27), -INT8_C( 68), INT8_C( 35), -INT8_C( 84), INT8_C( 88), -INT8_C( 92) }, + { INT8_C( 113), -INT8_C( 113), INT8_C( 96), -INT8_C( 34), -INT8_C( 36), -INT8_C( 19), INT8_C( 119), -INT8_C( 61), + -INT8_C( 118), INT8_C( 57), INT8_C( 102), INT8_C( 107), INT8_C( 113), -INT8_C( 83), -INT8_C( 126), INT8_C( 123) } }, + { { -INT8_C( 75), INT8_C( 107), INT8_C( 81), -INT8_C( 37), INT8_C( 4), -INT8_C( 53), -INT8_C( 24), -INT8_C( 121), + -INT8_C( 101), -INT8_C( 3), INT8_C( 119), -INT8_C( 28), -INT8_C( 54), INT8_C( 28), INT8_C( 77), INT8_C( 71) }, + { INT8_C( 125), -INT8_C( 25), INT8_C( 111), -INT8_C( 87), -INT8_C( 124), -INT8_C( 32), -INT8_C( 1), -INT8_C( 22), + INT8_C( 101), INT8_C( 26), -INT8_C( 90), -INT8_C( 120), -INT8_C( 57), -INT8_C( 2), INT8_C( 44), INT8_C( 124) }, + { -INT8_C( 88), -INT8_C( 8), -INT8_C( 102), INT8_C( 9), INT8_C( 118), -INT8_C( 76), INT8_C( 28), INT8_C( 83), + INT8_C( 113), -INT8_C( 122), INT8_C( 119), -INT8_C( 97), -INT8_C( 77), -INT8_C( 127), -INT8_C( 73), INT8_C( 21) } }, + { { INT8_C( 106), INT8_C( 126), INT8_C( 88), INT8_C( 110), INT8_C( 73), INT8_C( 64), -INT8_C( 10), -INT8_C( 27), + INT8_C( 61), INT8_C( 109), -INT8_C( 55), INT8_C( 8), -INT8_C( 119), INT8_C( 22), INT8_C( 79), INT8_C( 7) }, + { -INT8_C( 3), -INT8_C( 66), -INT8_C( 80), -INT8_C( 127), -INT8_C( 97), -INT8_C( 81), INT8_C( 108), INT8_C( 4), + -INT8_C( 55), INT8_C( 18), -INT8_C( 116), -INT8_C( 112), INT8_C( 17), -INT8_C( 72), INT8_C( 13), INT8_C( 123) }, + { -INT8_C( 1), -INT8_C( 73), INT8_C( 109), INT8_C( 68), -INT8_C( 92), -INT8_C( 109), -INT8_C( 24), -INT8_C( 101), + -INT8_C( 18), INT8_C( 85), -INT8_C( 26), INT8_C( 73), -INT8_C( 74), INT8_C( 75), INT8_C( 79), INT8_C( 75) } }, + { { INT8_C( 54), INT8_C( 101), -INT8_C( 23), INT8_MIN, -INT8_C( 91), -INT8_C( 33), INT8_C( 101), -INT8_C( 29), + INT8_C( 76), INT8_C( 46), -INT8_C( 21), -INT8_C( 42), INT8_C( 68), INT8_C( 58), -INT8_C( 35), INT8_C( 65) }, + { -INT8_C( 7), -INT8_C( 115), -INT8_C( 62), -INT8_C( 104), INT8_C( 60), INT8_C( 46), -INT8_C( 100), INT8_C( 5), + INT8_C( 65), INT8_C( 40), -INT8_C( 106), INT8_C( 82), -INT8_C( 32), -INT8_C( 93), -INT8_C( 51), INT8_C( 23) }, + { -INT8_C( 4), INT8_C( 19), INT8_C( 43), INT8_C( 27), INT8_C( 58), INT8_C( 31), INT8_C( 93), -INT8_C( 56), + INT8_C( 104), -INT8_C( 88), -INT8_C( 120), INT8_C( 67), -INT8_C( 5), -INT8_C( 18), INT8_MIN, -INT8_C( 31) } }, + { { INT8_C( 8), -INT8_C( 74), -INT8_C( 105), -INT8_C( 83), -INT8_C( 106), -INT8_C( 4), -INT8_C( 112), -INT8_C( 30), + INT8_C( 42), INT8_C( 123), -INT8_C( 72), INT8_C( 110), -INT8_C( 74), -INT8_C( 107), -INT8_C( 81), -INT8_C( 81) }, + { INT8_C( 34), INT8_C( 113), INT8_C( 71), INT8_C( 94), -INT8_C( 96), -INT8_C( 29), INT8_C( 100), -INT8_C( 31), + INT8_C( 11), -INT8_C( 6), INT8_C( 51), -INT8_C( 21), -INT8_C( 99), INT8_C( 0), INT8_C( 2), -INT8_C( 91) }, + { INT8_C( 18), -INT8_C( 63), INT8_C( 43), INT8_C( 39), INT8_C( 48), -INT8_C( 62), INT8_C( 29), INT8_C( 116), + -INT8_C( 18), -INT8_C( 48), -INT8_C( 69), INT8_C( 115), -INT8_C( 45), INT8_C( 78), INT8_C( 98), INT8_C( 58) } }, + }; + + for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) { + simde__m128i a = simde_x_mm_loadu_epi8(test_vec[i].a); + simde__m128i b = simde_x_mm_loadu_epi8(test_vec[i].b); + simde__m128i r = simde_mm_aesenclast_si128(a, b); + simde_test_x86_assert_equal_i8x16(r, simde_x_mm_loadu_epi8(test_vec[i].r)); + } + + return 0; +} + +static int +test_simde_mm_aesdeclast_si128 (SIMDE_MUNIT_TEST_ARGS) { + static const struct { + const int8_t a[16]; + const int8_t b[16]; + const int8_t r[16]; + } test_vec[] = { + { { INT8_C( 103), INT8_C( 70), -INT8_C( 95), INT8_C( 25), -INT8_C( 19), INT8_C( 60), INT8_C( 54), INT8_C( 17), + INT8_C( 55), -INT8_C( 114), INT8_C( 43), INT8_MAX, -INT8_C( 62), -INT8_C( 27), -INT8_C( 48), -INT8_C( 113) }, + { INT8_C( 10), -INT8_C( 103), INT8_C( 110), INT8_C( 74), -INT8_C( 80), -INT8_C( 49), INT8_C( 59), -INT8_C( 69), + -INT8_C( 123), INT8_C( 56), INT8_C( 65), -INT8_C( 77), INT8_C( 111), -INT8_C( 55), INT8_C( 99), -INT8_C( 42) }, + { INT8_C( 0), -INT8_C( 77), INT8_C( 101), -INT8_C( 87), -INT8_C( 29), INT8_C( 87), INT8_C( 91), -INT8_C( 48), + INT8_C( 55), INT8_C( 85), -INT8_C( 80), -INT8_C( 64), -INT8_C( 57), INT8_C( 47), INT8_C( 71), INT8_C( 88) } }, + { { INT8_C( 15), INT8_C( 4), -INT8_C( 17), -INT8_C( 3), INT8_C( 65), INT8_C( 37), INT8_C( 14), INT8_C( 120), + -INT8_C( 77), INT8_C( 57), -INT8_C( 9), INT8_C( 117), INT8_C( 30), -INT8_C( 56), INT8_C( 5), INT8_C( 40) }, + { INT8_C( 97), INT8_C( 115), INT8_C( 114), INT8_C( 18), INT8_C( 66), -INT8_C( 82), -INT8_C( 51), -INT8_C( 57), + -INT8_C( 26), INT8_C( 14), INT8_C( 122), INT8_C( 85), -INT8_C( 40), -INT8_C( 34), INT8_C( 43), -INT8_C( 25) }, + { -INT8_C( 102), -INT8_C( 62), INT8_C( 84), -INT8_C( 45), -INT8_C( 70), -INT8_C( 98), -INT8_C( 5), -INT8_C( 8), + -INT8_C( 83), -INT8_C( 52), INT8_C( 27), -INT8_C( 69), INT8_C( 49), -INT8_C( 123), -INT8_C( 4), -INT8_C( 58) } }, + { { -INT8_C( 30), INT8_C( 26), -INT8_C( 28), INT8_C( 35), INT8_C( 63), -INT8_C( 14), -INT8_C( 101), -INT8_C( 13), + INT8_C( 43), -INT8_C( 109), INT8_C( 104), INT8_C( 73), INT8_C( 91), INT8_C( 109), INT8_C( 114), -INT8_C( 68) }, + { -INT8_C( 32), -INT8_C( 28), -INT8_C( 50), INT8_C( 34), -INT8_C( 110), -INT8_C( 100), -INT8_C( 22), INT8_C( 121), + -INT8_C( 86), INT8_C( 100), -INT8_C( 50), -INT8_C( 126), INT8_C( 66), -INT8_C( 6), INT8_C( 106), INT8_C( 37) }, + { -INT8_C( 37), INT8_C( 87), INT8_C( 57), INT8_C( 92), -INT8_C( 73), -INT8_C( 33), -INT8_C( 12), -INT8_C( 35), + -INT8_C( 95), INT8_C( 96), INT8_C( 96), -INT8_C( 6), INT8_C( 21), -INT8_C( 40), -INT8_C( 126), INT8_C( 23) } }, + { { INT8_C( 20), INT8_C( 78), INT8_C( 72), INT8_C( 84), INT8_C( 65), -INT8_C( 28), INT8_C( 71), INT8_C( 108), + INT8_C( 119), -INT8_C( 81), -INT8_C( 74), -INT8_C( 46), INT8_C( 29), INT8_C( 40), -INT8_C( 114), -INT8_C( 3) }, + { INT8_C( 12), INT8_C( 93), INT8_C( 32), -INT8_C( 97), -INT8_C( 7), INT8_C( 10), INT8_C( 24), -INT8_C( 93), + INT8_C( 110), -INT8_C( 26), INT8_C( 38), -INT8_C( 79), -INT8_C( 32), -INT8_C( 112), -INT8_C( 42), -INT8_C( 11) }, + { -INT8_C( 105), -INT8_C( 77), INT8_C( 89), INT8_C( 39), INT8_C( 1), -INT8_C( 68), -INT8_C( 2), -INT8_C( 36), + INT8_C( 108), INT8_C( 72), -INT8_C( 14), -INT8_C( 112), INT8_C( 62), -INT8_C( 117), -INT8_C( 64), INT8_C( 8) } }, + { { -INT8_C( 34), INT8_C( 30), INT8_C( 73), INT8_C( 31), INT8_C( 2), -INT8_C( 112), -INT8_C( 116), INT8_C( 121), + INT8_C( 63), INT8_C( 66), INT8_C( 75), INT8_C( 92), INT8_C( 106), -INT8_C( 38), INT8_C( 90), INT8_C( 118) }, + { INT8_C( 55), INT8_C( 122), INT8_C( 21), INT8_C( 48), -INT8_C( 124), INT8_C( 45), -INT8_C( 45), -INT8_C( 14), + INT8_C( 20), -INT8_C( 7), -INT8_C( 93), -INT8_C( 12), -INT8_C( 119), INT8_C( 121), -INT8_C( 23), INT8_C( 104) }, + { -INT8_C( 85), INT8_C( 0), -INT8_C( 39), -INT8_C( 97), -INT8_C( 18), -INT8_C( 60), -INT8_C( 107), INT8_C( 85), + INT8_C( 49), INT8_C( 111), INT8_C( 7), -INT8_C( 5), -INT8_C( 47), -INT8_C( 113), INT8_C( 25), -INT8_C( 93) } }, + { { -INT8_C( 104), INT8_C( 50), -INT8_C( 121), -INT8_C( 102), -INT8_C( 62), INT8_C( 19), INT8_C( 20), INT8_C( 2), + INT8_C( 85), INT8_C( 95), INT8_C( 94), -INT8_C( 65), INT8_C( 57), -INT8_C( 72), INT8_C( 54), INT8_C( 112) }, + { INT8_C( 50), INT8_C( 75), -INT8_C( 96), -INT8_C( 74), INT8_C( 121), INT8_C( 116), -INT8_C( 87), -INT8_C( 115), + INT8_C( 109), INT8_C( 76), -INT8_C( 127), -INT8_C( 9), -INT8_C( 58), INT8_C( 107), INT8_C( 95), INT8_C( 94) }, + { -INT8_C( 48), -INT8_C( 47), INT8_C( 61), -INT8_C( 36), -INT8_C( 47), -INT8_C( 43), -INT8_C( 115), INT8_C( 121), + INT8_MIN, -INT8_C( 50), INT8_C( 107), INT8_C( 39), -INT8_C( 99), -INT8_C( 17), -INT8_C( 60), INT8_C( 105) } }, + { { -INT8_C( 99), -INT8_C( 26), -INT8_C( 8), INT8_C( 96), -INT8_C( 6), INT8_C( 12), INT8_C( 98), INT8_C( 79), + INT8_C( 108), -INT8_C( 64), INT8_C( 15), -INT8_C( 91), INT8_C( 121), INT8_C( 69), INT8_C( 22), -INT8_C( 85) }, + { -INT8_C( 112), -INT8_C( 74), INT8_C( 98), INT8_C( 9), INT8_C( 42), INT8_C( 11), -INT8_C( 106), -INT8_C( 104), + INT8_C( 87), INT8_C( 24), -INT8_C( 113), INT8_C( 29), -INT8_C( 125), -INT8_C( 18), INT8_C( 123), INT8_C( 32) }, + { -INT8_C( 27), -INT8_C( 34), -INT8_C( 103), -INT8_C( 101), INT8_C( 62), -INT8_C( 2), INT8_C( 105), -INT8_C( 79), + -INT8_C( 17), -INT8_C( 103), INT8_C( 110), INT8_C( 19), INT8_C( 44), -INT8_C( 15), -INT8_C( 48), -INT8_C( 80) } }, + { { -INT8_C( 44), INT8_C( 116), INT8_MIN, -INT8_C( 50), INT8_MIN, -INT8_C( 30), INT8_C( 30), -INT8_C( 20), + -INT8_C( 93), INT8_C( 45), -INT8_C( 110), INT8_C( 28), INT8_C( 114), -INT8_C( 88), -INT8_C( 57), INT8_C( 2) }, + { INT8_C( 94), INT8_C( 41), INT8_C( 12), -INT8_C( 119), INT8_C( 52), -INT8_C( 94), INT8_C( 33), -INT8_C( 116), + -INT8_C( 70), -INT8_C( 80), -INT8_C( 87), INT8_C( 61), -INT8_C( 98), INT8_C( 37), INT8_C( 94), INT8_C( 114) }, + { INT8_C( 71), INT8_C( 70), INT8_C( 120), INT8_C( 10), INT8_C( 14), INT8_C( 104), INT8_C( 16), INT8_C( 72), + -INT8_C( 53), -INT8_C( 117), -INT8_C( 109), INT8_C( 87), INT8_MIN, -INT8_C( 33), -INT8_C( 73), -INT8_C( 98) } }, + }; + + for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) { + simde__m128i a = simde_x_mm_loadu_epi8(test_vec[i].a); + simde__m128i b = simde_x_mm_loadu_epi8(test_vec[i].b); + simde__m128i r = simde_mm_aesdeclast_si128(a, b); + simde_test_x86_assert_equal_i8x16(r, simde_x_mm_loadu_epi8(test_vec[i].r)); + } + + return 0; +} + +static int +test_simde_mm_aesimc_si128 (SIMDE_MUNIT_TEST_ARGS) { + static const struct { + const int8_t a[16]; + const int8_t r[16]; + } test_vec[] = { + { { INT8_C( 11), INT8_C( 100), INT8_C( 93), -INT8_C( 105), -INT8_C( 56), INT8_C( 49), INT8_C( 0), INT8_C( 43), + -INT8_C( 38), INT8_C( 64), INT8_C( 10), INT8_C( 0), -INT8_C( 98), -INT8_C( 76), -INT8_C( 1), -INT8_C( 20) }, + { INT8_C( 108), INT8_C( 13), INT8_C( 107), -INT8_C( 81), INT8_C( 52), INT8_C( 35), INT8_C( 67), -INT8_C( 122), + -INT8_C( 28), -INT8_C( 77), INT8_C( 15), -INT8_C( 56), -INT8_C( 65), -INT8_C( 77), -INT8_C( 84), -INT8_C( 103) } }, + { { -INT8_C( 62), INT8_C( 41), INT8_C( 28), INT8_C( 57), INT8_C( 95), -INT8_C( 10), -INT8_C( 41), INT8_MAX, + INT8_C( 49), -INT8_C( 124), -INT8_C( 87), -INT8_C( 20), INT8_C( 69), INT8_C( 41), -INT8_C( 92), INT8_C( 80) }, + { -INT8_C( 66), -INT8_C( 25), -INT8_C( 25), INT8_C( 112), INT8_C( 9), -INT8_C( 81), -INT8_C( 125), INT8_C( 36), + INT8_C( 39), INT8_C( 84), INT8_C( 68), -INT8_C( 57), INT8_C( 0), -INT8_C( 29), -INT8_C( 54), -INT8_C( 79) } }, + { { -INT8_C( 115), INT8_C( 2), -INT8_C( 24), INT8_C( 86), INT8_C( 51), -INT8_C( 24), -INT8_C( 127), INT8_C( 13), + INT8_C( 40), -INT8_C( 117), INT8_C( 13), -INT8_C( 58), INT8_C( 64), INT8_C( 13), -INT8_C( 78), INT8_C( 2) }, + { -INT8_C( 91), INT8_C( 36), -INT8_C( 94), INT8_C( 18), -INT8_C( 71), INT8_C( 90), -INT8_C( 91), INT8_C( 17), + -INT8_C( 28), -INT8_C( 74), INT8_C( 17), INT8_C( 43), INT8_C( 107), INT8_C( 0), INT8_C( 120), -INT8_C( 18) } }, + { { INT8_C( 54), -INT8_C( 50), INT8_C( 59), -INT8_C( 107), -INT8_C( 59), INT8_C( 18), INT8_C( 20), -INT8_C( 10), + -INT8_C( 105), -INT8_C( 67), -INT8_C( 30), -INT8_C( 36), -INT8_C( 25), -INT8_C( 121), INT8_C( 44), INT8_C( 116) }, + { INT8_C( 57), -INT8_C( 104), -INT8_C( 104), INT8_C( 111), -INT8_C( 97), INT8_C( 37), INT8_C( 36), -INT8_C( 85), + -INT8_C( 72), INT8_C( 40), -INT8_C( 27), INT8_C( 97), -INT8_C( 59), -INT8_C( 56), INT8_C( 126), INT8_C( 75) } }, + { { -INT8_C( 119), INT8_C( 20), -INT8_C( 54), -INT8_C( 68), -INT8_C( 4), INT8_C( 75), -INT8_C( 55), INT8_C( 36), + -INT8_C( 41), -INT8_C( 42), -INT8_C( 22), INT8_C( 23), -INT8_C( 29), -INT8_C( 99), INT8_C( 25), INT8_C( 26) }, + { INT8_C( 77), -INT8_C( 41), -INT8_C( 61), -INT8_C( 78), -INT8_C( 31), INT8_C( 79), INT8_C( 96), -INT8_C( 108), + INT8_C( 124), -INT8_C( 38), -INT8_C( 94), -INT8_C( 8), INT8_C( 98), INT8_C( 28), INT8_C( 98), INT8_C( 97) } }, + { { INT8_C( 107), INT8_C( 84), -INT8_C( 81), INT8_C( 48), INT8_C( 102), -INT8_C( 60), INT8_C( 38), -INT8_C( 3), + -INT8_C( 127), INT8_C( 9), -INT8_C( 39), INT8_C( 104), -INT8_C( 112), INT8_C( 6), -INT8_C( 35), INT8_C( 25) }, + { -INT8_C( 1), -INT8_C( 27), INT8_C( 96), -INT8_C( 38), -INT8_C( 66), INT8_C( 99), INT8_C( 12), -INT8_C( 88), + INT8_C( 27), -INT8_C( 57), INT8_C( 49), -INT8_C( 44), INT8_C( 124), INT8_C( 35), -INT8_C( 107), -INT8_C( 104) } }, + { { INT8_C( 26), -INT8_C( 89), -INT8_C( 43), INT8_C( 23), -INT8_C( 13), -INT8_C( 98), INT8_C( 59), -INT8_C( 54), + INT8_C( 116), INT8_C( 38), -INT8_C( 31), INT8_C( 88), -INT8_C( 61), -INT8_C( 6), INT8_C( 114), INT8_C( 46) }, + { -INT8_C( 64), INT8_C( 31), -INT8_C( 15), INT8_C( 81), INT8_C( 52), -INT8_C( 108), -INT8_C( 33), -INT8_C( 29), + INT8_C( 64), -INT8_C( 94), INT8_C( 24), INT8_C( 17), INT8_C( 35), -INT8_C( 20), INT8_C( 88), -INT8_C( 14) } }, + { { INT8_C( 78), INT8_C( 33), INT8_C( 95), -INT8_C( 76), -INT8_C( 27), -INT8_C( 123), -INT8_C( 78), INT8_C( 103), + -INT8_C( 114), -INT8_C( 117), -INT8_C( 49), INT8_C( 30), -INT8_C( 111), -INT8_C( 84), INT8_C( 55), -INT8_C( 84) }, + { INT8_C( 28), INT8_C( 119), INT8_C( 30), -INT8_C( 15), INT8_C( 8), INT8_C( 36), INT8_C( 46), -INT8_C( 73), + -INT8_C( 75), INT8_C( 79), INT8_C( 71), INT8_C( 105), -INT8_C( 92), INT8_C( 96), INT8_C( 85), INT8_C( 55) } }, + }; + + for (size_t i = 0 ; i < (sizeof(test_vec) / sizeof(test_vec[0])) ; i++) { + simde__m128i a = simde_x_mm_loadu_epi8(test_vec[i].a); + simde__m128i r = simde_mm_aesimc_si128(a); + simde_test_x86_assert_equal_i8x16(r, simde_x_mm_loadu_epi8(test_vec[i].r)); + } + + return 0; +} + +SIMDE_TEST_FUNC_LIST_BEGIN + SIMDE_TEST_FUNC_LIST_ENTRY(mm_aesenc_si128) + SIMDE_TEST_FUNC_LIST_ENTRY(mm_aesdec_si128) + SIMDE_TEST_FUNC_LIST_ENTRY(mm_aesenclast_si128) + SIMDE_TEST_FUNC_LIST_ENTRY(mm_aesdeclast_si128) + SIMDE_TEST_FUNC_LIST_ENTRY(mm_aesimc_si128) +SIMDE_TEST_FUNC_LIST_END + +#include diff --git a/test/x86/meson.build b/test/x86/meson.build index 0434ad25f..c3d80f768 100644 --- a/test/x86/meson.build +++ b/test/x86/meson.build @@ -13,7 +13,8 @@ simde_test_x86_tests = [ 'gfni', 'clmul', 'svml', - 'xop' + 'xop', + 'aes' ] subdir('avx512')