26864473078

Committed 02 Jun 2026 07:58PM UTC coverage: 89.389% (+0.02%) from 89.37%

Build # 26864473078

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5639 from randombit/jack/sm4-hwaes-ks

Add hwaes hook for SM4 key schedule

Coverage Stats

110434 of 123543 relevant lines covered (89.39%)

11152828.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.15

/src/tests/test_simd.cpp

/*
* (C) 2017 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "tests.h"

#include <botan/hex.h>
#include <botan/internal/bswap.h>
#include <botan/internal/concat_util.h>
#include <botan/internal/isa_extn.h>
#include <botan/internal/loadstor.h>
#include <botan/internal/rotate.h>

#if defined(BOTAN_HAS_SIMD_4X32)
   #include <botan/internal/simd_4x32.h>
#endif

#if defined(BOTAN_HAS_SIMD_2X64)
   #include <botan/internal/simd_2x64.h>
#endif

#if defined(BOTAN_HAS_CPUID)
   #include <botan/internal/cpuid.h>
#endif

namespace Botan_Tests {

namespace {

#if defined(BOTAN_HAS_SIMD_4X32) && defined(BOTAN_HAS_CPUID)

class SIMD_4X32_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         if(!Botan::CPUID::has(Botan::CPUID::Feature::SIMD_4X32)) {
            return {Test::Result::Note("simd_4x32", "Skipping tests due to missing SIMD support at runtime")};
         } else {
            return {test_simd_4x32()};
         }
      }

   private:
      Test::Result BOTAN_FN_ISA_SIMD_4X32 test_simd_4x32() {
         Test::Result result("SIMD_4x32");

         const uint32_t pat1 = 0xAABBCCDD;
         const uint32_t pat2 = 0x87654321;
         const uint32_t pat3 = 0x01234567;
         const uint32_t pat4 = 0xC0D0E0F0;

         // pat1 + pat{1,2,3,4}
         // precomputed to avoid integer overflow warnings
         const uint32_t pat1_1 = 0x557799BA;
         const uint32_t pat1_2 = 0x32210FFE;
         const uint32_t pat1_3 = 0xABDF1244;
         const uint32_t pat1_4 = 0x6B8CADCD;

         test_eq(result, "default init", Botan::SIMD_4x32(), 0, 0, 0, 0);
         test_eq(result, "SIMD scalar constructor", Botan::SIMD_4x32(1, 2, 3, 4), 1, 2, 3, 4);

         const Botan::SIMD_4x32 splat = Botan::SIMD_4x32::splat(pat1);

         test_eq(result, "splat", splat, pat1, pat1, pat1, pat1);

         const Botan::SIMD_4x32 input(pat1, pat2, pat3, pat4);

         result.test_u32_eq("SIMD_4x32::extract_word<0>", input.extract_word<0>(), pat1);
         result.test_u32_eq("SIMD_4x32::extract_word<1>", input.extract_word<1>(), pat2);
         result.test_u32_eq("SIMD_4x32::extract_word<2>", input.extract_word<2>(), pat3);
         result.test_u32_eq("SIMD_4x32::extract_word<3>", input.extract_word<3>(), pat4);

         const Botan::SIMD_4x32 rol = input.rotl<3>();

         test_eq(result,
                 "rotl",
                 rol,
                 Botan::rotl<3>(pat1),
                 Botan::rotl<3>(pat2),
                 Botan::rotl<3>(pat3),
                 Botan::rotl<3>(pat4));

         const Botan::SIMD_4x32 ror = input.rotr<9>();

         test_eq(result,
                 "rotr",
                 ror,
                 Botan::rotr<9>(pat1),
                 Botan::rotr<9>(pat2),
                 Botan::rotr<9>(pat3),
                 Botan::rotr<9>(pat4));

         Botan::SIMD_4x32 add = input + splat;
         test_eq(result, "add +", add, pat1_1, pat1_2, pat1_3, pat1_4);

         add -= splat;
         test_eq(result, "sub -=", add, pat1, pat2, pat3, pat4);

         add += splat;
         test_eq(result, "add +=", add, pat1_1, pat1_2, pat1_3, pat1_4);

         test_eq(result, "xor", input ^ splat, 0, pat2 ^ pat1, pat3 ^ pat1, pat4 ^ pat1);
         test_eq(result, "or", input | splat, pat1, pat2 | pat1, pat3 | pat1, pat4 | pat1);
         test_eq(result, "and", input & splat, pat1, pat2 & pat1, pat3 & pat1, pat4 & pat1);

         Botan::SIMD_4x32 blender = input;
         blender |= splat;
         test_eq(result, "|=", blender, pat1, pat2 | pat1, pat3 | pat1, pat4 | pat1);
         blender &= splat;
         test_eq(result, "&=", blender, pat1, pat1, pat1, pat1);
         blender ^= splat;
         test_eq(result, "^=", blender, 0, 0, 0, 0);

         blender = ~blender;
         test_eq(result, "~", blender, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);

         blender = blender.shr<23>();
         test_eq(result, ">>", blender, 0x1FF, 0x1FF, 0x1FF, 0x1FF);

         blender = blender.shl<27>();
         test_eq(result, "<<", blender, 0xF8000000, 0xF8000000, 0xF8000000, 0xF8000000);

         blender = ~blender;
         test_eq(result, "~", blender, 0x7FFFFFF, 0x7FFFFFF, 0x7FFFFFF, 0x7FFFFFF);

         blender = input.andc(~blender);
         test_eq(
            result, "andc", blender, ~pat1 & 0xF8000000, ~pat2 & 0xF8000000, ~pat3 & 0xF8000000, ~pat4 & 0xF8000000);

         test_eq(result,
                 "bswap",
                 input.bswap(),
                 Botan::reverse_bytes(pat1),
                 Botan::reverse_bytes(pat2),
                 Botan::reverse_bytes(pat3),
                 Botan::reverse_bytes(pat4));

         Botan::SIMD_4x32 t1(pat1, pat2, pat3, pat4);
         Botan::SIMD_4x32 t2(pat1 + 1, pat2 + 1, pat3 + 1, pat4 + 1);
         Botan::SIMD_4x32 t3(pat1 + 2, pat2 + 2, pat3 + 2, pat4 + 2);
         Botan::SIMD_4x32 t4(pat1 + 3, pat2 + 3, pat3 + 3, pat4 + 3);

         Botan::SIMD_4x32::transpose(t1, t2, t3, t4);

         test_eq(result, "transpose t1", t1, pat1, pat1 + 1, pat1 + 2, pat1 + 3);
         test_eq(result, "transpose t2", t2, pat2, pat2 + 1, pat2 + 2, pat2 + 3);
         test_eq(result, "transpose t3", t3, pat3, pat3 + 1, pat3 + 2, pat3 + 3);
         test_eq(result, "transpose t4", t4, pat4, pat4 + 1, pat4 + 2, pat4 + 3);

         test_eq(result, "shift left 1", input.shift_elems_left<1>(), 0, pat1, pat2, pat3);
         test_eq(result, "shift left 2", input.shift_elems_left<2>(), 0, 0, pat1, pat2);
         test_eq(result, "shift left 3", input.shift_elems_left<3>(), 0, 0, 0, pat1);

         test_eq(result, "shift right 1", input.shift_elems_right<1>(), pat2, pat3, pat4, 0);
         test_eq(result, "shift right 2", input.shift_elems_right<2>(), pat3, pat4, 0, 0);
         test_eq(result, "shift right 3", input.shift_elems_right<3>(), pat4, 0, 0, 0);

         // Test load/stores SIMD wrapper types
         const auto simd_le_in = Botan::hex_decode("ABCDEF01234567890123456789ABCDEF");
         const auto simd_be_in = Botan::hex_decode("0123456789ABCDEFABCDEF0123456789");
         const auto simd_le_array_in = Botan::concat(simd_le_in, simd_be_in);
         const auto simd_be_array_in = Botan::concat(simd_be_in, simd_le_in);

         auto simd_le = Botan::load_le<Botan::SIMD_4x32>(simd_le_in);
         auto simd_be = Botan::load_be<Botan::SIMD_4x32>(simd_be_in);
         auto simd_le_array = Botan::load_le<std::array<Botan::SIMD_4x32, 2>>(simd_le_array_in);
         auto simd_be_array = Botan::load_be<std::array<Botan::SIMD_4x32, 2>>(simd_be_array_in);

         auto simd_le_vec = Botan::store_le<std::vector<uint8_t>>(simd_le);
         auto simd_be_vec = Botan::store_be(simd_be);
         auto simd_le_array_vec = Botan::store_le<std::vector<uint8_t>>(simd_le_array);
         auto simd_be_array_vec = Botan::store_be(simd_be_array);

         result.test_bin_eq("roundtrip SIMD little-endian", simd_le_vec, simd_le_in);
         result.test_bin_eq(
            "roundtrip SIMD big-endian", std::vector(simd_be_vec.begin(), simd_be_vec.end()), simd_be_in);
         result.test_bin_eq("roundtrip SIMD array little-endian", simd_le_array_vec, simd_le_array_in);
         result.test_bin_eq("roundtrip SIMD array big-endian",
                            std::vector(simd_be_array_vec.begin(), simd_be_array_vec.end()),
                            simd_be_array_in);

         using StrongSIMD = Botan::Strong<Botan::SIMD_4x32, struct StrongSIMD_>;
         const auto simd_le_strong = Botan::load_le<StrongSIMD>(simd_le_in);
         const auto simd_be_strong = Botan::load_be<StrongSIMD>(simd_be_in);

         result.test_bin_eq(
            "roundtrip SIMD strong little-endian", Botan::store_le<std::vector<uint8_t>>(simd_le_strong), simd_le_in);
         result.test_bin_eq(
            "roundtrip SIMD strong big-endian", Botan::store_be<std::vector<uint8_t>>(simd_be_strong), simd_be_in);

         return {result};
      }

      static void BOTAN_FN_ISA_SIMD_4X32 test_eq(Test::Result& result,
                                                 const std::string& op,
                                                 const Botan::SIMD_4x32& simd,
                                                 uint32_t exp0,
                                                 uint32_t exp1,
                                                 uint32_t exp2,
                                                 uint32_t exp3) {
         uint8_t arr_be[16 + 15];
         uint8_t arr_be2[16 + 15];
         uint8_t arr_le[16 + 15];
         uint8_t arr_le2[16 + 15];

         for(size_t misalignment = 0; misalignment != 16; ++misalignment) {
            uint8_t* mem_be = arr_be + misalignment;
            uint8_t* mem_be2 = arr_be2 + misalignment;
            uint8_t* mem_le = arr_le + misalignment;
            uint8_t* mem_le2 = arr_le2 + misalignment;

            simd.store_be(mem_be);

            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem0 BE", Botan::make_uint32(mem_be[0], mem_be[1], mem_be[2], mem_be[3]), exp0);
            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem1 BE", Botan::make_uint32(mem_be[4], mem_be[5], mem_be[6], mem_be[7]), exp1);
            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem2 BE", Botan::make_uint32(mem_be[8], mem_be[9], mem_be[10], mem_be[11]), exp2);
            result.test_u32_eq("SIMD_4x32 " + op + " elem3 BE",
                               Botan::make_uint32(mem_be[12], mem_be[13], mem_be[14], mem_be[15]),
                               exp3);

            // Check load_be+store_be results in same value
            const Botan::SIMD_4x32 reloaded_be = Botan::SIMD_4x32::load_be(mem_be);
            reloaded_be.store_be(mem_be2);
            result.test_bin_eq("SIMD_4x32 load_be", {mem_be, 16}, {mem_be2, 16});

            simd.store_le(mem_le);

            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem0 LE", Botan::make_uint32(mem_le[3], mem_le[2], mem_le[1], mem_le[0]), exp0);
            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem1 LE", Botan::make_uint32(mem_le[7], mem_le[6], mem_le[5], mem_le[4]), exp1);
            result.test_u32_eq(
               "SIMD_4x32 " + op + " elem2 LE", Botan::make_uint32(mem_le[11], mem_le[10], mem_le[9], mem_le[8]), exp2);
            result.test_u32_eq("SIMD_4x32 " + op + " elem3 LE",
                               Botan::make_uint32(mem_le[15], mem_le[14], mem_le[13], mem_le[12]),
                               exp3);

            // Check load_le+store_le results in same value
            const Botan::SIMD_4x32 reloaded_le = Botan::SIMD_4x32::load_le(mem_le);
            reloaded_le.store_le(mem_le2);
            result.test_bin_eq("SIMD_4x32 load_le", {mem_le, 16}, {mem_le2, 16});
         }
      }
};

BOTAN_REGISTER_TEST("utils", "simd_4x32", SIMD_4X32_Tests);
#endif

#if defined(BOTAN_HAS_SIMD_2X64) && defined(BOTAN_HAS_CPUID)

class SIMD_2X64_Tests final : public Test {
   public:
      std::vector<Test::Result> BOTAN_FN_ISA_SIMD_2X64 run() override {
         if(!Botan::CPUID::has(Botan::CPUID::Feature::SIMD_2X64)) {
            return {Test::Result::Note("simd_2x64", "Skipping tests due to missing SIMD support at runtime")};
         } else {
            return {test_simd_2x64()};
         }
      }

   private:
      Test::Result BOTAN_FN_ISA_SIMD_2X64 test_simd_2x64() {
         Test::Result result("SIMD_2x64");

         const uint64_t pat1 = 0x2F8C91D4A37E5C10;
         const uint64_t pat2 = 0x1B74A6F8C29D1345;

         const uint64_t pat1_1 = pat1 + pat1;
         const uint64_t pat1_2 = pat1 + pat2;

         test_eq(result, "default init", Botan::SIMD_2x64(), 0, 0);
         test_eq(result, "SIMD scalar constructor", Botan::SIMD_2x64(1, 2), 1, 2);

         const auto input = Botan::SIMD_2x64(pat1, pat2);
         const auto splat = Botan::SIMD_2x64(pat1, pat1);

         const auto rotl = input.rotl<3>();
         test_eq(result, "rotl", rotl, Botan::rotl<3>(pat1), Botan::rotl<3>(pat2));

         const auto rotr = input.rotr<9>();
         test_eq(result, "rotr", rotr, Botan::rotr<9>(pat1), Botan::rotr<9>(pat2));

         test_eq(result, "rotr<8>", input.rotr<8>(), Botan::rotr<8>(pat1), Botan::rotr<8>(pat2));
         test_eq(result, "rotr<16>", input.rotr<16>(), Botan::rotr<16>(pat1), Botan::rotr<16>(pat2));
         test_eq(result, "rotr<24>", input.rotr<24>(), Botan::rotr<24>(pat1), Botan::rotr<24>(pat2));
         test_eq(result, "rotr<32>", input.rotr<32>(), Botan::rotr<32>(pat1), Botan::rotr<32>(pat2));

         const auto add = input + splat;
         test_eq(result, "add +", add, pat1_1, pat1_2);

         test_eq(result, "xor", input ^ splat, 0, pat2 ^ pat1);

         auto shifter = Botan::SIMD_2x64(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);
         shifter = shifter.shr<23>();
         test_eq(result, ">>", shifter, 0x1FFFFFFFFFF, 0x1FFFFFFFFFF);

         shifter = shifter.shl<27>();
         test_eq(result, "<<", shifter, 0xFFFFFFFFF8000000, 0xFFFFFFFFF8000000);

         shifter = input.andc(shifter);
         test_eq(result, "andc", shifter, ~pat1 & 0xFFFFFFFFF8000000, ~pat2 & 0xFFFFFFFFF8000000);

         test_eq(result, "bswap", input.bswap(), Botan::reverse_bytes(pat1), Botan::reverse_bytes(pat2));

         test_eq(result,
                 "reverse_all_bytes",
                 Botan::SIMD_2x64(0x0001020304050607, 0x08090a0b0c0d0e0f).reverse_all_bytes(),
                 0x0f0e0d0c0b0a0908,
                 0x0706050403020100);

         test_eq(result, "swap_lanes", Botan::SIMD_2x64(pat1, pat2).swap_lanes(), pat2, pat1);

         const auto interleave_a = Botan::SIMD_2x64(0x1111111122222222, 0x3333333344444444);
         const auto interleave_b = Botan::SIMD_2x64(0x5555555566666666, 0x7777777788888888);
         test_eq(result,
                 "interleave_high",
                 Botan::SIMD_2x64::interleave_high(interleave_a, interleave_b),
                 0x3333333344444444,
                 0x7777777788888888);

         test_eq(result,
                 "interleave_low",
                 Botan::SIMD_2x64::interleave_low(interleave_a, interleave_b),
                 0x1111111122222222,
                 0x5555555566666666);

         test_eq(result, "all_ones", Botan::SIMD_2x64::all_ones(), 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);

         // Test load/stores SIMD wrapper types
         const auto simd_le_in = Botan::hex_decode("ABCDEF01234567890123456789ABCDEF");
         const auto simd_be_in = Botan::hex_decode("0123456789ABCDEFABCDEF0123456789");
         const auto simd_le_array_in = Botan::concat(simd_le_in, simd_be_in);
         const auto simd_be_array_in = Botan::concat(simd_be_in, simd_le_in);

         auto simd_le = Botan::load_le<Botan::SIMD_2x64>(simd_le_in);
         auto simd_be = Botan::load_be<Botan::SIMD_2x64>(simd_be_in);
         auto simd_le_array = Botan::load_le<std::array<Botan::SIMD_2x64, 2>>(simd_le_array_in);
         auto simd_be_array = Botan::load_be<std::array<Botan::SIMD_2x64, 2>>(simd_be_array_in);

         auto simd_le_vec = Botan::store_le<std::vector<uint8_t>>(simd_le);
         auto simd_be_vec = Botan::store_be(simd_be);
         auto simd_le_array_vec = Botan::store_le<std::vector<uint8_t>>(simd_le_array);
         auto simd_be_array_vec = Botan::store_be(simd_be_array);

         result.test_bin_eq("roundtrip SIMD little-endian", simd_le_vec, simd_le_in);
         result.test_bin_eq(
            "roundtrip SIMD big-endian", std::vector(simd_be_vec.begin(), simd_be_vec.end()), simd_be_in);
         result.test_bin_eq("roundtrip SIMD array little-endian", simd_le_array_vec, simd_le_array_in);
         result.test_bin_eq("roundtrip SIMD array big-endian",
                            std::vector(simd_be_array_vec.begin(), simd_be_array_vec.end()),
                            simd_be_array_in);

         using StrongSIMD = Botan::Strong<Botan::SIMD_2x64, struct StrongSIMD_>;
         const auto simd_le_strong = Botan::load_le<StrongSIMD>(simd_le_in);
         const auto simd_be_strong = Botan::load_be<StrongSIMD>(simd_be_in);

         result.test_bin_eq(
            "roundtrip SIMD strong little-endian", Botan::store_le<std::vector<uint8_t>>(simd_le_strong), simd_le_in);
         result.test_bin_eq(
            "roundtrip SIMD strong big-endian", Botan::store_be<std::vector<uint8_t>>(simd_be_strong), simd_be_in);

         return {result};
      }

   private:
      static void BOTAN_FN_ISA_SIMD_2X64
      test_eq(Test::Result& result, const std::string& op, const Botan::SIMD_2x64& simd, uint64_t exp0, uint64_t exp1) {
         uint8_t arr_be[16 + 15];
         uint8_t arr_be2[16 + 15];
         uint8_t arr_le[16 + 15];
         uint8_t arr_le2[16 + 15];

         for(size_t misalignment = 0; misalignment != 16; ++misalignment) {
            uint8_t* mem_be = arr_be + misalignment;
            uint8_t* mem_be2 = arr_be2 + misalignment;
            uint8_t* mem_le = arr_le + misalignment;
            uint8_t* mem_le2 = arr_le2 + misalignment;

            simd.store_be(mem_be);

            result.test_u64_eq(
               "SIMD_2x64 " + op + " elem0 BE",
               Botan::make_uint64(
                  mem_be[0], mem_be[1], mem_be[2], mem_be[3], mem_be[4], mem_be[5], mem_be[6], mem_be[7]),
               exp0);
            result.test_u64_eq(
               "SIMD_2x64 " + op + " elem1 BE",
               Botan::make_uint64(
                  mem_be[8], mem_be[9], mem_be[10], mem_be[11], mem_be[12], mem_be[13], mem_be[14], mem_be[15]),
               exp1);

            // Check load_be+store_be results in same value
            const Botan::SIMD_2x64 reloaded_be = Botan::SIMD_2x64::load_be(mem_be);
            reloaded_be.store_be(mem_be2);
            result.test_bin_eq("SIMD_2x64 load_be", {mem_be, 16}, {mem_be2, 16});

            simd.store_le(mem_le);

            result.test_u64_eq(
               "SIMD_2x64 " + op + " elem0 LE",
               Botan::make_uint64(
                  mem_le[7], mem_le[6], mem_le[5], mem_le[4], mem_le[3], mem_le[2], mem_le[1], mem_le[0]),
               exp0);
            result.test_u64_eq(
               "SIMD_2x64 " + op + " elem1 LE",
               Botan::make_uint64(
                  mem_le[15], mem_le[14], mem_le[13], mem_le[12], mem_le[11], mem_le[10], mem_le[9], mem_le[8]),
               exp1);

            // Check load_le+store_le results in same value
            const Botan::SIMD_2x64 reloaded_le = Botan::SIMD_2x64::load_le(mem_le);
            reloaded_le.store_le(mem_le2);
            result.test_bin_eq("SIMD_2x64 load_le", {mem_le, 16}, {mem_le2, 16});
         }
      }
};

BOTAN_REGISTER_TEST("utils", "simd_2x64", SIMD_2X64_Tests);
#endif

}  // namespace

}  // namespace Botan_Tests

1	/*
2	* (C) 2017 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "tests.h"
8
9	#include <botan/hex.h>
10	#include <botan/internal/bswap.h>
11	#include <botan/internal/concat_util.h>
12	#include <botan/internal/isa_extn.h>
13	#include <botan/internal/loadstor.h>
14	#include <botan/internal/rotate.h>
15
16	#if defined(BOTAN_HAS_SIMD_4X32)
17	#include <botan/internal/simd_4x32.h>
18	#endif
19
20	#if defined(BOTAN_HAS_SIMD_2X64)
21	#include <botan/internal/simd_2x64.h>
22	#endif
23
24	#if defined(BOTAN_HAS_CPUID)
25	#include <botan/internal/cpuid.h>
26	#endif
27
28	namespace Botan_Tests {
29
30	namespace {
31
32	#if defined(BOTAN_HAS_SIMD_4X32) && defined(BOTAN_HAS_CPUID)
33
34	class SIMD_4X32_Tests final : public Test {	1✔
35	public:
36	std::vector<Test::Result> run() override {	1✔
37	if(!Botan::CPUID::has(Botan::CPUID::Feature::SIMD_4X32)) {	1✔
38	return {Test::Result::Note("simd_4x32", "Skipping tests due to missing SIMD support at runtime")};	×
39	} else {
40	return {test_simd_4x32()};	2✔
41	}
42	}	1✔
43
44	private:
45	Test::Result BOTAN_FN_ISA_SIMD_4X32 test_simd_4x32() {	1✔
46	Test::Result result("SIMD_4x32");	1✔
47
48	const uint32_t pat1 = 0xAABBCCDD;	1✔
49	const uint32_t pat2 = 0x87654321;	1✔
50	const uint32_t pat3 = 0x01234567;	1✔
51	const uint32_t pat4 = 0xC0D0E0F0;	1✔
52
53	// pat1 + pat{1,2,3,4}
54	// precomputed to avoid integer overflow warnings
55	const uint32_t pat1_1 = 0x557799BA;	1✔
56	const uint32_t pat1_2 = 0x32210FFE;	1✔
57	const uint32_t pat1_3 = 0xABDF1244;	1✔
58	const uint32_t pat1_4 = 0x6B8CADCD;	1✔
59
60	test_eq(result, "default init", Botan::SIMD_4x32(), 0, 0, 0, 0);	1✔
61	test_eq(result, "SIMD scalar constructor", Botan::SIMD_4x32(1, 2, 3, 4), 1, 2, 3, 4);	1✔
62
63	const Botan::SIMD_4x32 splat = Botan::SIMD_4x32::splat(pat1);	1✔
64
65	test_eq(result, "splat", splat, pat1, pat1, pat1, pat1);	1✔
66
67	const Botan::SIMD_4x32 input(pat1, pat2, pat3, pat4);	1✔
68
69	result.test_u32_eq("SIMD_4x32::extract_word<0>", input.extract_word<0>(), pat1);	1✔
70	result.test_u32_eq("SIMD_4x32::extract_word<1>", input.extract_word<1>(), pat2);	1✔
71	result.test_u32_eq("SIMD_4x32::extract_word<2>", input.extract_word<2>(), pat3);	1✔
72	result.test_u32_eq("SIMD_4x32::extract_word<3>", input.extract_word<3>(), pat4);	1✔
73
74	const Botan::SIMD_4x32 rol = input.rotl<3>();	1✔
75
76	test_eq(result,	1✔
77	"rotl",
78	rol,
79	Botan::rotl<3>(pat1),
80	Botan::rotl<3>(pat2),
81	Botan::rotl<3>(pat3),
82	Botan::rotl<3>(pat4));
83
84	const Botan::SIMD_4x32 ror = input.rotr<9>();	1✔
85
86	test_eq(result,	1✔
87	"rotr",
88	ror,
89	Botan::rotr<9>(pat1),
90	Botan::rotr<9>(pat2),
91	Botan::rotr<9>(pat3),
92	Botan::rotr<9>(pat4));
93
94	Botan::SIMD_4x32 add = input + splat;	1✔
95	test_eq(result, "add +", add, pat1_1, pat1_2, pat1_3, pat1_4);	1✔
96
97	add -= splat;	1✔
98	test_eq(result, "sub -=", add, pat1, pat2, pat3, pat4);	1✔
99
100	add += splat;	1✔
101	test_eq(result, "add +=", add, pat1_1, pat1_2, pat1_3, pat1_4);	1✔
102
103	test_eq(result, "xor", input ^ splat, 0, pat2 ^ pat1, pat3 ^ pat1, pat4 ^ pat1);	1✔
104	test_eq(result, "or", input \| splat, pat1, pat2 \| pat1, pat3 \| pat1, pat4 \| pat1);	1✔
105	test_eq(result, "and", input & splat, pat1, pat2 & pat1, pat3 & pat1, pat4 & pat1);	1✔
106
107	Botan::SIMD_4x32 blender = input;	1✔
108	blender \|= splat;	1✔
109	test_eq(result, "\|=", blender, pat1, pat2 \| pat1, pat3 \| pat1, pat4 \| pat1);	1✔
110	blender &= splat;	1✔
111	test_eq(result, "&=", blender, pat1, pat1, pat1, pat1);	1✔
112	blender ^= splat;	1✔
113	test_eq(result, "^=", blender, 0, 0, 0, 0);	1✔
114
115	blender = ~blender;	1✔
116	test_eq(result, "~", blender, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF);	1✔
117
118	blender = blender.shr<23>();	1✔
119	test_eq(result, ">>", blender, 0x1FF, 0x1FF, 0x1FF, 0x1FF);	1✔
120
121	blender = blender.shl<27>();	1✔
122	test_eq(result, "<<", blender, 0xF8000000, 0xF8000000, 0xF8000000, 0xF8000000);	1✔
123
124	blender = ~blender;	1✔
125	test_eq(result, "~", blender, 0x7FFFFFF, 0x7FFFFFF, 0x7FFFFFF, 0x7FFFFFF);	1✔
126
127	blender = input.andc(~blender);	1✔
128	test_eq(	1✔
129	result, "andc", blender, ~pat1 & 0xF8000000, ~pat2 & 0xF8000000, ~pat3 & 0xF8000000, ~pat4 & 0xF8000000);
130
131	test_eq(result,	1✔
132	"bswap",
133	input.bswap(),	1✔
134	Botan::reverse_bytes(pat1),
135	Botan::reverse_bytes(pat2),
136	Botan::reverse_bytes(pat3),
137	Botan::reverse_bytes(pat4));
138
139	Botan::SIMD_4x32 t1(pat1, pat2, pat3, pat4);	1✔
140	Botan::SIMD_4x32 t2(pat1 + 1, pat2 + 1, pat3 + 1, pat4 + 1);	1✔
141	Botan::SIMD_4x32 t3(pat1 + 2, pat2 + 2, pat3 + 2, pat4 + 2);	1✔
142	Botan::SIMD_4x32 t4(pat1 + 3, pat2 + 3, pat3 + 3, pat4 + 3);	1✔
143
144	Botan::SIMD_4x32::transpose(t1, t2, t3, t4);	1✔
145
146	test_eq(result, "transpose t1", t1, pat1, pat1 + 1, pat1 + 2, pat1 + 3);	1✔
147	test_eq(result, "transpose t2", t2, pat2, pat2 + 1, pat2 + 2, pat2 + 3);	1✔
148	test_eq(result, "transpose t3", t3, pat3, pat3 + 1, pat3 + 2, pat3 + 3);	1✔
149	test_eq(result, "transpose t4", t4, pat4, pat4 + 1, pat4 + 2, pat4 + 3);	1✔
150
151	test_eq(result, "shift left 1", input.shift_elems_left<1>(), 0, pat1, pat2, pat3);	1✔
152	test_eq(result, "shift left 2", input.shift_elems_left<2>(), 0, 0, pat1, pat2);	1✔
153	test_eq(result, "shift left 3", input.shift_elems_left<3>(), 0, 0, 0, pat1);	1✔
154
155	test_eq(result, "shift right 1", input.shift_elems_right<1>(), pat2, pat3, pat4, 0);	1✔
156	test_eq(result, "shift right 2", input.shift_elems_right<2>(), pat3, pat4, 0, 0);	1✔
157	test_eq(result, "shift right 3", input.shift_elems_right<3>(), pat4, 0, 0, 0);	1✔
158
159	// Test load/stores SIMD wrapper types
160	const auto simd_le_in = Botan::hex_decode("ABCDEF01234567890123456789ABCDEF");	1✔
161	const auto simd_be_in = Botan::hex_decode("0123456789ABCDEFABCDEF0123456789");	1✔
162	const auto simd_le_array_in = Botan::concat(simd_le_in, simd_be_in);	1✔
163	const auto simd_be_array_in = Botan::concat(simd_be_in, simd_le_in);	1✔
164
165	auto simd_le = Botan::load_le<Botan::SIMD_4x32>(simd_le_in);	1✔
166	auto simd_be = Botan::load_be<Botan::SIMD_4x32>(simd_be_in);	1✔
167	auto simd_le_array = Botan::load_le<std::array<Botan::SIMD_4x32, 2>>(simd_le_array_in);	1✔
168	auto simd_be_array = Botan::load_be<std::array<Botan::SIMD_4x32, 2>>(simd_be_array_in);	1✔
169
170	auto simd_le_vec = Botan::store_le<std::vector<uint8_t>>(simd_le);	1✔
171	auto simd_be_vec = Botan::store_be(simd_be);	1✔
172	auto simd_le_array_vec = Botan::store_le<std::vector<uint8_t>>(simd_le_array);	1✔
173	auto simd_be_array_vec = Botan::store_be(simd_be_array);	1✔
174
175	result.test_bin_eq("roundtrip SIMD little-endian", simd_le_vec, simd_le_in);	1✔
176	result.test_bin_eq(	1✔
177	"roundtrip SIMD big-endian", std::vector(simd_be_vec.begin(), simd_be_vec.end()), simd_be_in);	1✔
178	result.test_bin_eq("roundtrip SIMD array little-endian", simd_le_array_vec, simd_le_array_in);	1✔
179	result.test_bin_eq("roundtrip SIMD array big-endian",	1✔
180	std::vector(simd_be_array_vec.begin(), simd_be_array_vec.end()),	1✔
181	simd_be_array_in);
182
183	using StrongSIMD = Botan::Strong<Botan::SIMD_4x32, struct StrongSIMD_>;	1✔
184	const auto simd_le_strong = Botan::load_le<StrongSIMD>(simd_le_in);	1✔
185	const auto simd_be_strong = Botan::load_be<StrongSIMD>(simd_be_in);	1✔
186
187	result.test_bin_eq(	1✔
188	"roundtrip SIMD strong little-endian", Botan::store_le<std::vector<uint8_t>>(simd_le_strong), simd_le_in);	1✔
189	result.test_bin_eq(	1✔
190	"roundtrip SIMD strong big-endian", Botan::store_be<std::vector<uint8_t>>(simd_be_strong), simd_be_in);	1✔
191
192	return {result};	2✔
193	}	6✔
194
195	static void BOTAN_FN_ISA_SIMD_4X32 test_eq(Test::Result& result,	30✔
196	const std::string& op,
197	const Botan::SIMD_4x32& simd,
198	uint32_t exp0,
199	uint32_t exp1,
200	uint32_t exp2,
201	uint32_t exp3) {
202	uint8_t arr_be[16 + 15];	30✔
203	uint8_t arr_be2[16 + 15];	30✔
204	uint8_t arr_le[16 + 15];	30✔
205	uint8_t arr_le2[16 + 15];	30✔
206
207	for(size_t misalignment = 0; misalignment != 16; ++misalignment) {	510✔
208	uint8_t* mem_be = arr_be + misalignment;	480✔
209	uint8_t* mem_be2 = arr_be2 + misalignment;	480✔
210	uint8_t* mem_le = arr_le + misalignment;	480✔
211	uint8_t* mem_le2 = arr_le2 + misalignment;	480✔
212
213	simd.store_be(mem_be);	480✔
214
215	result.test_u32_eq(	960✔
216	"SIMD_4x32 " + op + " elem0 BE", Botan::make_uint32(mem_be[0], mem_be[1], mem_be[2], mem_be[3]), exp0);	1,440✔
217	result.test_u32_eq(	480✔
218	"SIMD_4x32 " + op + " elem1 BE", Botan::make_uint32(mem_be[4], mem_be[5], mem_be[6], mem_be[7]), exp1);	1,440✔
219	result.test_u32_eq(	480✔
220	"SIMD_4x32 " + op + " elem2 BE", Botan::make_uint32(mem_be[8], mem_be[9], mem_be[10], mem_be[11]), exp2);	1,440✔
221	result.test_u32_eq("SIMD_4x32 " + op + " elem3 BE",	960✔
222	Botan::make_uint32(mem_be[12], mem_be[13], mem_be[14], mem_be[15]),	480✔
223	exp3);
224
225	// Check load_be+store_be results in same value
226	const Botan::SIMD_4x32 reloaded_be = Botan::SIMD_4x32::load_be(mem_be);	480✔
227	reloaded_be.store_be(mem_be2);	480✔
228	result.test_bin_eq("SIMD_4x32 load_be", {mem_be, 16}, {mem_be2, 16});	480✔
229
230	simd.store_le(mem_le);	480✔
231
232	result.test_u32_eq(	960✔
233	"SIMD_4x32 " + op + " elem0 LE", Botan::make_uint32(mem_le[3], mem_le[2], mem_le[1], mem_le[0]), exp0);	1,440✔
234	result.test_u32_eq(	480✔
235	"SIMD_4x32 " + op + " elem1 LE", Botan::make_uint32(mem_le[7], mem_le[6], mem_le[5], mem_le[4]), exp1);	1,440✔
236	result.test_u32_eq(	480✔
237	"SIMD_4x32 " + op + " elem2 LE", Botan::make_uint32(mem_le[11], mem_le[10], mem_le[9], mem_le[8]), exp2);	1,440✔
238	result.test_u32_eq("SIMD_4x32 " + op + " elem3 LE",	960✔
239	Botan::make_uint32(mem_le[15], mem_le[14], mem_le[13], mem_le[12]),	480✔
240	exp3);
241
242	// Check load_le+store_le results in same value
243	const Botan::SIMD_4x32 reloaded_le = Botan::SIMD_4x32::load_le(mem_le);	480✔
244	reloaded_le.store_le(mem_le2);	480✔
245	result.test_bin_eq("SIMD_4x32 load_le", {mem_le, 16}, {mem_le2, 16});	480✔
246	}
247	}	30✔
248	};
249
250	BOTAN_REGISTER_TEST("utils", "simd_4x32", SIMD_4X32_Tests);
251	#endif
252
253	#if defined(BOTAN_HAS_SIMD_2X64) && defined(BOTAN_HAS_CPUID)
254
255	class SIMD_2X64_Tests final : public Test {	1✔
256	public:
257	std::vector<Test::Result> BOTAN_FN_ISA_SIMD_2X64 run() override {	1✔
258	if(!Botan::CPUID::has(Botan::CPUID::Feature::SIMD_2X64)) {	1✔
259	return {Test::Result::Note("simd_2x64", "Skipping tests due to missing SIMD support at runtime")};	×
260	} else {
261	return {test_simd_2x64()};	2✔
262	}
263	}	1✔
264
265	private:
266	Test::Result BOTAN_FN_ISA_SIMD_2X64 test_simd_2x64() {	1✔
267	Test::Result result("SIMD_2x64");	1✔
268
269	const uint64_t pat1 = 0x2F8C91D4A37E5C10;	1✔
270	const uint64_t pat2 = 0x1B74A6F8C29D1345;	1✔
271
272	const uint64_t pat1_1 = pat1 + pat1;	1✔
273	const uint64_t pat1_2 = pat1 + pat2;	1✔
274
275	test_eq(result, "default init", Botan::SIMD_2x64(), 0, 0);	1✔
276	test_eq(result, "SIMD scalar constructor", Botan::SIMD_2x64(1, 2), 1, 2);	1✔
277
278	const auto input = Botan::SIMD_2x64(pat1, pat2);	1✔
279	const auto splat = Botan::SIMD_2x64(pat1, pat1);	1✔
280
281	const auto rotl = input.rotl<3>();	1✔
282	test_eq(result, "rotl", rotl, Botan::rotl<3>(pat1), Botan::rotl<3>(pat2));	1✔
283
284	const auto rotr = input.rotr<9>();	1✔
285	test_eq(result, "rotr", rotr, Botan::rotr<9>(pat1), Botan::rotr<9>(pat2));	1✔
286
287	test_eq(result, "rotr<8>", input.rotr<8>(), Botan::rotr<8>(pat1), Botan::rotr<8>(pat2));	1✔
288	test_eq(result, "rotr<16>", input.rotr<16>(), Botan::rotr<16>(pat1), Botan::rotr<16>(pat2));	1✔
289	test_eq(result, "rotr<24>", input.rotr<24>(), Botan::rotr<24>(pat1), Botan::rotr<24>(pat2));	1✔
290	test_eq(result, "rotr<32>", input.rotr<32>(), Botan::rotr<32>(pat1), Botan::rotr<32>(pat2));	1✔
291
292	const auto add = input + splat;	1✔
293	test_eq(result, "add +", add, pat1_1, pat1_2);	1✔
294
295	test_eq(result, "xor", input ^ splat, 0, pat2 ^ pat1);	1✔
296
297	auto shifter = Botan::SIMD_2x64(0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);	1✔
298	shifter = shifter.shr<23>();	1✔
299	test_eq(result, ">>", shifter, 0x1FFFFFFFFFF, 0x1FFFFFFFFFF);	1✔
300
301	shifter = shifter.shl<27>();	1✔
302	test_eq(result, "<<", shifter, 0xFFFFFFFFF8000000, 0xFFFFFFFFF8000000);	1✔
303
304	shifter = input.andc(shifter);	1✔
305	test_eq(result, "andc", shifter, ~pat1 & 0xFFFFFFFFF8000000, ~pat2 & 0xFFFFFFFFF8000000);	1✔
306
307	test_eq(result, "bswap", input.bswap(), Botan::reverse_bytes(pat1), Botan::reverse_bytes(pat2));	1✔
308
309	test_eq(result,	1✔
310	"reverse_all_bytes",
311	Botan::SIMD_2x64(0x0001020304050607, 0x08090a0b0c0d0e0f).reverse_all_bytes(),	1✔
312	0x0f0e0d0c0b0a0908,
313	0x0706050403020100);
314
315	test_eq(result, "swap_lanes", Botan::SIMD_2x64(pat1, pat2).swap_lanes(), pat2, pat1);	1✔
316
317	const auto interleave_a = Botan::SIMD_2x64(0x1111111122222222, 0x3333333344444444);	1✔
318	const auto interleave_b = Botan::SIMD_2x64(0x5555555566666666, 0x7777777788888888);	1✔
319	test_eq(result,	1✔
320	"interleave_high",
321	Botan::SIMD_2x64::interleave_high(interleave_a, interleave_b),	1✔
322	0x3333333344444444,
323	0x7777777788888888);
324
325	test_eq(result,	1✔
326	"interleave_low",
327	Botan::SIMD_2x64::interleave_low(interleave_a, interleave_b),	1✔
328	0x1111111122222222,
329	0x5555555566666666);
330
331	test_eq(result, "all_ones", Botan::SIMD_2x64::all_ones(), 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF);	1✔
332
333	// Test load/stores SIMD wrapper types
334	const auto simd_le_in = Botan::hex_decode("ABCDEF01234567890123456789ABCDEF");	1✔
335	const auto simd_be_in = Botan::hex_decode("0123456789ABCDEFABCDEF0123456789");	1✔
336	const auto simd_le_array_in = Botan::concat(simd_le_in, simd_be_in);	1✔
337	const auto simd_be_array_in = Botan::concat(simd_be_in, simd_le_in);	1✔
338
339	auto simd_le = Botan::load_le<Botan::SIMD_2x64>(simd_le_in);	1✔
340	auto simd_be = Botan::load_be<Botan::SIMD_2x64>(simd_be_in);	1✔
341	auto simd_le_array = Botan::load_le<std::array<Botan::SIMD_2x64, 2>>(simd_le_array_in);	1✔
342	auto simd_be_array = Botan::load_be<std::array<Botan::SIMD_2x64, 2>>(simd_be_array_in);	1✔
343
344	auto simd_le_vec = Botan::store_le<std::vector<uint8_t>>(simd_le);	1✔
345	auto simd_be_vec = Botan::store_be(simd_be);	1✔
346	auto simd_le_array_vec = Botan::store_le<std::vector<uint8_t>>(simd_le_array);	1✔
347	auto simd_be_array_vec = Botan::store_be(simd_be_array);	1✔
348
349	result.test_bin_eq("roundtrip SIMD little-endian", simd_le_vec, simd_le_in);	1✔
350	result.test_bin_eq(	1✔
351	"roundtrip SIMD big-endian", std::vector(simd_be_vec.begin(), simd_be_vec.end()), simd_be_in);	1✔
352	result.test_bin_eq("roundtrip SIMD array little-endian", simd_le_array_vec, simd_le_array_in);	1✔
353	result.test_bin_eq("roundtrip SIMD array big-endian",	1✔
354	std::vector(simd_be_array_vec.begin(), simd_be_array_vec.end()),	1✔
355	simd_be_array_in);
356
357	using StrongSIMD = Botan::Strong<Botan::SIMD_2x64, struct StrongSIMD_>;	1✔
358	const auto simd_le_strong = Botan::load_le<StrongSIMD>(simd_le_in);	1✔
359	const auto simd_be_strong = Botan::load_be<StrongSIMD>(simd_be_in);	1✔
360
361	result.test_bin_eq(	1✔
362	"roundtrip SIMD strong little-endian", Botan::store_le<std::vector<uint8_t>>(simd_le_strong), simd_le_in);	1✔
363	result.test_bin_eq(	1✔
364	"roundtrip SIMD strong big-endian", Botan::store_be<std::vector<uint8_t>>(simd_be_strong), simd_be_in);	1✔
365
366	return {result};	2✔
367	}	6✔
368
369	private:
370	static void BOTAN_FN_ISA_SIMD_2X64
371	test_eq(Test::Result& result, const std::string& op, const Botan::SIMD_2x64& simd, uint64_t exp0, uint64_t exp1) {	19✔
372	uint8_t arr_be[16 + 15];	19✔
373	uint8_t arr_be2[16 + 15];	19✔
374	uint8_t arr_le[16 + 15];	19✔
375	uint8_t arr_le2[16 + 15];	19✔
376
377	for(size_t misalignment = 0; misalignment != 16; ++misalignment) {	323✔
378	uint8_t* mem_be = arr_be + misalignment;	304✔
379	uint8_t* mem_be2 = arr_be2 + misalignment;	304✔
380	uint8_t* mem_le = arr_le + misalignment;	304✔
381	uint8_t* mem_le2 = arr_le2 + misalignment;	304✔
382
383	simd.store_be(mem_be);	304✔
384
385	result.test_u64_eq(	608✔
386	"SIMD_2x64 " + op + " elem0 BE",	912✔
387	Botan::make_uint64(
388	mem_be[0], mem_be[1], mem_be[2], mem_be[3], mem_be[4], mem_be[5], mem_be[6], mem_be[7]),
389	exp0);
390	result.test_u64_eq(	304✔
391	"SIMD_2x64 " + op + " elem1 BE",	912✔
392	Botan::make_uint64(
393	mem_be[8], mem_be[9], mem_be[10], mem_be[11], mem_be[12], mem_be[13], mem_be[14], mem_be[15]),	304✔
394	exp1);
395
396	// Check load_be+store_be results in same value
397	const Botan::SIMD_2x64 reloaded_be = Botan::SIMD_2x64::load_be(mem_be);	304✔
398	reloaded_be.store_be(mem_be2);	304✔
399	result.test_bin_eq("SIMD_2x64 load_be", {mem_be, 16}, {mem_be2, 16});	304✔
400
401	simd.store_le(mem_le);	304✔
402
403	result.test_u64_eq(	608✔
404	"SIMD_2x64 " + op + " elem0 LE",	912✔
405	Botan::make_uint64(
406	mem_le[7], mem_le[6], mem_le[5], mem_le[4], mem_le[3], mem_le[2], mem_le[1], mem_le[0]),
407	exp0);
408	result.test_u64_eq(	304✔
409	"SIMD_2x64 " + op + " elem1 LE",	912✔
410	Botan::make_uint64(
411	mem_le[15], mem_le[14], mem_le[13], mem_le[12], mem_le[11], mem_le[10], mem_le[9], mem_le[8]),	304✔
412	exp1);
413
414	// Check load_le+store_le results in same value
415	const Botan::SIMD_2x64 reloaded_le = Botan::SIMD_2x64::load_le(mem_le);	304✔
416	reloaded_le.store_le(mem_le2);	304✔
417	result.test_bin_eq("SIMD_2x64 load_le", {mem_le, 16}, {mem_le2, 16});	304✔
418	}
419	}	19✔
420	};
421
422	BOTAN_REGISTER_TEST("utils", "simd_2x64", SIMD_2X64_Tests);
423	#endif
424
425	} // namespace
426
427	} // namespace Botan_Tests

randombit / botan / 26864473078

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous