native.arm.sm4.ccm

// SPDX-License-Identifier: BSD-2-Clause OR Apache-2.0
module;
#include "native/isa_import.h"
#include "native/detail/sm4_sbox.h"
#include "native/arm/detail/constant_lanes.h"
#include "native/config.h"
#include "native/attributes.h"
#include "native/isa.h"
#include <cstdint>
#if NATIVE_HOST_NEON
#include <arm_neon.h>
#endif
#include "native/targets.h"
export module native.arm.sm4;
export import native.arm.features;
export import native.simd;
namespace native::detail::arm_sm4_constant {
 
 
  template<bool Key, class V> constexpr V rounds(V state, V keys) noexcept {
    auto x = arm_constant::lanes(state);
    auto k = arm_constant::lanes(keys);
    for (unsigned i = 0; i < 4; ++i) {
      auto mixed = x[1] ^ x[2] ^ x[3] ^ k[i];
      std::uint32_t substituted = 0;
      for (unsigned byte = 0; byte < 4; ++byte)
        substituted |= std::uint32_t(sbox[(mixed >> (byte * 8)) & 255]) << (byte * 8);
      auto next = substituted;
      if constexpr (Key)
        next ^= std::rotl(substituted, 13) ^ std::rotl(substituted, 23);
      else
        next ^= std::rotl(substituted, 2) ^ std::rotl(substituted, 10) ^
                std::rotl(substituted, 18) ^ std::rotl(substituted, 24);
      next ^= x[0];
      x = {x[1], x[2], x[3], next};
    }
    return arm_constant::pack<V>(x);
  }
 
  template<class V> constexpr V sm4e(V state, V keys) noexcept {
    return rounds<false>(state, keys);
  }
 
  template<class V> constexpr V sm4ekey(V state, V constants) noexcept {
    return rounds<true>(state, constants);
  }
} // namespace native::detail::arm_sm4_constant

#if NATIVE_HOST_NEON
 
namespace native::detail::arm_sm4 {
  template<isa<arm> Arch>
    requires(Arch.has(arm_feature::sm4))
  native_nodiscard native_inline native_const native_target("sm4") uint32x4_t sm4e(
    uint32x4_t a, uint32x4_t b) noexcept {
    return vsm4eq_u32(a, b);
  }
 
  template<isa<arm> Arch>
    requires(Arch.has(arm_feature::sm4))
  native_nodiscard native_inline native_const native_target("sm4") uint32x4_t sm4ekey(
    uint32x4_t a, uint32x4_t b) noexcept {
    return vsm4ekeyq_u32(a, b);
  }
 
} // namespace native::detail::arm_sm4
#endif
 
#if NATIVE_HOST_NEON || defined(NATIVE_DOXYGEN)
export namespace native {

  template<isa<arm> Arch>
    requires(Arch.has(arm_feature::sm4))
  native_nodiscard native_inline native_const
  native_target("sm4") constexpr simd<std::uint32_t, 4, Arch>
  sm4e(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b) noexcept {
    if consteval {
      return detail::arm_sm4_constant::sm4e(a, b);
    } else {
      auto result = detail::arm_sm4::sm4e<Arch>(__builtin_bit_cast(uint32x4_t, a.to_native()),
        __builtin_bit_cast(uint32x4_t, b.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(
        __builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch>
    requires(!Arch.has(arm_feature::sm4) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sm4e(
    simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b) noexcept {
    return detail::arm_sm4_constant::sm4e(a, b);
  }

  template<isa<arm> Arch>
    requires(Arch.has(arm_feature::sm4))
  native_nodiscard native_inline native_const
  native_target("sm4") constexpr simd<std::uint32_t, 4, Arch>
  sm4ekey(simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b) noexcept {
    if consteval {
      return detail::arm_sm4_constant::sm4ekey(a, b);
    } else {
      auto result = detail::arm_sm4::sm4ekey<Arch>(__builtin_bit_cast(uint32x4_t, a.to_native()),
        __builtin_bit_cast(uint32x4_t, b.to_native()));
      return simd<std::uint32_t, 4, Arch>::from_native(
        __builtin_bit_cast(typename simd<std::uint32_t, 4, Arch>::native_type, result));
    }
  }

  template<isa<arm> Arch>
    requires(!Arch.has(arm_feature::sm4) && requires { sizeof(simd<std::uint32_t, 4, Arch>); })
  native_nodiscard consteval simd<std::uint32_t, 4, Arch> sm4ekey(
    simd<std::uint32_t, 4, Arch> a, simd<std::uint32_t, 4, Arch> b) noexcept {
    return detail::arm_sm4_constant::sm4ekey(a, b);
  }

} // namespace native
#endif