v3.20.2

JayDDee · Aug 2, 2022 · 58030e2 · 58030e2
1 parent 1321ac4
commit 58030e2
Show file tree

Hide file tree

Showing 27 changed files with 311 additions and 4,733 deletions.
diff --git a/Makefile.am b/Makefile.am
@@ -285,8 +285,6 @@ cpuminer_SOURCES = \
   algo/x22/x22i-gate.c \
   algo/x22/x25x.c \
   algo/x22/x25x-4way.c \
-  algo/yescrypt/yescrypt.c \
-  algo/yescrypt/yescrypt-best.c \
   algo/yespower/yespower-gate.c \
   algo/yespower/yespower-blake2b.c \
   algo/yespower/crypto/hmac-blake2b.c \

diff --git a/RELEASE_NOTES b/RELEASE_NOTES
@@ -65,6 +65,11 @@ If not what makes it happen or not happen?
 Change Log
 ----------
 
+v3.20.2
+
+Bit rotation optimizations to Blake256, Blake512, Blake2b, Blake2s & Lyra2-blake2b for SSE2 & AVX2.
+Removed old unused yescrypt library and other unused code.
+
 v3.20.1
 
 sph_blake2b optimized 1-way SSSE3 & AVX2.

diff --git a/algo-gate-api.c b/algo-gate-api.c
@@ -371,15 +371,11 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
     case ALGO_X22I:         rc = register_x22i_algo          ( gate ); break;
     case ALGO_X25X:         rc = register_x25x_algo          ( gate ); break;
     case ALGO_XEVAN:        rc = register_xevan_algo         ( gate ); break;
-    case ALGO_YESCRYPT:     rc = register_yescrypt_05_algo   ( gate ); break;
-//    case ALGO_YESCRYPT:      register_yescrypt_algo      ( gate ); break;
-    case ALGO_YESCRYPTR8:   rc = register_yescryptr8_05_algo ( gate ); break;
-//    case ALGO_YESCRYPTR8:    register_yescryptr8_algo    ( gate ); break;
+    case ALGO_YESCRYPT:     rc = register_yescrypt_algo      ( gate ); break;
+    case ALGO_YESCRYPTR8:   rc = register_yescryptr8_algo    ( gate ); break;
     case ALGO_YESCRYPTR8G:  rc = register_yescryptr8g_algo   ( gate ); break;
-    case ALGO_YESCRYPTR16:  rc = register_yescryptr16_05_algo( gate ); break;
-//    case ALGO_YESCRYPTR16:   register_yescryptr16_algo   ( gate ); break;
-    case ALGO_YESCRYPTR32:  rc = register_yescryptr32_05_algo( gate ); break;
-//    case ALGO_YESCRYPTR32:   register_yescryptr32_algo   ( gate ); break;
+    case ALGO_YESCRYPTR16:  rc = register_yescryptr16_algo   ( gate ); break;
+    case ALGO_YESCRYPTR32:  rc = register_yescryptr32_algo   ( gate ); break;
     case ALGO_YESPOWER:     rc = register_yespower_algo      ( gate ); break;
     case ALGO_YESPOWERR16:  rc = register_yespowerr16_algo   ( gate ); break;
     case ALGO_YESPOWER_B2B: rc = register_yespower_b2b_algo  ( gate ); break;

diff --git a/algo/blake/blake256-hash-4way.c b/algo/blake/blake256-hash-4way.c
@@ -400,18 +400,18 @@ void blake256_transform_le( uint32_t *H, const uint32_t *buf,
 // Blake-256 4 way
 
 #define GS_4WAY( m0, m1, c0, c1, a, b, c, d ) \
-do { \
+{ \
    a = _mm_add_epi32( _mm_add_epi32( a, b ), \
                       _mm_xor_si128( _mm_set1_epi32( c1 ), m0 ) ); \
-   d = mm128_ror_32( _mm_xor_si128( d, a ), 16 ); \
+   d = mm128_swap32_16( _mm_xor_si128( d, a ) ); \
    c = _mm_add_epi32( c, d ); \
    b = mm128_ror_32( _mm_xor_si128( b, c ), 12 ); \
    a = _mm_add_epi32( _mm_add_epi32( a, b ), \
                       _mm_xor_si128( _mm_set1_epi32( c0 ), m1 ) ); \
-   d = mm128_ror_32( _mm_xor_si128( d, a ), 8 ); \
+   d = mm128_shuflr32_8( _mm_xor_si128( d, a ) ); \
    c = _mm_add_epi32( c, d ); \
    b = mm128_ror_32( _mm_xor_si128( b, c ), 7 ); \
-} while (0)
+}
 
 #if SPH_COMPACT_BLAKE_32
 
@@ -441,7 +441,8 @@ do { \
 
 #else
 
-#define ROUND_S_4WAY(r)   do { \
+#define ROUND_S_4WAY(r) \
+{ \
 	GS_4WAY(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
 	GS_4WAY(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
 	GS_4WAY(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
@@ -450,7 +451,7 @@ do { \
 	GS_4WAY(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
 	GS_4WAY(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
 	GS_4WAY(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
-} while (0)
+}
 
 #endif
 
@@ -537,7 +538,7 @@ do { \
 
 #if defined(__SSSE3__)
 
-#define BLAKE256_4WAY_BLOCK_BSWAP32 do \
+#define BLAKE256_4WAY_BLOCK_BSWAP32 \
 { \
    __m128i shuf_bswap32 = _mm_set_epi64x( 0x0c0d0e0f08090a0b, \
                                           0x0405060700010203 ); \
@@ -557,11 +558,11 @@ do { \
    MD = _mm_shuffle_epi8( buf[13], shuf_bswap32 ); \
    ME = _mm_shuffle_epi8( buf[14], shuf_bswap32 ); \
    MF = _mm_shuffle_epi8( buf[15], shuf_bswap32 ); \
-} while(0)
+}
 
 #else  // SSE2
 
-#define BLAKE256_4WAY_BLOCK_BSWAP32 do \
+#define BLAKE256_4WAY_BLOCK_BSWAP32 \
 { \
    M0 = mm128_bswap_32( buf[0] ); \
    M1 = mm128_bswap_32( buf[1] ); \
@@ -579,12 +580,12 @@ do { \
    MD = mm128_bswap_32( buf[13] ); \
    ME = mm128_bswap_32( buf[14] ); \
    MF = mm128_bswap_32( buf[15] ); \
-} while(0)
+}
 
 #endif  // SSSE3 else SSE2
 
 #define COMPRESS32_4WAY( rounds ) \
-do { \
+{ \
    __m128i M0, M1, M2, M3, M4, M5, M6, M7; \
    __m128i M8, M9, MA, MB, MC, MD, ME, MF; \
    __m128i V0, V1, V2, V3, V4, V5, V6, V7; \
@@ -631,7 +632,7 @@ do { \
    H5 = _mm_xor_si128( _mm_xor_si128( VD, V5 ), H5 ); \
    H6 = _mm_xor_si128( _mm_xor_si128( VE, V6 ), H6 ); \
    H7 = _mm_xor_si128( _mm_xor_si128( VF, V7 ), H7 ); \
-} while (0)
+}
 
 #endif
 
@@ -642,20 +643,21 @@ do { \
 // Blake-256 8 way
 
 #define GS_8WAY( m0, m1, c0, c1, a, b, c, d ) \
-do { \
+{ \
    a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
                          _mm256_xor_si256( _mm256_set1_epi32( c1 ), m0 ) ); \
-   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
+   d = mm256_swap32_16( _mm256_xor_si256( d, a ) ); \
    c = _mm256_add_epi32( c, d ); \
    b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
    a = _mm256_add_epi32( _mm256_add_epi32( a, b ), \
                          _mm256_xor_si256( _mm256_set1_epi32( c0 ), m1 ) ); \
-   d = mm256_ror_32( _mm256_xor_si256( d, a ), 8 ); \
+   d = mm256_shuflr32_8( _mm256_xor_si256( d, a ) ); \
    c = _mm256_add_epi32( c, d ); \
    b = mm256_ror_32( _mm256_xor_si256( b, c ), 7 ); \
-} while (0)
+}
 
-#define ROUND_S_8WAY(r)   do { \
+#define ROUND_S_8WAY(r) \
+{ \
         GS_8WAY(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
         GS_8WAY(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
         GS_8WAY(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
@@ -664,7 +666,7 @@ do { \
         GS_8WAY(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
         GS_8WAY(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
         GS_8WAY(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
-} while (0)
+}
 
 #define DECL_STATE32_8WAY \
    __m256i H0, H1, H2, H3, H4, H5, H6, H7; \
@@ -699,7 +701,7 @@ do { \
 } while (0)
 
 #define COMPRESS32_8WAY( rounds ) \
-do { \
+{ \
    __m256i M0, M1, M2, M3, M4, M5, M6, M7; \
    __m256i M8, M9, MA, MB, MC, MD, ME, MF; \
    __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
@@ -764,10 +766,10 @@ do { \
    H5 = mm256_xor3( VD, V5, H5 ); \
    H6 = mm256_xor3( VE, V6, H6 ); \
    H7 = mm256_xor3( VF, V7, H7 ); \
-} while (0)
+}
 
 #define COMPRESS32_8WAY_LE( rounds ) \
-do { \
+{ \
    __m256i M0, M1, M2, M3, M4, M5, M6, M7; \
    __m256i M8, M9, MA, MB, MC, MD, ME, MF; \
    __m256i V0, V1, V2, V3, V4, V5, V6, V7; \
@@ -829,7 +831,7 @@ do { \
    H5 = mm256_xor3( VD, V5, H5 ); \
    H6 = mm256_xor3( VE, V6, H6 ); \
    H7 = mm256_xor3( VF, V7, H7 ); \
-} while (0)
+}
 
 void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
                                        const void *data )
@@ -861,7 +863,7 @@ void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
    // G1   
    V[ 1] = _mm256_add_epi32( _mm256_add_epi32( V[ 1], V[ 5] ),
                          _mm256_xor_si256( _mm256_set1_epi32( CS3 ), M[ 2] ) );
-   V[13] = mm256_ror_32( _mm256_xor_si256( V[13], V[ 1] ), 16 );
+   V[13] = mm256_swap32_16( _mm256_xor_si256( V[13], V[ 1] ) );
    V[ 9] = _mm256_add_epi32( V[ 9], V[13] );
    V[ 5] = mm256_ror_32( _mm256_xor_si256( V[ 5], V[ 9] ), 12 );
    V[ 1] = _mm256_add_epi32( V[ 1], V[ 5] );
@@ -881,7 +883,7 @@ void blake256_8way_round0_prehash_le( void *midstate, const void *midhash,
    // G7   
    V[ 3] = _mm256_add_epi32( _mm256_add_epi32( V[ 3], V[ 4] ),
                          _mm256_xor_si256( _mm256_set1_epi32( CSF ), M[14] ) );
-   V[14] = mm256_ror_32( _mm256_xor_si256( V[14], V[ 3] ), 16 );
+   V[14] = mm256_swap32_16( _mm256_xor_si256( V[14], V[ 3] ) );
    V[ 3] = _mm256_add_epi32( V[ 3],
                          _mm256_xor_si256( _mm256_set1_epi32( CSE ), M[15] ) );
 }
@@ -935,39 +937,39 @@ void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
    // G1   
    V1 = _mm256_add_epi32( V1,
                          _mm256_xor_si256( _mm256_set1_epi32( CS2 ), M3 ) );
-   VD = mm256_ror_32( _mm256_xor_si256( VD, V1 ), 8 );
+   VD = mm256_shuflr32_8( _mm256_xor_si256( VD, V1 ) );
    V9 = _mm256_add_epi32( V9, VD );
    V5 = mm256_ror_32( _mm256_xor_si256( V5, V9 ), 7 );
 
    // G4
    V0 = _mm256_add_epi32( V0, V5 );
-   VF = mm256_ror_32( _mm256_xor_si256( VF, V0 ), 16 );
+   VF = mm256_swap32_16( _mm256_xor_si256( VF, V0 ) );
    VA = _mm256_add_epi32( VA, VF );
    V5 = mm256_ror_32( _mm256_xor_si256( V5, VA ), 12 );
    V0 = _mm256_add_epi32( V0, _mm256_add_epi32( V5,
                          _mm256_xor_si256( _mm256_set1_epi32( CS8 ), M9 ) ) );
-   VF = mm256_ror_32( _mm256_xor_si256( VF, V0 ), 8 );
+   VF = mm256_shuflr32_8( _mm256_xor_si256( VF, V0 ) );
    VA = _mm256_add_epi32( VA, VF );
    V5 = mm256_ror_32( _mm256_xor_si256( V5, VA ), 7 );
 
    // G5
    GS_8WAY( MA, MB, CSA, CSB, V1, V6, VB, VC );
 
    // G6
-   VD = mm256_ror_32( _mm256_xor_si256( VD, V2 ), 16 );
+   VD = mm256_swap32_16( _mm256_xor_si256( VD, V2 ) );
    V8 = _mm256_add_epi32( V8, VD );
    V7 = mm256_ror_32( _mm256_xor_si256( V7, V8 ), 12 );
    V2 = _mm256_add_epi32( _mm256_add_epi32( V2, V7 ),
                          _mm256_xor_si256( _mm256_set1_epi32( CSC ), MD ) );
-   VD = mm256_ror_32( _mm256_xor_si256( VD, V2 ), 8 );
+   VD = mm256_shuflr32_8( _mm256_xor_si256( VD, V2 ) );
    V8 = _mm256_add_epi32( V8, VD );
    V7 = mm256_ror_32( _mm256_xor_si256( V7, V8 ), 7 );
 
    // G7
    V9 = _mm256_add_epi32( V9, VE );
    V4 = mm256_ror_32( _mm256_xor_si256( V4, V9 ), 12 );
    V3 = _mm256_add_epi32( V3, V4 );
-   VE = mm256_ror_32( _mm256_xor_si256( VE, V3 ), 8 );
+   VE = mm256_shuflr32_8( _mm256_xor_si256( VE, V3 ) );
    V9 = _mm256_add_epi32( V9, VE );
    V4 = mm256_ror_32( _mm256_xor_si256( V4, V9 ), 7 );
 
@@ -1009,7 +1011,7 @@ void blake256_8way_final_rounds_le( void *final_hash, const void *midstate,
 // Blake-256 16 way AVX512
 
 #define GS_16WAY( m0, m1, c0, c1, a, b, c, d ) \
-do { \
+{ \
    a = _mm512_add_epi32( _mm512_add_epi32( a, b ), \
                          _mm512_xor_si512( _mm512_set1_epi32( c1 ), m0 ) ); \
    d = mm512_ror_32( _mm512_xor_si512( d, a ), 16 ); \
@@ -1020,9 +1022,10 @@ do { \
    d = mm512_ror_32( _mm512_xor_si512( d, a ), 8 ); \
    c = _mm512_add_epi32( c, d ); \
    b = mm512_ror_32( _mm512_xor_si512( b, c ), 7 ); \
-} while (0)
+}
 
-#define ROUND_S_16WAY(r)   do { \
+#define ROUND_S_16WAY(r) \
+{ \
         GS_16WAY(Mx(r, 0), Mx(r, 1), CSx(r, 0), CSx(r, 1), V0, V4, V8, VC); \
         GS_16WAY(Mx(r, 2), Mx(r, 3), CSx(r, 2), CSx(r, 3), V1, V5, V9, VD); \
         GS_16WAY(Mx(r, 4), Mx(r, 5), CSx(r, 4), CSx(r, 5), V2, V6, VA, VE); \
@@ -1031,7 +1034,7 @@ do { \
         GS_16WAY(Mx(r, A), Mx(r, B), CSx(r, A), CSx(r, B), V1, V6, VB, VC); \
         GS_16WAY(Mx(r, C), Mx(r, D), CSx(r, C), CSx(r, D), V2, V7, V8, VD); \
         GS_16WAY(Mx(r, E), Mx(r, F), CSx(r, E), CSx(r, F), V3, V4, V9, VE); \
-} while (0)
+}
 
 #define DECL_STATE32_16WAY \
    __m512i H0, H1, H2, H3, H4, H5, H6, H7; \
@@ -1066,7 +1069,7 @@ do { \
 } while (0)
 
 #define COMPRESS32_16WAY( rounds ) \
-do { \
+{ \
    __m512i M0, M1, M2, M3, M4, M5, M6, M7; \
    __m512i M8, M9, MA, MB, MC, MD, ME, MF; \
    __m512i V0, V1, V2, V3, V4, V5, V6, V7; \
@@ -1133,10 +1136,10 @@ do { \
    H5 = mm512_xor3( VD, V5, H5 ); \
    H6 = mm512_xor3( VE, V6, H6 ); \
    H7 = mm512_xor3( VF, V7, H7 ); \
-} while (0)
+}
 
 #define COMPRESS32_16WAY_LE( rounds ) \
-do { \
+{ \
    __m512i M0, M1, M2, M3, M4, M5, M6, M7; \
    __m512i M8, M9, MA, MB, MC, MD, ME, MF; \
    __m512i V0, V1, V2, V3, V4, V5, V6, V7; \
@@ -1198,7 +1201,7 @@ do { \
    H5 = mm512_xor3( VD, V5, H5 ); \
    H6 = mm512_xor3( VE, V6, H6 ); \
    H7 = mm512_xor3( VF, V7, H7 ); \
-} while (0)
+}
 
 // Blake-256 prehash of the second block is split onto 2 parts. The first part
 // is constant for every nonce and only needs to be run once per job. The

diff --git a/algo/blake/blake2b-hash-4way.c b/algo/blake/blake2b-hash-4way.c
@@ -388,11 +388,11 @@ void blake2b_8way_final( blake2b_8way_ctx *ctx, void *out )
 #define B2B_G(a, b, c, d, x, y) \
 { \
    v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), x ); \
-	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 32 ); \
+	v[d] = mm256_swap64_32( _mm256_xor_si256( v[d], v[a] ) ); \
 	v[c] = _mm256_add_epi64( v[c], v[d] ); \
-	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 24 ); \
+	v[b] = mm256_shuflr64_24( _mm256_xor_si256( v[b], v[c] ) ); \
 	v[a] = _mm256_add_epi64( _mm256_add_epi64( v[a], v[b] ), y ); \
-	v[d] = mm256_ror_64( _mm256_xor_si256( v[d], v[a] ), 16 ); \
+	v[d] = mm256_shuflr64_16( _mm256_xor_si256( v[d], v[a] ) ); \
 	v[c] = _mm256_add_epi64( v[c], v[d] ); \
 	v[b] = mm256_ror_64( _mm256_xor_si256( v[b], v[c] ), 63 ); \
 }

diff --git a/algo/blake/blake2s-hash-4way.c b/algo/blake/blake2s-hash-4way.c
@@ -108,11 +108,11 @@ do { \
    uint8_t s0 = sigma0; \
    uint8_t s1 = sigma1; \
    a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ s0 ] ); \
-   d = mm128_ror_32( _mm_xor_si128( d, a ), 16 ); \
+   d = mm128_swap32_16( _mm_xor_si128( d, a ) ); \
    c = _mm_add_epi32( c, d ); \
    b = mm128_ror_32( _mm_xor_si128( b, c ), 12 ); \
    a = _mm_add_epi32( _mm_add_epi32( a, b ), m[ s1 ] ); \
-   d = mm128_ror_32( _mm_xor_si128( d, a ),  8 ); \
+   d = mm128_shuflr32_8( _mm_xor_si128( d, a ) ); \
    c = _mm_add_epi32( c, d ); \
    b = mm128_ror_32( _mm_xor_si128( b, c ),  7 ); \
 } while(0)
@@ -320,11 +320,11 @@ do { \
    uint8_t s0 = sigma0; \
    uint8_t s1 = sigma1; \
    a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s0 ] ); \
-   d = mm256_ror_32( _mm256_xor_si256( d, a ), 16 ); \
+   d = mm256_swap32_16( _mm256_xor_si256( d, a ) ); \
    c = _mm256_add_epi32( c, d ); \
    b = mm256_ror_32( _mm256_xor_si256( b, c ), 12 ); \
    a = _mm256_add_epi32( _mm256_add_epi32( a, b ), m[ s1 ] ); \
-   d = mm256_ror_32( _mm256_xor_si256( d, a ),  8 ); \
+   d = mm256_shuflr32_8( _mm256_xor_si256( d, a ) ); \
    c = _mm256_add_epi32( c, d ); \
    b = mm256_ror_32( _mm256_xor_si256( b, c ),  7 ); \
 } while(0)