shadps4-emu/ext-cryptopp
1
0
Fork 0
mirror of https://github.com/shadps4-emu/ext-cryptopp.git synced 2025-02-08 22:26:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert changes for lgtm findings

Browse Source 
This broke SunCC to the point of no repair. SunCC is using AVX2 instructions for C++ and SSE2. Man this compiler sucks...
This commit is contained in:
Jeffrey Walton 2019-06-09 01:49:44 -04:00
parent 3ce1823fd1
commit 8fab1c3677
No known key found for this signature in database
GPG Key ID: B36AB348921B1838
8 changed files with 118 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Filelist.txt
View File

@ -358,7 +358,6 @@ square.cpp
square.h
squaretb.cpp
sse_simd.cpp
sse_simd.h
stdcpp.h
strciphr.cpp
strciphr.h

16
asn.cpp
View File

@ -395,25 +395,25 @@ void EncodedObjectFilter::Put(const byte *inString, size_t length)
}
BERGeneralDecoder::BERGeneralDecoder(BufferedTransformation &inQueue)
: m_inQueue(inQueue), m_length(0), m_finished(false)
: m_inQueue(inQueue), m_finished(false)
{
Init(DefaultTag);
}
BERGeneralDecoder::BERGeneralDecoder(BufferedTransformation &inQueue, byte asnTag)
: m_inQueue(inQueue), m_length(0), m_finished(false)
: m_inQueue(inQueue), m_finished(false)
{
Init(asnTag);
}
BERGeneralDecoder::BERGeneralDecoder(BERGeneralDecoder &inQueue)
: m_inQueue(inQueue), m_length(0), m_finished(false)
: m_inQueue(inQueue), m_finished(false)
{
Init(DefaultTag);
}
BERGeneralDecoder::BERGeneralDecoder(BERGeneralDecoder &inQueue, byte asnTag)
: m_inQueue(inQueue), m_length(0), m_finished(false)
: m_inQueue(inQueue), m_finished(false)
{
Init(asnTag);
}
@ -514,22 +514,22 @@ lword BERGeneralDecoder::ReduceLength(lword delta)
}
DERGeneralEncoder::DERGeneralEncoder(BufferedTransformation &outQueue)
: m_outQueue(outQueue), m_asnTag(DefaultTag), m_finished(false)
: ByteQueue(), m_outQueue(outQueue), m_asnTag(DefaultTag), m_finished(false)
{
}
DERGeneralEncoder::DERGeneralEncoder(BufferedTransformation &outQueue, byte asnTag)
: m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)
: ByteQueue(), m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)
{
}
DERGeneralEncoder::DERGeneralEncoder(DERGeneralEncoder &outQueue)
: m_outQueue(outQueue), m_asnTag(DefaultTag), m_finished(false)
: ByteQueue(), m_outQueue(outQueue), m_asnTag(DefaultTag), m_finished(false)
{
}
DERGeneralEncoder::DERGeneralEncoder(DERGeneralEncoder &outQueue, byte asnTag)
: m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)
: ByteQueue(), m_outQueue(outQueue), m_asnTag(asnTag), m_finished(false)
{
}

92
chacha_avx.cpp
View File

@ -24,12 +24,18 @@
# include <xmmintrin.h>
# include <emmintrin.h>
# include <immintrin.h>
# include "sse_simd.h"
#endif
// Squash MS LNK4221 and libtool warnings
extern const char CHACHA_AVX_FNAME[] = __FILE__;
// Sun Studio 12.4 OK, 12.5 and 12.6 compile error.
#if (__SUNPRO_CC >= 0x5140) && (__SUNPRO_CC <= 0x5150)
# define MAYBE_CONST
#else
# define MAYBE_CONST const
#endif
// VS2017 and global optimization bug. TODO, figure out when
// we can re-enable full optimizations for VS2017. Also see
// https://github.com/weidai11/cryptopp/issues/649 and
@ -85,10 +91,14 @@ NAMESPACE_BEGIN(CryptoPP)
void ChaCha_OperateKeystream_AVX2(const word32 *state, const byte* input, byte *output, unsigned int rounds)
{
const __m256i state0 = _mm256_broadcastsi128_si256(load_m128i<0>(state));
const __m256i state1 = _mm256_broadcastsi128_si256(load_m128i<1>(state));
const __m256i state2 = _mm256_broadcastsi128_si256(load_m128i<2>(state));
const __m256i state3 = _mm256_broadcastsi128_si256(load_m128i<3>(state));
MAYBE_CONST __m128i* state_mm = (MAYBE_CONST __m128i*)(state);
MAYBE_CONST __m256i* input_mm = (MAYBE_CONST __m256i*)(input);
__m256i* output_mm = reinterpret_cast<__m256i*>(output);
const __m256i state0 = _mm256_broadcastsi128_si256(_mm_loadu_si128(state_mm + 0));
const __m256i state1 = _mm256_broadcastsi128_si256(_mm_loadu_si128(state_mm + 1));
const __m256i state2 = _mm256_broadcastsi128_si256(_mm_loadu_si128(state_mm + 2));
const __m256i state3 = _mm256_broadcastsi128_si256(_mm_loadu_si128(state_mm + 3));
const __m256i CTR0 = _mm256_set_epi32(0, 0, 0, 0, 0, 0, 0, 4);
const __m256i CTR1 = _mm256_set_epi32(0, 0, 0, 1, 0, 0, 0, 5);
@ -294,80 +304,80 @@ void ChaCha_OperateKeystream_AVX2(const word32 *state, const byte* input, byte *
X3_3 = _mm256_add_epi32(X3_3, state3);
X3_3 = _mm256_add_epi64(X3_3, CTR3);
if (input)
if (input_mm)
{
store_m256i<0>(output, _mm256_xor_si256(load_m256i<0>(input),
_mm256_storeu_si256(output_mm + 0, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 0),
_mm256_permute2x128_si256(X0_0, X0_1, 1 + (3 << 4))));
store_m256i<1>(output, _mm256_xor_si256(load_m256i<1>(input),
_mm256_storeu_si256(output_mm + 1, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 1),
_mm256_permute2x128_si256(X0_2, X0_3, 1 + (3 << 4))));
store_m256i<2>(output, _mm256_xor_si256(load_m256i<2>(input),
_mm256_storeu_si256(output_mm + 2, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 2),
_mm256_permute2x128_si256(X1_0, X1_1, 1 + (3 << 4))));
store_m256i<3>(output, _mm256_xor_si256(load_m256i<3>(input),
_mm256_storeu_si256(output_mm + 3, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 3),
_mm256_permute2x128_si256(X1_2, X1_3, 1 + (3 << 4))));
}
else
{
store_m256i<0>(output, _mm256_permute2x128_si256(X0_0, X0_1, 1 + (3 << 4)));
store_m256i<1>(output, _mm256_permute2x128_si256(X0_2, X0_3, 1 + (3 << 4)));
store_m256i<2>(output, _mm256_permute2x128_si256(X1_0, X1_1, 1 + (3 << 4)));
store_m256i<3>(output, _mm256_permute2x128_si256(X1_2, X1_3, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 0, _mm256_permute2x128_si256(X0_0, X0_1, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 1, _mm256_permute2x128_si256(X0_2, X0_3, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 2, _mm256_permute2x128_si256(X1_0, X1_1, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 3, _mm256_permute2x128_si256(X1_2, X1_3, 1 + (3 << 4)));
}
if (input)
if (input_mm)
{
store_m256i<4>(output, _mm256_xor_si256(load_m256i<4>(input),
_mm256_storeu_si256(output_mm + 4, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 4),
_mm256_permute2x128_si256(X2_0, X2_1, 1 + (3 << 4))));
store_m256i<5>(output, _mm256_xor_si256(load_m256i<5>(input),
_mm256_storeu_si256(output_mm + 5, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 5),
_mm256_permute2x128_si256(X2_2, X2_3, 1 + (3 << 4))));
store_m256i<6>(output, _mm256_xor_si256(load_m256i<6>(input),
_mm256_storeu_si256(output_mm + 6, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 6),
_mm256_permute2x128_si256(X3_0, X3_1, 1 + (3 << 4))));
store_m256i<7>(output, _mm256_xor_si256(load_m256i<7>(input),
_mm256_storeu_si256(output_mm + 7, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 7),
_mm256_permute2x128_si256(X3_2, X3_3, 1 + (3 << 4))));
}
else
{
store_m256i<4>(output, _mm256_permute2x128_si256(X2_0, X2_1, 1 + (3 << 4)));
store_m256i<5>(output, _mm256_permute2x128_si256(X2_2, X2_3, 1 + (3 << 4)));
store_m256i<6>(output, _mm256_permute2x128_si256(X3_0, X3_1, 1 + (3 << 4)));
store_m256i<7>(output, _mm256_permute2x128_si256(X3_2, X3_3, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 4, _mm256_permute2x128_si256(X2_0, X2_1, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 5, _mm256_permute2x128_si256(X2_2, X2_3, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 6, _mm256_permute2x128_si256(X3_0, X3_1, 1 + (3 << 4)));
_mm256_storeu_si256(output_mm + 7, _mm256_permute2x128_si256(X3_2, X3_3, 1 + (3 << 4)));
}
if (input)
if (input_mm)
{
store_m256i<8>(output, _mm256_xor_si256(load_m256i<8>(input),
_mm256_storeu_si256(output_mm + 8, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 8),
_mm256_permute2x128_si256(X0_0, X0_1, 0 + (2 << 4))));
store_m256i<9>(output, _mm256_xor_si256(load_m256i<9>(input),
_mm256_storeu_si256(output_mm + 9, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 9),
_mm256_permute2x128_si256(X0_2, X0_3, 0 + (2 << 4))));
store_m256i<10>(output, _mm256_xor_si256(load_m256i<10>(input),
_mm256_storeu_si256(output_mm + 10, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 10),
_mm256_permute2x128_si256(X1_0, X1_1, 0 + (2 << 4))));
store_m256i<11>(output, _mm256_xor_si256(load_m256i<11>(input),
_mm256_storeu_si256(output_mm + 11, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 11),
_mm256_permute2x128_si256(X1_2, X1_3, 0 + (2 << 4))));
}
else
{
store_m256i<8>(output, _mm256_permute2x128_si256(X0_0, X0_1, 0 + (2 << 4)));
store_m256i<9>(output, _mm256_permute2x128_si256(X0_2, X0_3, 0 + (2 << 4)));
store_m256i<10>(output, _mm256_permute2x128_si256(X1_0, X1_1, 0 + (2 << 4)));
store_m256i<11>(output, _mm256_permute2x128_si256(X1_2, X1_3, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 8, _mm256_permute2x128_si256(X0_0, X0_1, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 9, _mm256_permute2x128_si256(X0_2, X0_3, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 10, _mm256_permute2x128_si256(X1_0, X1_1, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 11, _mm256_permute2x128_si256(X1_2, X1_3, 0 + (2 << 4)));
}
if (input)
if (input_mm)
{
store_m256i<12>(output, _mm256_xor_si256(load_m256i<12>(input),
_mm256_storeu_si256(output_mm + 12, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 12),
_mm256_permute2x128_si256(X2_0, X2_1, 0 + (2 << 4))));
store_m256i<13>(output, _mm256_xor_si256(load_m256i<13>(input),
_mm256_storeu_si256(output_mm + 13, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 13),
_mm256_permute2x128_si256(X2_2, X2_3, 0 + (2 << 4))));
store_m256i<14>(output, _mm256_xor_si256(load_m256i<14>(input),
_mm256_storeu_si256(output_mm + 14, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 14),
_mm256_permute2x128_si256(X3_0, X3_1, 0 + (2 << 4))));
store_m256i<15>(output, _mm256_xor_si256(load_m256i<15>(input),
_mm256_storeu_si256(output_mm + 15, _mm256_xor_si256(_mm256_loadu_si256(input_mm + 15),
_mm256_permute2x128_si256(X3_2, X3_3, 0 + (2 << 4))));
}
else
{
store_m256i<12>(output, _mm256_permute2x128_si256(X2_0, X2_1, 0 + (2 << 4)));
store_m256i<13>(output, _mm256_permute2x128_si256(X2_2, X2_3, 0 + (2 << 4)));
store_m256i<14>(output, _mm256_permute2x128_si256(X3_0, X3_1, 0 + (2 << 4)));
store_m256i<15>(output, _mm256_permute2x128_si256(X3_2, X3_3, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 12, _mm256_permute2x128_si256(X2_0, X2_1, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 13, _mm256_permute2x128_si256(X2_2, X2_3, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 14, _mm256_permute2x128_si256(X3_0, X3_1, 0 + (2 << 4)));
_mm256_storeu_si256(output_mm + 15, _mm256_permute2x128_si256(X3_2, X3_3, 0 + (2 << 4)));
}
// https://software.intel.com/en-us/articles/avoiding-avx-sse-transition-penalties

85
chacha_simd.cpp
View File

@ -38,7 +38,6 @@
#if (CRYPTOPP_SSE2_INTRIN_AVAILABLE)
# include <xmmintrin.h>
# include <emmintrin.h>
# include "sse_simd.h"
#endif
#if defined(__SSSE3__)
@ -566,10 +565,14 @@ void ChaCha_OperateKeystream_NEON(const word32 *state, const byte* input, byte *
void ChaCha_OperateKeystream_SSE2(const word32 *state, const byte* input, byte *output, unsigned int rounds)
{
const __m128i state0 = load_m128i<0>(state);
const __m128i state1 = load_m128i<1>(state);
const __m128i state2 = load_m128i<2>(state);
const __m128i state3 = load_m128i<3>(state);
const __m128i* state_mm = reinterpret_cast<const __m128i*>(state);
const __m128i* input_mm = reinterpret_cast<const __m128i*>(input);
__m128i* output_mm = reinterpret_cast<__m128i*>(output);
const __m128i state0 = _mm_load_si128(state_mm + 0);
const __m128i state1 = _mm_load_si128(state_mm + 1);
const __m128i state2 = _mm_load_si128(state_mm + 2);
const __m128i state3 = _mm_load_si128(state_mm + 3);
__m128i r0_0 = state0;
__m128i r0_1 = state1;
@ -769,57 +772,57 @@ void ChaCha_OperateKeystream_SSE2(const word32 *state, const byte* input, byte *
r3_3 = _mm_add_epi32(r3_3, state3);
r3_3 = _mm_add_epi64(r3_3, _mm_set_epi32(0, 0, 0, 3));
if (input)
if (input_mm)
{
r0_0 = _mm_xor_si128(load_m128i<0>(input), r0_0);
r0_1 = _mm_xor_si128(load_m128i<1>(input), r0_1);
r0_2 = _mm_xor_si128(load_m128i<2>(input), r0_2);
r0_3 = _mm_xor_si128(load_m128i<3>(input), r0_3);
r0_0 = _mm_xor_si128(_mm_loadu_si128(input_mm + 0), r0_0);
r0_1 = _mm_xor_si128(_mm_loadu_si128(input_mm + 1), r0_1);
r0_2 = _mm_xor_si128(_mm_loadu_si128(input_mm + 2), r0_2);
r0_3 = _mm_xor_si128(_mm_loadu_si128(input_mm + 3), r0_3);
}
store_m128i<0>(output, r0_0);
store_m128i<1>(output, r0_1);
store_m128i<2>(output, r0_2);
store_m128i<3>(output, r0_3);
_mm_storeu_si128(output_mm + 0, r0_0);
_mm_storeu_si128(output_mm + 1, r0_1);
_mm_storeu_si128(output_mm + 2, r0_2);
_mm_storeu_si128(output_mm + 3, r0_3);
if (input)
if (input_mm)
{
r1_0 = _mm_xor_si128(load_m128i<4>(input), r1_0);
r1_1 = _mm_xor_si128(load_m128i<5>(input), r1_1);
r1_2 = _mm_xor_si128(load_m128i<6>(input), r1_2);
r1_3 = _mm_xor_si128(load_m128i<7>(input), r1_3);
r1_0 = _mm_xor_si128(_mm_loadu_si128(input_mm + 4), r1_0);
r1_1 = _mm_xor_si128(_mm_loadu_si128(input_mm + 5), r1_1);
r1_2 = _mm_xor_si128(_mm_loadu_si128(input_mm + 6), r1_2);
r1_3 = _mm_xor_si128(_mm_loadu_si128(input_mm + 7), r1_3);
}
store_m128i<4>(output, r1_0);
store_m128i<5>(output, r1_1);
store_m128i<6>(output, r1_2);
store_m128i<7>(output, r1_3);
_mm_storeu_si128(output_mm + 4, r1_0);
_mm_storeu_si128(output_mm + 5, r1_1);
_mm_storeu_si128(output_mm + 6, r1_2);
_mm_storeu_si128(output_mm + 7, r1_3);
if (input)
if (input_mm)
{
r2_0 = _mm_xor_si128(load_m128i< 8>(input), r2_0);
r2_1 = _mm_xor_si128(load_m128i< 9>(input), r2_1);
r2_2 = _mm_xor_si128(load_m128i<10>(input), r2_2);
r2_3 = _mm_xor_si128(load_m128i<11>(input), r2_3);
r2_0 = _mm_xor_si128(_mm_loadu_si128(input_mm + 8), r2_0);
r2_1 = _mm_xor_si128(_mm_loadu_si128(input_mm + 9), r2_1);
r2_2 = _mm_xor_si128(_mm_loadu_si128(input_mm + 10), r2_2);
r2_3 = _mm_xor_si128(_mm_loadu_si128(input_mm + 11), r2_3);
}
store_m128i< 8>(output, r2_0);
store_m128i< 9>(output, r2_1);
store_m128i<10>(output, r2_2);
store_m128i<11>(output, r2_3);
_mm_storeu_si128(output_mm + 8, r2_0);
_mm_storeu_si128(output_mm + 9, r2_1);
_mm_storeu_si128(output_mm + 10, r2_2);
_mm_storeu_si128(output_mm + 11, r2_3);
if (input)
if (input_mm)
{
r3_0 = _mm_xor_si128(load_m128i<12>(input), r3_0);
r3_1 = _mm_xor_si128(load_m128i<13>(input), r3_1);
r3_2 = _mm_xor_si128(load_m128i<14>(input), r3_2);
r3_3 = _mm_xor_si128(load_m128i<15>(input), r3_3);
r3_0 = _mm_xor_si128(_mm_loadu_si128(input_mm + 12), r3_0);
r3_1 = _mm_xor_si128(_mm_loadu_si128(input_mm + 13), r3_1);
r3_2 = _mm_xor_si128(_mm_loadu_si128(input_mm + 14), r3_2);
r3_3 = _mm_xor_si128(_mm_loadu_si128(input_mm + 15), r3_3);
}
store_m128i<12>(output, r3_0);
store_m128i<13>(output, r3_1);
store_m128i<14>(output, r3_2);
store_m128i<15>(output, r3_3);
_mm_storeu_si128(output_mm + 12, r3_0);
_mm_storeu_si128(output_mm + 13, r3_1);
_mm_storeu_si128(output_mm + 14, r3_2);
_mm_storeu_si128(output_mm + 15, r3_3);
}
#endif // CRYPTOPP_SSE2_INTRIN_AVAILABLE

1
cryptlib.vcxproj
View File

@ -538,7 +538,6 @@
<ClInclude Include="sosemanuk.h" />
<ClInclude Include="speck.h" />
<ClInclude Include="square.h" />
<ClInclude Include="sse_simd.h" />
<ClInclude Include="stdcpp.h" />
<ClInclude Include="strciphr.h" />
<ClInclude Include="tea.h" />

3
cryptlib.vcxproj.filters
View File

@ -993,9 +993,6 @@
<ClInclude Include="square.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="sse_simd.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="stdcpp.h">
<Filter>Header Files</Filter>
</ClInclude>

26
gf2n_simd.cpp
View File

@ -28,7 +28,6 @@
#if (CRYPTOPP_CLMUL_AVAILABLE)
# include <emmintrin.h>
# include <wmmintrin.h>
# include "sse_simd.h"
#endif
#if (CRYPTOPP_ARM_PMULL_AVAILABLE)
@ -466,31 +465,36 @@ NAMESPACE_BEGIN(CryptoPP)
void
GF2NT_233_Multiply_Reduce_CLMUL(const word* pA, const word* pB, word* pC)
{
__m128i a0 = load_m128i<0>(pA);
__m128i a1 = load_m128i<1>(pA);
__m128i b0 = load_m128i<0>(pB);
__m128i b1 = load_m128i<1>(pB);
const __m128i* pAA = reinterpret_cast<const __m128i*>(pA);
const __m128i* pBB = reinterpret_cast<const __m128i*>(pB);
__m128i a0 = _mm_loadu_si128(pAA+0);
__m128i a1 = _mm_loadu_si128(pAA+1);
__m128i b0 = _mm_loadu_si128(pBB+0);
__m128i b1 = _mm_loadu_si128(pBB+1);
__m128i c0, c1, c2, c3;
F2N_Multiply_256x256_CLMUL(c3, c2, c1, c0, a1, a0, b1, b0);
GF2NT_233_Reduce_CLMUL(c3, c2, c1, c0);
store_m128i<0>(pC, c0);
store_m128i<1>(pC, c1);
__m128i* pCC = reinterpret_cast<__m128i*>(pC);
_mm_storeu_si128(pCC+0, c0);
_mm_storeu_si128(pCC+1, c1);
}
void
GF2NT_233_Square_Reduce_CLMUL(const word* pA, word* pC)
{
__m128i a0 = load_m128i<0>(pA);
__m128i a1 = load_m128i<1>(pA);
const __m128i* pAA = reinterpret_cast<const __m128i*>(pA);
__m128i a0 = _mm_loadu_si128(pAA+0);
__m128i a1 = _mm_loadu_si128(pAA+1);
__m128i c0, c1, c2, c3;
F2N_Square_256_CLMUL(c3, c2, c1, c0, a1, a0);
GF2NT_233_Reduce_CLMUL(c3, c2, c1, c0);
store_m128i<0>(pC, c0);
store_m128i<1>(pC, c1);
__m128i* pCC = reinterpret_cast<__m128i*>(pC);
_mm_storeu_si128(pCC+0, c0);
_mm_storeu_si128(pCC+1, c1);
}
#elif (CRYPTOPP_ARM_PMULL_AVAILABLE)

121
sse_simd.h
View File

@ -1,121 +0,0 @@
// sse_simd.h - written and placed in public domain by Jeffrey Walton
// Helper functions to work with SSE and above. The class file
// was added after a scan by lgtm.com. We caught some findings
// that were not problems, but we refactored to squash them.
#ifndef CRYPTOPP_SSE_CRYPTO_H
#define CRYPTOPP_SSE_CRYPTO_H
#include "config.h"
#if (CRYPTOPP_SSE2_INTRIN_AVAILABLE)
# include <emmintrin.h>
#endif
#if (CRYPTOPP_AVX2_AVAILABLE)
# include <immintrin.h>
#endif
NAMESPACE_BEGIN(CryptoPP)
#if (CRYPTOPP_SSE2_INTRIN_AVAILABLE)
template <unsigned int N>
inline __m128i load_m128i(const byte* ptr)
{
enum { SCALE=sizeof(__m128i)/sizeof(byte) };
return _mm_loadu_si128(
const_cast<__m128i*>( // SunCC workaround
reinterpret_cast<const __m128i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m128i load_m128i(const word16* ptr)
{
enum { SCALE=sizeof(__m128i)/sizeof(word16) };
return _mm_loadu_si128(
const_cast<__m128i*>( // SunCC workaround
reinterpret_cast<const __m128i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m128i load_m128i(const word32* ptr)
{
enum { SCALE=sizeof(__m128i)/sizeof(word32) };
return _mm_loadu_si128(
const_cast<__m128i*>( // SunCC workaround
reinterpret_cast<const __m128i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m128i load_m128i(const word64* ptr)
{
enum { SCALE=sizeof(__m128i)/sizeof(word64) };
return _mm_loadu_si128(
const_cast<__m128i*>( // SunCC workaround
reinterpret_cast<const __m128i*>(ptr+SCALE*N)));
}
// N specifies the nth 128-bit element
template <unsigned int N, class T>
inline void store_m128i(T* ptr, __m128i val)
{
enum { SCALE=sizeof(__m128i)/sizeof(T) };
return _mm_storeu_si128(
reinterpret_cast<__m128i*>(ptr+SCALE*N), val);
}
#endif
#if (CRYPTOPP_AVX2_AVAILABLE)
template <unsigned int N>
inline __m256i load_m256i(const byte* ptr)
{
enum { SCALE=sizeof(__m256i)/sizeof(byte) };
return _mm256_loadu_si256(
const_cast<__m256i*>( // SunCC workaround
reinterpret_cast<const __m256i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m256i load_m256i(const word16* ptr)
{
enum { SCALE=sizeof(__m256i)/sizeof(word16) };
return _mm256_loadu_si256(
const_cast<__m256i*>( // SunCC workaround
reinterpret_cast<const __m256i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m256i load_m256i(const word32* ptr)
{
enum { SCALE=sizeof(__m256i)/sizeof(word32) };
return _mm256_loadu_si256(
const_cast<__m256i*>( // SunCC workaround
reinterpret_cast<const __m256i*>(ptr+SCALE*N)));
}
template <unsigned int N>
inline __m256i load_m256i(const word64* ptr)
{
enum { SCALE=sizeof(__m256i)/sizeof(word64) };
return _mm256_loadu_si256(
const_cast<__m256i*>( // SunCC workaround
reinterpret_cast<const __m256i*>(ptr+SCALE*N)));
}
// N specifies the nth 256-bit element
template <unsigned int N, class T>
inline void store_m256i(T* ptr, __m256i val)
{
enum { SCALE=sizeof(__m256i)/sizeof(T) };
return _mm256_storeu_si256(
reinterpret_cast<__m256i*>(ptr+SCALE*N), val);
}
#endif
NAMESPACE_END
#endif // CRYPTOPP_SSE_CRYPTO_H