native_i8x16_sse2.hpp

// Copyright Take Vos 2022, 2023.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "native_simd_utility.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include <array>
#include <ostream>
 
 
 
hi_warning_push();
// C26472: Don't use a static_cast for arithmetic conversions.
// This is a low level type.
hi_warning_ignore_msvc(26472);
 
namespace hi { inline namespace v1 {
 
#ifdef HI_HAS_SSE2
 
struct native_i8x16 {
    using value_type = int8_t;
    constexpr static size_t size = 4;
    using register_type = __m128i;
    using array_type = std::array<value_type, size>;
 
    register_type v;
 
    native_i8x16(native_i8x16 const&) noexcept = default;
    native_i8x16(native_i8x16&&) noexcept = default;
    native_i8x16& operator=(native_i8x16 const&) noexcept = default;
    native_i8x16& operator=(native_i8x16&&) noexcept = default;
 
    native_i8x16() noexcept : v(_mm_setzero_si128()) {}
 
    [[nodiscard]] explicit native_i8x16(register_type other) noexcept : v(other) {}
 
    [[nodiscard]] explicit operator register_type() const noexcept
    {
        return v;
    }
 
    [[nodiscard]] native_i8x16(
        value_type a,
        value_type b = value_type{0},
        value_type c = value_type{0},
        value_type d = value_type{0},
        value_type e = value_type{0},
        value_type f = value_type{0},
        value_type g = value_type{0},
        value_type h = value_type{0},
        value_type i = value_type{0},
        value_type j = value_type{0},
        value_type k = value_type{0},
        value_type l = value_type{0},
        value_type m = value_type{0},
        value_type n = value_type{0},
        value_type o = value_type{0},
        value_type p = value_type{0}
        ) noexcept :
        v(_mm_set_epi8(p, o, n, m, l, k, j, i, h, g, f, e, d, c, b, a))
    {
    }
 
    [[nodiscard]] explicit native_i8x16(value_type const *other) noexcept :
        v(_mm_loadu_si128(reinterpret_cast<register_type const *>(other)))
    {
    }
 
    void store(value_type *out) const noexcept
    {
        hi_axiom_not_null(out);
        _mm_storeu_si128(reinterpret_cast<register_type *>(out), v);
    }
 
    [[nodiscard]] explicit native_i8x16(void const *other) noexcept : v(_mm_loadu_si128(static_cast<register_type const *>(other)))
    {
    }
 
    void store(void *out) const noexcept
    {
        hi_axiom_not_null(out);
        _mm_storeu_si128(static_cast<register_type *>(out), v);
    }
 
    [[nodiscard]] explicit native_i8x16(std::span<value_type const> other) noexcept
    {
        hi_axiom(other.size() >= size);
        v = _mm_loadu_si128(reinterpret_cast<register_type const *>(other.data()));
    }
 
    void store(std::span<value_type> out) const noexcept
    {
        hi_axiom(out.size() >= size);
        _mm_storeu_si128(reinterpret_cast<register_type *>(out.data()), v);
    }
 
    [[nodiscard]] explicit native_i8x16(array_type other) noexcept :
        v(_mm_loadu_si128(reinterpret_cast<register_type const *>(other.data())))
    {
    }
 
    [[nodiscard]] explicit operator array_type() const noexcept
    {
        auto r = array_type{};
        _mm_storeu_si128(reinterpret_cast<register_type *>(r.data()), v);
        return r;
    }
 
#ifdef AVX512F
    [[nodiscard]] explicit native_i8x16(native_f32x16 const& a) noexcept;
    [[nodiscard]] explicit native_i8x16(native_u32x16 const& a) noexcept;
#endif
 
    [[nodiscard]] static native_i8x16 broadcast(value_type a) noexcept
    {
        return native_i8x16{_mm_set1_epi8(a)};
    }
 
    [[nodiscard]] static native_i8x16 broadcast(native_i8x16 a) noexcept
    {
#ifdef HI_HAS_AVX2
        return native_i8x16{_mm_broadcastb_epi8(a.v)};
#elif HI_HAS_SSSE3
        return native_i8x16{_mm_shuffle_epi8(a.v, _mm_setzero_si128())};
#else
        // Create a mask for 1 byte each 32 bit word, AND it with a.v.
        auto tmp = _mm_undefined_si128();
        tmp = _mm_cmpeq_epi32(tmp, tmp);
        tmp = _mm_slli_epi32(tmp, 24);
        tmp = _mm_and_si128(tmp, a.v);
 
        // Broadcast the first byte to all the bytes in the first 32 bit word.
        tmp = _mm_or_si128(tmp, _mm_slli_epi32(tmp, 8));
        tmp = _mm_or_si128(tmp, _mm_slli_epi32(tmp,16));
 
        // Broadcast the first 32 bit word to all 4 32 bit words.
        tmp = _mm_shuffle_epi32(tmp, 0b00'00'00'00);
        return native_i8x16{tmp};
#endif
    }
 
    [[nodiscard]] static native_i8x16 ones() noexcept
    {
        hilet tmp = _mm_undefined_si128();
        return native_i8x16{_mm_cmpeq_epi32(tmp, tmp)};
    }
 
    [[nodiscard]] size_t mask() const noexcept
    {
        return narrow_cast<size_t>(_mm_movemask_epi8(v));
    }
 
    [[nodiscard]] friend bool equal(native_i8x16 a, native_i8x16 b) noexcept
    {
        return (a == b).mask() == 0b1111'1111'1111'1111;
    }
 
    [[nodiscard]] friend native_i8x16 operator==(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_cmpeq_epi8(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator!=(native_i8x16 a, native_i8x16 b) noexcept
    {
        return ~(a == b);
    }
 
    [[nodiscard]] friend native_i8x16 operator<(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_cmplt_epi8(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator>(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_cmpgt_epi8(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator<=(native_i8x16 a, native_i8x16 b) noexcept
    {
        return ~(a > b);
    }
 
    [[nodiscard]] friend native_i8x16 operator>=(native_i8x16 a, native_i8x16 b) noexcept
    {
        return ~(a < b);
    }
 
    [[nodiscard]] friend native_i8x16 operator+(native_i8x16 a) noexcept
    {
        return a;
    }
 
    [[nodiscard]] friend native_i8x16 operator-(native_i8x16 a) noexcept
    {
        return native_i8x16{} - a;
    }
 
    [[nodiscard]] friend native_i8x16 operator+(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_add_epi8(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator-(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_sub_epi8(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator&(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_and_si128(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator|(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_or_si128(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator^(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_xor_si128(a.v, b.v)};
    }
 
    [[nodiscard]] friend native_i8x16 operator~(native_i8x16 a) noexcept
    {
        auto ones = _mm_undefined_si128();
        ones = _mm_cmpeq_epi32(ones, ones);
        return native_i8x16{_mm_andnot_si128(a.v, ones)};
    }
 
    [[nodiscard]] friend native_i8x16 min(native_i8x16 a, native_i8x16 b) noexcept
    {
#if HI_HAS_SSE4_1
        return native_i8x16{_mm_min_epi8(a.v, b.v)};
#else
        hilet mask = a < b;
        return (mask & a) | not_and(mask, b);
#endif
    }
 
    [[nodiscard]] friend native_i8x16 max(native_i8x16 a, native_i8x16 b) noexcept
    {
#if HI_HAS_SSE4_1
        return native_i8x16{_mm_max_epi8(a.v, b.v)};
#else
        hilet mask = a > b;
        return (mask & a) | not_and(mask, b);
#endif
    }
 
    [[nodiscard]] friend native_i8x16 abs(native_i8x16 a) noexcept
    {
#if HI_HAS_SSSE3
        return native_i8x16{_mm_abs_epi8(a.v)};
#else
        hilet mask = a > native_i8x16{};
        return (mask & a) | not_and(mask, -a);
#endif
    }
 
    template<size_t Mask>
    [[nodiscard]] friend native_i8x16 set_zero(native_i8x16 a) noexcept
    {
        static_assert(Mask <= 0b1111);
#ifdef HI_HAS_SSE4_1
        return native_i8x16{_mm_castps_si128(_mm_insert_ps(_mm_castsi128_ps(a.v), _mm_castsi128_ps(a.v), Mask))};
#else
        hilet mask = from_mask<Mask>();
        return not_and(mask, a);
#endif
    }
 
    template<size_t Index>
    [[nodiscard]] friend native_i8x16 insert(native_i8x16 a, value_type b) noexcept
    {
        static_assert(Index < 4);
 
#ifdef HI_HAS_SSE4_1
        return native_i8x16{_mm_insert_epi8(a.v, b, Index)};
#else
        hilet mask = from_mask<1_uz << Index>();
        return not_and(mask, a) | (mask & broadcast(b));
#endif
    }
 
    template<size_t Index>
    [[nodiscard]] friend value_type get(native_i8x16 a) noexcept
    {
#ifdef HI_HAS_SSE4_1
        return static_cast<value_type>(_mm_extract_epi8(a.v, Index));
#else
        auto r = static_cast<array_type>(a);
        return std::get<Index>(r);
#endif
    }
 
    [[nodiscard]] friend native_i8x16 not_and(native_i8x16 a, native_i8x16 b) noexcept
    {
        return native_i8x16{_mm_andnot_si128(a.v, b.v)};
    }
 
    friend std::ostream& operator<<(std::ostream& a, native_i8x16 b) noexcept
    {
        return a << "(" << get<0>(b) << ", " << get<1>(b) << ", " << get<2>(b) << ", " << get<3>(b) << ")";
    }
};
 
#endif
 
}} // namespace hi::v1
 
hi_warning_pop();