* Re: [PATCH] staging: skein: macros moved to header file
[not found] ` <K4fop6l----0@tutanota.de>
@ 2015-12-04 12:35 ` Jason Cooper
2015-12-04 14:25 ` Mathieu Poirier
1 sibling, 0 replies; 5+ messages in thread
From: Jason Cooper @ 2015-12-04 12:35 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: Gregkh, mathieu.poirier, deepa.kernel, brcnakalin,
vatikaharlalka, devel, Linux Kernel
Oh hell. :)
Go ahead and try to configure git send-mail, or configure Thunderbird
according to Documentation/email-clients.txt. If you want, send it to
me off list first to confirm it's not getting mangled like below.
I think you just won the obfuscated C contest...
thx,
Jason.
On Fri, Dec 04, 2015 at 07:09:49AM +0000, Sanidhya Solanki wrote:
> Staging: Skein: Moved macros from skein_block.c to header file.
> The original code defined macros in the source code, making it harder toread.
> Move them to the header file.
> Signed-off-by: Sanidhya Solanki
> <jpage@tutanota.de>--- drivers/staging/skein/skein_block.c | 321
> ----------------------------------- drivers/staging/skein/skein_block.h | 323
> ++++++++++++++++++++++++++++++++++++ 2 files changed, 323 insertions(+), 321
> deletions(-)
> diff --git a/drivers/staging/skein/skein_block.c
> b/drivers/staging/skein/skein_block.cindex 45b4732..9701f95 100644---
> a/drivers/staging/skein/skein_block.c+++
> b/drivers/staging/skein/skein_block.c@@ -18,327 +18,6 @@ #include
> "skein_base.h" #include "skein_block.h" -#ifndef SKEIN_USE_ASM-#define
> SKEIN_USE_ASM (0) /* default is all C code (no ASM) */-#endif--#ifndef
> SKEIN_LOOP-#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not
> 1024 */-#endif--#define BLK_BITS (WCNT * 64) /* some useful
> definitions for code here */-#define KW_TWK_BASE (0)-#define KW_KEY_BASE
> (3)-#define ks (kw + KW_KEY_BASE)-#define ts
> (kw + KW_TWK_BASE)--#ifdef SKEIN_DEBUG-#define debug_save_tweak(ctx)
> \-{ \- ctx->h.tweak[0] = ts[0];
> \- ctx->h.tweak[1] = ts[1]; \-}-#else-#define
> debug_save_tweak(ctx)-#endif--#if !(SKEIN_USE_ASM & 256)-#undef RCNT-#define
> RCNT (SKEIN_256_ROUNDS_TOTAL / 8)-#ifdef SKEIN_LOOP /* configure how much to
> unroll the loop */-#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) %
> 10)-#else-#define SKEIN_UNROLL_256 (0)-#endif--#if SKEIN_UNROLL_256-#if (RCNT
> % SKEIN_UNROLL_256)-#error "Invalid SKEIN_UNROLL_256" /* sanity check on
> unroll count */-#endif-#endif-#define ROUND256(p0, p1, p2, p3, ROT, r_num)
> \- do { \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1, ROT##_0); \- X##p1 ^= X##p0;
> \- X##p2 += X##p3; \- X##p3 =
> rotl_64(X##p3, ROT##_1); \- X##p3 ^= X##p2; \- }
> while (0)--#if SKEIN_UNROLL_256 == 0-#define R256(p0, p1, p2, p3, ROT, r_num)
> /* fully unrolled */ \- ROUND256(p0, p1, p2, p3, ROT, r_num)--#define I256(R)
> \- do {
> \- /* inject the key schedule
> value */ \- X0 += ks[((R) + 1) % 5];
> \- X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \- X2
> += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \- X3 += ks[((R) + 4)
> % 5] + (R) + 1; \- } while (0)-#else-/* looping version
> */-#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)--#define I256(R) \- do {
> \- /* inject the key schedule value */
> \- X0 += ks[r + (R) + 0]; \- X1 += ks[r + (R) + 1] +
> ts[r + (R) + 0];\- X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\- X3 += ks[r +
> (R) + 3] + r + (R); \- /* rotate key schedule */
> \- ks[r + (R) + 4] = ks[r + (R) - 1]; \- ts[r + (R) + 2] = ts[r + (R)
> - 1]; \- } while (0)-#endif-#define R256_8_ROUNDS(R)
> \- do { \- R256(0, 1,
> 2, 3, R_256_0, 8 * (R) + 1); \- R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2);
> \- R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \- R256(0, 3, 2, 1, R_256_3, 8 *
> (R) + 4); \- I256(2 * (R)); \- R256(0, 1, 2, 3,
> R_256_4, 8 * (R) + 5); \- R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6);
> \- R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \- R256(0, 3, 2, 1, R_256_7, 8 *
> (R) + 8); \- I256(2 * (R) + 1); \- } while (0)--#define
> R256_UNROLL_R(NN) \- ((SKEIN_UNROLL_256 == 0 &&
> \- SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \- (SKEIN_UNROLL_256 > (NN)))--#if
> (SKEIN_UNROLL_256 > 14)-#error "need more unrolling in
> skein_256_process_block"-#endif-#endif--#if !(SKEIN_USE_ASM & 512)-#undef
> RCNT-#define RCNT (SKEIN_512_ROUNDS_TOTAL/8)--#ifdef SKEIN_LOOP /*
> configure how much to unroll the loop */-#define SKEIN_UNROLL_512
> (((SKEIN_LOOP)/10)%10)-#else-#define SKEIN_UNROLL_512 (0)-#endif--#if
> SKEIN_UNROLL_512-#if (RCNT % SKEIN_UNROLL_512)-#error "Invalid
> SKEIN_UNROLL_512" /* sanity check on unroll count */-#endif-#endif-#define
> ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \- do {
> \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1, ROT##_0); \- X##p1 ^=
> X##p0; \- X##p2 += X##p3;
> \- X##p3 = rotl_64(X##p3, ROT##_1); \- X##p3
> ^= X##p2; \- X##p4 += X##p5;
> \- X##p5 = rotl_64(X##p5, ROT##_2); \- X##p5
> ^= X##p4; \- X##p6 += X##p7; X##p7 =
> rotl_64(X##p7, ROT##_3);\- X##p7 ^= X##p6;
> \- } while (0)--#if SKEIN_UNROLL_512 == 0-#define R512(p0, p1, p2, p3, p4,
> p5, p6, p7, ROT, r_num) /* unrolled */ \- ROUND512(p0, p1, p2, p3, p4, p5,
> p6, p7, ROT, r_num)--#define I512(R)
> \- do {
> \- /* inject the key schedule value */ \- X0 +=
> ks[((R) + 1) % 9]; \- X1 += ks[((R) + 2) %
> 9]; \- X2 += ks[((R) + 3) % 9];
> \- X3 += ks[((R) + 4) % 9];
> \- X4 += ks[((R) + 5) % 9]; \- X5 +=
> ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \- X6 += ks[((R) + 7) % 9]
> + ts[((R) + 2) % 3]; \- X7 += ks[((R) + 8) % 9] + (R) + 1;
> \- } while (0)--#else /* looping version */-#define R512(p0, p1,
> p2, p3, p4, p5, p6, p7, ROT, r_num) \- ROUND512(p0, p1, p2,
> p3, p4, p5, p6, p7, ROT, r_num) \--#define I512(R)
> \- do {
> \- /* inject the key schedule value */
> \- X0 += ks[r + (R) + 0];
> \- X1 += ks[r + (R) + 1]; \- X2 += ks[r
> + (R) + 2]; \- X3 += ks[r + (R) + 3];
> \- X4 += ks[r + (R) + 4];
> \- X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \- X6
> += ks[r + (R) + 6] + ts[r + (R) + 1]; \- X7 += ks[r + (R) +
> 7] + r + (R); \- /* rotate key schedule */
> \- ks[r + (R) + 8] = ks[r + (R) - 1];
> \- ts[r + (R) + 2] = ts[r + (R) - 1]; \- } while
> (0)-#endif /* end of looped code definitions */-#define R512_8_ROUNDS(R) /*
> do 8 full rounds */ \- do {
> \- R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8
> * (R) + 1); \- R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2);
> \- R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \- R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \- I512(2 * (R));
> \- R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) +
> 5); \- R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6);
> \- R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \- R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \- I512(2 * (R) + 1); /* and key
> injection */ \- } while (0)-#define R512_UNROLL_R(NN)
> \- ((SKEIN_UNROLL_512 == 0 &&
> \- SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \- (SKEIN_UNROLL_512 >
> (NN)))--#if (SKEIN_UNROLL_512 > 14)-#error "need more unrolling in
> skein_512_process_block"-#endif-#endif--#if !(SKEIN_USE_ASM & 1024)-#undef
> RCNT-#define RCNT (SKEIN_1024_ROUNDS_TOTAL/8)-#ifdef SKEIN_LOOP /*
> configure how much to unroll the loop */-#define SKEIN_UNROLL_1024
> ((SKEIN_LOOP) % 10)-#else-#define SKEIN_UNROLL_1024 (0)-#endif--#if
> (SKEIN_UNROLL_1024 != 0)-#if (RCNT % SKEIN_UNROLL_1024)-#error "Invalid
> SKEIN_UNROLL_1024" /* sanity check on unroll count */-#endif-#endif-#define
> ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \-
> pF, ROT, r_num) \- do {
> \- X##p0 += X##p1;
> \- X##p1 = rotl_64(X##p1,
> ROT##_0); \- X##p1 ^= X##p0;
> \- X##p2 += X##p3;
> \- X##p3 = rotl_64(X##p3, ROT##_1);
> \- X##p3 ^= X##p2;
> \- X##p4 += X##p5; \- X##p5 =
> rotl_64(X##p5, ROT##_2); \- X##p5 ^= X##p4;
> \- X##p6 += X##p7;
> \- X##p7 = rotl_64(X##p7, ROT##_3);
> \- X##p7 ^= X##p6;
> \- X##p8 += X##p9;
> \- X##p9 = rotl_64(X##p9, ROT##_4); \- X##p9
> ^= X##p8; \- X##pA += X##pB;
> \- X##pB = rotl_64(X##pB,
> ROT##_5); \- X##pB ^= X##pA;
> \- X##pC += X##pD;
> \- X##pD = rotl_64(X##pD, ROT##_6);
> \- X##pD ^= X##pC;
> \- X##pE += X##pF; \- X##pF =
> rotl_64(X##pF, ROT##_7); \- X##pF ^= X##pE;
> \- } while (0)--#if
> SKEIN_UNROLL_1024 == 0-#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
> pA, pB, pC, pD, pE, pF, \- ROT, rn)
> \- ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA,
> pB, pC, pD, pE, \- pF, ROT, rn)
> \--#define I1024(R) \- do
> { \- /* inject the key
> schedule value */ \- X00 += ks[((R) + 1) % 17];
> \- X01 += ks[((R) + 2) % 17]; \- X02 += ks[((R) +
> 3) % 17]; \- X03 += ks[((R) + 4) % 17];
> \- X04 += ks[((R) + 5) % 17]; \- X05 += ks[((R) +
> 6) % 17]; \- X06 += ks[((R) + 7) % 17];
> \- X07 += ks[((R) + 8) % 17]; \- X08 += ks[((R) +
> 9) % 17]; \- X09 += ks[((R) + 10) % 17];
> \- X10 += ks[((R) + 11) % 17]; \- X11 += ks[((R)
> + 12) % 17]; \- X12 += ks[((R) + 13) % 17];
> \- X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \- X14 +=
> ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \- X15 += ks[((R) + 16) % 17] + (R)
> + 1; \- } while (0)-#else /* looping version */-#define R1024(p0,
> p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \- ROT, rn)
> \- ROUND1024(p0, p1,
> p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \- pF, ROT, rn)
> \--#define I1024(R)
> \- do {
> \- /* inject the key schedule value */
> \- X00 += ks[r + (R) + 0];
> \- X01 += ks[r + (R) + 1]; \- X02 += ks[r +
> (R) + 2]; \- X03 += ks[r + (R) + 3];
> \- X04 += ks[r + (R) + 4];
> \- X05 += ks[r + (R) + 5]; \- X06 +=
> ks[r + (R) + 6]; \- X07 += ks[r + (R) + 7];
> \- X08 += ks[r + (R) + 8];
> \- X09 += ks[r + (R) + 9];
> \- X10 += ks[r + (R) + 10]; \- X11 += ks[r +
> (R) + 11]; \- X12 += ks[r + (R) + 12];
> \- X13 += ks[r + (R) + 13] + ts[r + (R) + 0];
> \- X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \- X15 +=
> ks[r + (R) + 15] + r + (R); \- /* rotate key schedule
> */ \- ks[r + (R) + 16] = ks[r + (R) - 1];
> \- ts[r + (R) + 2] = ts[r + (R) - 1];
> \- } while (0)--#endif-#define R1024_8_ROUNDS(R)
> \- do {
> \- R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \-
> 13, 14, 15, R1024_0, 8*(R) + 1); \- R1024(00, 09,
> 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \- 05, 08, 01, R1024_1,
> 8*(R) + 2); \- R1024(00, 07, 02, 05, 04, 03, 06, 01, 12,
> 15, 14, 13, 08, \- 11, 10, 09, R1024_2, 8*(R) + 3);
> \- R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \- 03,
> 12, 07, R1024_3, 8*(R) + 4); \- I1024(2*(R));
> \- R1024(00, 01, 02, 03, 04, 05, 06, 07, 08,
> 09, 10, 11, 12, \- 13, 14, 15, R1024_4, 8*(R) + 5);
> \- R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \- 05,
> 08, 01, R1024_5, 8*(R) + 6); \- R1024(00, 07, 02, 05, 04,
> 03, 06, 01, 12, 15, 14, 13, 08, \- 11, 10, 09, R1024_6, 8*(R) + 7);
> \- R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05,
> 10, \- 03, 12, 07, R1024_7, 8*(R) + 8);
> \- I1024(2*(R)+1); \- } while
> (0)--#define R1024_UNROLL_R(NN)
> \- ((SKEIN_UNROLL_1024 == 0 && \- SKEIN_1024_ROUNDS_TOTAL/8 >
> (NN)) || \- (SKEIN_UNROLL_1024 > (NN)))--#if (SKEIN_UNROLL_1024 >
> 14)-#error "need more unrolling in
> Skein_1024_Process_Block"-#endif-#endif /*****************************
> SKEIN_256 ******************************/ #if !(SKEIN_USE_ASM & 256)diff
> --git a/drivers/staging/skein/skein_block.h
> b/drivers/staging/skein/skein_block.hindex 9d40f4a..1b28d52 100644---
> a/drivers/staging/skein/skein_block.h+++
> b/drivers/staging/skein/skein_block.h@@ -20,3 +20,326 @@ void
> skein_1024_process_block(struct skein_1024_ctx *ctx, const u8 *blk_ptr,
> size_t blk_cnt, size_t byte_cnt_add); #endif+++#ifndef
> SKEIN_USE_ASM+#define SKEIN_USE_ASM (0) /* default is all C code (no ASM)
> */+#endif++#ifndef SKEIN_LOOP+#define SKEIN_LOOP 001 /* default: unroll 256
> and 512, but not 1024 */+#endif++#define BLK_BITS (WCNT * 64) /* some
> useful definitions for code here */+#define KW_TWK_BASE (0)+#define
> KW_KEY_BASE (3)+#define ks (kw + KW_KEY_BASE)+#define ts
> (kw + KW_TWK_BASE)++#ifdef SKEIN_DEBUG+#define debug_save_tweak(ctx)
> \+{ \+ ctx->h.tweak[0] = ts[0];
> \+ ctx->h.tweak[1] = ts[1]; \+}+#else+#define
> debug_save_tweak(ctx)+#endif++#if !(SKEIN_USE_ASM & 256)+#undef RCNT+#define
> RCNT (SKEIN_256_ROUNDS_TOTAL / 8)+#ifdef SKEIN_LOOP /* configure how much to
> unroll the loop */+#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) %
> 10)+#else+#define SKEIN_UNROLL_256 (0)+#endif++#if SKEIN_UNROLL_256+#if (RCNT
> % SKEIN_UNROLL_256)+#error "Invalid SKEIN_UNROLL_256" /* sanity check on
> unroll count */+#endif+#endif+#define ROUND256(p0, p1, p2, p3, ROT, r_num)
> \+ do { \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1, ROT##_0); \+ X##p1 ^= X##p0;
> \+ X##p2 += X##p3; \+ X##p3 =
> rotl_64(X##p3, ROT##_1); \+ X##p3 ^= X##p2; \+ }
> while (0)++#if SKEIN_UNROLL_256 == 0+#define R256(p0, p1, p2, p3, ROT, r_num)
> /* fully unrolled */ \+ ROUND256(p0, p1, p2, p3, ROT, r_num)++#define I256(R)
> \+ do {
> \+ /* inject the key schedule
> value */ \+ X0 += ks[((R) + 1) % 5];
> \+ X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \+ X2
> += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \+ X3 += ks[((R) + 4)
> % 5] + (R) + 1; \+ } while (0)+#else+/* looping version
> */+#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)++#define I256(R) \+ do {
> \+ /* inject the key schedule value */
> \+ X0 += ks[r + (R) + 0]; \+ X1 += ks[r + (R) + 1] +
> ts[r + (R) + 0];\+ X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\+ X3 += ks[r +
> (R) + 3] + r + (R); \+ /* rotate key schedule */
> \+ ks[r + (R) + 4] = ks[r + (R) - 1]; \+ ts[r + (R) + 2] = ts[r + (R)
> - 1]; \+ } while (0)+#endif+#define R256_8_ROUNDS(R)
> \+ do { \+ R256(0, 1,
> 2, 3, R_256_0, 8 * (R) + 1); \+ R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2);
> \+ R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \+ R256(0, 3, 2, 1, R_256_3, 8 *
> (R) + 4); \+ I256(2 * (R)); \+ R256(0, 1, 2, 3,
> R_256_4, 8 * (R) + 5); \+ R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6);
> \+ R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \+ R256(0, 3, 2, 1, R_256_7, 8 *
> (R) + 8); \+ I256(2 * (R) + 1); \+ } while (0)++#define
> R256_UNROLL_R(NN) \+ ((SKEIN_UNROLL_256 == 0 &&
> \+ SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \+ (SKEIN_UNROLL_256 > (NN)))++#if
> (SKEIN_UNROLL_256 > 14)+#error "need more unrolling in
> skein_256_process_block"+#endif+#endif++#if !(SKEIN_USE_ASM & 512)+#undef
> RCNT+#define RCNT (SKEIN_512_ROUNDS_TOTAL/8)++#ifdef SKEIN_LOOP /*
> configure how much to unroll the loop */+#define SKEIN_UNROLL_512
> (((SKEIN_LOOP)/10)%10)+#else+#define SKEIN_UNROLL_512 (0)+#endif++#if
> SKEIN_UNROLL_512+#if (RCNT % SKEIN_UNROLL_512)+#error "Invalid
> SKEIN_UNROLL_512" /* sanity check on unroll count */+#endif+#endif+#define
> ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \+ do {
> \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1, ROT##_0); \+ X##p1 ^=
> X##p0; \+ X##p2 += X##p3;
> \+ X##p3 = rotl_64(X##p3, ROT##_1); \+ X##p3
> ^= X##p2; \+ X##p4 += X##p5;
> \+ X##p5 = rotl_64(X##p5, ROT##_2); \+ X##p5
> ^= X##p4; \+ X##p6 += X##p7; X##p7 =
> rotl_64(X##p7, ROT##_3);\+ X##p7 ^= X##p6;
> \+ } while (0)++#if SKEIN_UNROLL_512 == 0+#define R512(p0, p1, p2, p3, p4,
> p5, p6, p7, ROT, r_num) /* unrolled */ \+ ROUND512(p0, p1, p2, p3, p4, p5,
> p6, p7, ROT, r_num)++#define I512(R)
> \+ do {
> \+ /* inject the key schedule value */ \+ X0 +=
> ks[((R) + 1) % 9]; \+ X1 += ks[((R) + 2) %
> 9]; \+ X2 += ks[((R) + 3) % 9];
> \+ X3 += ks[((R) + 4) % 9];
> \+ X4 += ks[((R) + 5) % 9]; \+ X5 +=
> ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \+ X6 += ks[((R) + 7) % 9]
> + ts[((R) + 2) % 3]; \+ X7 += ks[((R) + 8) % 9] + (R) + 1;
> \+ } while (0)++#else /* looping version */+#define R512(p0, p1,
> p2, p3, p4, p5, p6, p7, ROT, r_num) \+ ROUND512(p0, p1, p2,
> p3, p4, p5, p6, p7, ROT, r_num) \++#define I512(R)
> \+ do {
> \+ /* inject the key schedule value */
> \+ X0 += ks[r + (R) + 0];
> \+ X1 += ks[r + (R) + 1]; \+ X2 += ks[r
> + (R) + 2]; \+ X3 += ks[r + (R) + 3];
> \+ X4 += ks[r + (R) + 4];
> \+ X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \+ X6
> += ks[r + (R) + 6] + ts[r + (R) + 1]; \+ X7 += ks[r + (R) +
> 7] + r + (R); \+ /* rotate key schedule */
> \+ ks[r + (R) + 8] = ks[r + (R) - 1];
> \+ ts[r + (R) + 2] = ts[r + (R) - 1]; \+ } while
> (0)+#endif /* end of looped code definitions */+#define R512_8_ROUNDS(R) /*
> do 8 full rounds */ \+ do {
> \+ R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8
> * (R) + 1); \+ R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2);
> \+ R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \+ R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \+ I512(2 * (R));
> \+ R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) +
> 5); \+ R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6);
> \+ R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \+ R512(6, 1, 0,
> 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \+ I512(2 * (R) + 1); /* and key
> injection */ \+ } while (0)+#define R512_UNROLL_R(NN)
> \+ ((SKEIN_UNROLL_512 == 0 &&
> \+ SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \+ (SKEIN_UNROLL_512 >
> (NN)))++#if (SKEIN_UNROLL_512 > 14)+#error "need more unrolling in
> skein_512_process_block"+#endif+#endif++#if !(SKEIN_USE_ASM & 1024)+#undef
> RCNT+#define RCNT (SKEIN_1024_ROUNDS_TOTAL/8)+#ifdef SKEIN_LOOP /*
> configure how much to unroll the loop */+#define SKEIN_UNROLL_1024
> ((SKEIN_LOOP) % 10)+#else+#define SKEIN_UNROLL_1024 (0)+#endif++#if
> (SKEIN_UNROLL_1024 != 0)+#if (RCNT % SKEIN_UNROLL_1024)+#error "Invalid
> SKEIN_UNROLL_1024" /* sanity check on unroll count */+#endif+#endif+#define
> ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \+
> pF, ROT, r_num) \+ do {
> \+ X##p0 += X##p1;
> \+ X##p1 = rotl_64(X##p1,
> ROT##_0); \+ X##p1 ^= X##p0;
> \+ X##p2 += X##p3;
> \+ X##p3 = rotl_64(X##p3, ROT##_1);
> \+ X##p3 ^= X##p2;
> \+ X##p4 += X##p5; \+ X##p5 =
> rotl_64(X##p5, ROT##_2); \+ X##p5 ^= X##p4;
> \+ X##p6 += X##p7;
> \+ X##p7 = rotl_64(X##p7, ROT##_3);
> \+ X##p7 ^= X##p6;
> \+ X##p8 += X##p9;
> \+ X##p9 = rotl_64(X##p9, ROT##_4); \+ X##p9
> ^= X##p8; \+ X##pA += X##pB;
> \+ X##pB = rotl_64(X##pB,
> ROT##_5); \+ X##pB ^= X##pA;
> \+ X##pC += X##pD;
> \+ X##pD = rotl_64(X##pD, ROT##_6);
> \+ X##pD ^= X##pC;
> \+ X##pE += X##pF; \+ X##pF =
> rotl_64(X##pF, ROT##_7); \+ X##pF ^= X##pE;
> \+ } while (0)++#if
> SKEIN_UNROLL_1024 == 0+#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9,
> pA, pB, pC, pD, pE, pF, \+ ROT, rn)
> \+ ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA,
> pB, pC, pD, pE, \+ pF, ROT, rn)
> \++#define I1024(R) \+ do
> { \+ /* inject the key
> schedule value */ \+ X00 += ks[((R) + 1) % 17];
> \+ X01 += ks[((R) + 2) % 17]; \+ X02 += ks[((R) +
> 3) % 17]; \+ X03 += ks[((R) + 4) % 17];
> \+ X04 += ks[((R) + 5) % 17]; \+ X05 += ks[((R) +
> 6) % 17]; \+ X06 += ks[((R) + 7) % 17];
> \+ X07 += ks[((R) + 8) % 17]; \+ X08 += ks[((R) +
> 9) % 17]; \+ X09 += ks[((R) + 10) % 17];
> \+ X10 += ks[((R) + 11) % 17]; \+ X11 += ks[((R)
> + 12) % 17]; \+ X12 += ks[((R) + 13) % 17];
> \+ X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \+ X14 +=
> ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \+ X15 += ks[((R) + 16) % 17] + (R)
> + 1; \+ } while (0)+#else /* looping version */+#define R1024(p0,
> p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, pF, \+ ROT, rn)
> \+ ROUND1024(p0, p1,
> p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \+ pF, ROT, rn)
> \++#define I1024(R)
> \+ do {
> \+ /* inject the key schedule value */
> \+ X00 += ks[r + (R) + 0];
> \+ X01 += ks[r + (R) + 1]; \+ X02 += ks[r +
> (R) + 2]; \+ X03 += ks[r + (R) + 3];
> \+ X04 += ks[r + (R) + 4];
> \+ X05 += ks[r + (R) + 5]; \+ X06 +=
> ks[r + (R) + 6]; \+ X07 += ks[r + (R) + 7];
> \+ X08 += ks[r + (R) + 8];
> \+ X09 += ks[r + (R) + 9];
> \+ X10 += ks[r + (R) + 10]; \+ X11 += ks[r +
> (R) + 11]; \+ X12 += ks[r + (R) + 12];
> \+ X13 += ks[r + (R) + 13] + ts[r + (R) + 0];
> \+ X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \+ X15 +=
> ks[r + (R) + 15] + r + (R); \+ /* rotate key schedule
> */ \+ ks[r + (R) + 16] = ks[r + (R) - 1];
> \+ ts[r + (R) + 2] = ts[r + (R) - 1];
> \+ } while (0)++#endif+#define R1024_8_ROUNDS(R)
> \+ do {
> \+ R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \+
> 13, 14, 15, R1024_0, 8*(R) + 1); \+ R1024(00, 09,
> 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \+ 05, 08, 01, R1024_1,
> 8*(R) + 2); \+ R1024(00, 07, 02, 05, 04, 03, 06, 01, 12,
> 15, 14, 13, 08, \+ 11, 10, 09, R1024_2, 8*(R) + 3);
> \+ R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \+ 03,
> 12, 07, R1024_3, 8*(R) + 4); \+ I1024(2*(R));
> \+ R1024(00, 01, 02, 03, 04, 05, 06, 07, 08,
> 09, 10, 11, 12, \+ 13, 14, 15, R1024_4, 8*(R) + 5);
> \+ R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \+ 05,
> 08, 01, R1024_5, 8*(R) + 6); \+ R1024(00, 07, 02, 05, 04,
> 03, 06, 01, 12, 15, 14, 13, 08, \+ 11, 10, 09, R1024_6, 8*(R) + 7);
> \+ R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05,
> 10, \+ 03, 12, 07, R1024_7, 8*(R) + 8);
> \+ I1024(2*(R)+1); \+ } while
> (0)++#define R1024_UNROLL_R(NN)
> \+ ((SKEIN_UNROLL_1024 == 0 && \+ SKEIN_1024_ROUNDS_TOTAL/8 >
> (NN)) || \+ (SKEIN_UNROLL_1024 > (NN)))++#if (SKEIN_UNROLL_1024 >
> 14)+#error "need more unrolling in
> Skein_1024_Process_Block"+#endif+#endif-- 2.5.0
^ permalink raw reply [flat|nested] 5+ messages in thread* Re: [PATCH] staging: skein: macros moved to header file
[not found] ` <K4fop6l----0@tutanota.de>
2015-12-04 12:35 ` [PATCH] staging: skein: macros moved to header file Jason Cooper
@ 2015-12-04 14:25 ` Mathieu Poirier
1 sibling, 0 replies; 5+ messages in thread
From: Mathieu Poirier @ 2015-12-04 14:25 UTC (permalink / raw)
To: Sanidhya Solanki
Cc: Gregkh, Jason, deepa.kernel, brcnakalin, vatikaharlalka, devel,
Linux Kernel
On 4 December 2015 at 00:09, Sanidhya Solanki <jpage@tutanota.de> wrote:
> Staging: Skein: Moved macros from skein_block.c to header file.
>
> The original code defined macros in the source code, making it harder to
> read. Move them to the header file.
The patch didn't end up mangled on my side but definitely did not
cleared checkpatch, which may indicate some sort of problem with the
email client (as I assume you did indeed run checkpatch.sh).
It would also be a good idea to update the TODO file to reflect that
some of the macros have now been moved to a header file.
I will review the work when checkpatch is happy.
Thanks,
Mathieu
>
> Signed-off-by: Sanidhya Solanki <jpage@tutanota.de>
> ---
> drivers/staging/skein/skein_block.c | 321
> -----------------------------------
> drivers/staging/skein/skein_block.h | 323
> ++++++++++++++++++++++++++++++++++++
> 2 files changed, 323 insertions(+), 321 deletions(-)
>
> diff --git a/drivers/staging/skein/skein_block.c
> b/drivers/staging/skein/skein_block.c
> index 45b4732..9701f95 100644
> --- a/drivers/staging/skein/skein_block.c
> +++ b/drivers/staging/skein/skein_block.c
> @@ -18,327 +18,6 @@
> #include "skein_base.h"
> #include "skein_block.h"
>
> -#ifndef SKEIN_USE_ASM
> -#define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */
> -#endif
> -
> -#ifndef SKEIN_LOOP
> -#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */
> -#endif
> -
> -#define BLK_BITS (WCNT * 64) /* some useful definitions for code
> here */
> -#define KW_TWK_BASE (0)
> -#define KW_KEY_BASE (3)
> -#define ks (kw + KW_KEY_BASE)
> -#define ts (kw + KW_TWK_BASE)
> -
> -#ifdef SKEIN_DEBUG
> -#define debug_save_tweak(ctx) \
> -{ \
> - ctx->h.tweak[0] = ts[0]; \
> - ctx->h.tweak[1] = ts[1]; \
> -}
> -#else
> -#define debug_save_tweak(ctx)
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 256)
> -#undef RCNT
> -#define RCNT (SKEIN_256_ROUNDS_TOTAL / 8)
> -#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> -#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) % 10)
> -#else
> -#define SKEIN_UNROLL_256 (0)
> -#endif
> -
> -#if SKEIN_UNROLL_256
> -#if (RCNT % SKEIN_UNROLL_256)
> -#error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND256(p0, p1, p2, p3, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_256 == 0
> -#define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \
> - ROUND256(p0, p1, p2, p3, ROT, r_num)
> -
> -#define I256(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[((R) + 1) % 5]; \
> - X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \
> - X2 += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \
> - X3 += ks[((R) + 4) % 5] + (R) + 1; \
> - } while (0)
> -#else
> -/* looping version */
> -#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)
> -
> -#define I256(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[r + (R) + 0]; \
> - X1 += ks[r + (R) + 1] + ts[r + (R) + 0];\
> - X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\
> - X3 += ks[r + (R) + 3] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 4] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -#endif
> -#define R256_8_ROUNDS(R) \
> - do { \
> - R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \
> - R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \
> - R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \
> - R256(0, 3, 2, 1, R_256_3, 8 * (R) + 4); \
> - I256(2 * (R)); \
> - R256(0, 1, 2, 3, R_256_4, 8 * (R) + 5); \
> - R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6); \
> - R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \
> - R256(0, 3, 2, 1, R_256_7, 8 * (R) + 8); \
> - I256(2 * (R) + 1); \
> - } while (0)
> -
> -#define R256_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_256 == 0 && \
> - SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \
> - (SKEIN_UNROLL_256 > (NN)))
> -
> -#if (SKEIN_UNROLL_256 > 14)
> -#error "need more unrolling in skein_256_process_block"
> -#endif
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 512)
> -#undef RCNT
> -#define RCNT (SKEIN_512_ROUNDS_TOTAL/8)
> -
> -#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> -#define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10)
> -#else
> -#define SKEIN_UNROLL_512 (0)
> -#endif
> -
> -#if SKEIN_UNROLL_512
> -#if (RCNT % SKEIN_UNROLL_512)
> -#error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - X##p4 += X##p5; \
> - X##p5 = rotl_64(X##p5, ROT##_2); \
> - X##p5 ^= X##p4; \
> - X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3);\
> - X##p7 ^= X##p6; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_512 == 0
> -#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \
> - ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num)
> -
> -#define I512(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[((R) + 1) % 9]; \
> - X1 += ks[((R) + 2) % 9]; \
> - X2 += ks[((R) + 3) % 9]; \
> - X3 += ks[((R) + 4) % 9]; \
> - X4 += ks[((R) + 5) % 9]; \
> - X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \
> - X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \
> - X7 += ks[((R) + 8) % 9] + (R) + 1; \
> - } while (0)
> -
> -#else /* looping version */
> -#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> - ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> -
> -#define I512(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X0 += ks[r + (R) + 0]; \
> - X1 += ks[r + (R) + 1]; \
> - X2 += ks[r + (R) + 2]; \
> - X3 += ks[r + (R) + 3]; \
> - X4 += ks[r + (R) + 4]; \
> - X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \
> - X6 += ks[r + (R) + 6] + ts[r + (R) + 1]; \
> - X7 += ks[r + (R) + 7] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 8] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -#endif /* end of looped code definitions */
> -#define R512_8_ROUNDS(R) /* do 8 full rounds */ \
> - do { \
> - R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \
> - R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \
> - R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \
> - R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \
> - I512(2 * (R)); \
> - R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) + 5); \
> - R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6); \
> - R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \
> - R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \
> - I512(2 * (R) + 1); /* and key injection */ \
> - } while (0)
> -#define R512_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_512 == 0 && \
> - SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \
> - (SKEIN_UNROLL_512 > (NN)))
> -
> -#if (SKEIN_UNROLL_512 > 14)
> -#error "need more unrolling in skein_512_process_block"
> -#endif
> -#endif
> -
> -#if !(SKEIN_USE_ASM & 1024)
> -#undef RCNT
> -#define RCNT (SKEIN_1024_ROUNDS_TOTAL/8)
> -#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> -#define SKEIN_UNROLL_1024 ((SKEIN_LOOP) % 10)
> -#else
> -#define SKEIN_UNROLL_1024 (0)
> -#endif
> -
> -#if (SKEIN_UNROLL_1024 != 0)
> -#if (RCNT % SKEIN_UNROLL_1024)
> -#error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */
> -#endif
> -#endif
> -#define ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD,
> pE, \
> - pF, ROT, r_num) \
> - do { \
> - X##p0 += X##p1; \
> - X##p1 = rotl_64(X##p1, ROT##_0); \
> - X##p1 ^= X##p0; \
> - X##p2 += X##p3; \
> - X##p3 = rotl_64(X##p3, ROT##_1); \
> - X##p3 ^= X##p2; \
> - X##p4 += X##p5; \
> - X##p5 = rotl_64(X##p5, ROT##_2); \
> - X##p5 ^= X##p4; \
> - X##p6 += X##p7; \
> - X##p7 = rotl_64(X##p7, ROT##_3); \
> - X##p7 ^= X##p6; \
> - X##p8 += X##p9; \
> - X##p9 = rotl_64(X##p9, ROT##_4); \
> - X##p9 ^= X##p8; \
> - X##pA += X##pB; \
> - X##pB = rotl_64(X##pB, ROT##_5); \
> - X##pB ^= X##pA; \
> - X##pC += X##pD; \
> - X##pD = rotl_64(X##pD, ROT##_6); \
> - X##pD ^= X##pC; \
> - X##pE += X##pF; \
> - X##pF = rotl_64(X##pF, ROT##_7); \
> - X##pF ^= X##pE; \
> - } while (0)
> -
> -#if SKEIN_UNROLL_1024 == 0
> -#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> - ROT, rn) \
> - ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> - pF, ROT, rn) \
> -
> -#define I1024(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X00 += ks[((R) + 1) % 17]; \
> - X01 += ks[((R) + 2) % 17]; \
> - X02 += ks[((R) + 3) % 17]; \
> - X03 += ks[((R) + 4) % 17]; \
> - X04 += ks[((R) + 5) % 17]; \
> - X05 += ks[((R) + 6) % 17]; \
> - X06 += ks[((R) + 7) % 17]; \
> - X07 += ks[((R) + 8) % 17]; \
> - X08 += ks[((R) + 9) % 17]; \
> - X09 += ks[((R) + 10) % 17]; \
> - X10 += ks[((R) + 11) % 17]; \
> - X11 += ks[((R) + 12) % 17]; \
> - X12 += ks[((R) + 13) % 17]; \
> - X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \
> - X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \
> - X15 += ks[((R) + 16) % 17] + (R) + 1; \
> - } while (0)
> -#else /* looping version */
> -#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> - ROT, rn) \
> - ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> - pF, ROT, rn) \
> -
> -#define I1024(R) \
> - do { \
> - /* inject the key schedule value */ \
> - X00 += ks[r + (R) + 0]; \
> - X01 += ks[r + (R) + 1]; \
> - X02 += ks[r + (R) + 2]; \
> - X03 += ks[r + (R) + 3]; \
> - X04 += ks[r + (R) + 4]; \
> - X05 += ks[r + (R) + 5]; \
> - X06 += ks[r + (R) + 6]; \
> - X07 += ks[r + (R) + 7]; \
> - X08 += ks[r + (R) + 8]; \
> - X09 += ks[r + (R) + 9]; \
> - X10 += ks[r + (R) + 10]; \
> - X11 += ks[r + (R) + 11]; \
> - X12 += ks[r + (R) + 12]; \
> - X13 += ks[r + (R) + 13] + ts[r + (R) + 0]; \
> - X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \
> - X15 += ks[r + (R) + 15] + r + (R); \
> - /* rotate key schedule */ \
> - ks[r + (R) + 16] = ks[r + (R) - 1]; \
> - ts[r + (R) + 2] = ts[r + (R) - 1]; \
> - } while (0)
> -
> -#endif
> -#define R1024_8_ROUNDS(R) \
> - do { \
> - R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> - 13, 14, 15, R1024_0, 8*(R) + 1); \
> - R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> - 05, 08, 01, R1024_1, 8*(R) + 2); \
> - R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> - 11, 10, 09, R1024_2, 8*(R) + 3); \
> - R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
> - 03, 12, 07, R1024_3, 8*(R) + 4); \
> - I1024(2*(R)); \
> - R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> - 13, 14, 15, R1024_4, 8*(R) + 5); \
> - R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> - 05, 08, 01, R1024_5, 8*(R) + 6); \
> - R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> - 11, 10, 09, R1024_6, 8*(R) + 7); \
> - R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
> - 03, 12, 07, R1024_7, 8*(R) + 8); \
> - I1024(2*(R)+1); \
> - } while (0)
> -
> -#define R1024_UNROLL_R(NN) \
> - ((SKEIN_UNROLL_1024 == 0 && \
> - SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) || \
> - (SKEIN_UNROLL_1024 > (NN)))
> -
> -#if (SKEIN_UNROLL_1024 > 14)
> -#error "need more unrolling in Skein_1024_Process_Block"
> -#endif
> -#endif
>
> /***************************** SKEIN_256 ******************************/
> #if !(SKEIN_USE_ASM & 256)
> diff --git a/drivers/staging/skein/skein_block.h
> b/drivers/staging/skein/skein_block.h
> index 9d40f4a..1b28d52 100644
> --- a/drivers/staging/skein/skein_block.h
> +++ b/drivers/staging/skein/skein_block.h
> @@ -20,3 +20,326 @@ void skein_1024_process_block(struct skein_1024_ctx
> *ctx, const u8 *blk_ptr,
> size_t blk_cnt, size_t byte_cnt_add);
>
> #endif
> +
> +
> +#ifndef SKEIN_USE_ASM
> +#define SKEIN_USE_ASM (0) /* default is all C code (no ASM) */
> +#endif
> +
> +#ifndef SKEIN_LOOP
> +#define SKEIN_LOOP 001 /* default: unroll 256 and 512, but not 1024 */
> +#endif
> +
> +#define BLK_BITS (WCNT * 64) /* some useful definitions for code
> here */
> +#define KW_TWK_BASE (0)
> +#define KW_KEY_BASE (3)
> +#define ks (kw + KW_KEY_BASE)
> +#define ts (kw + KW_TWK_BASE)
> +
> +#ifdef SKEIN_DEBUG
> +#define debug_save_tweak(ctx) \
> +{ \
> + ctx->h.tweak[0] = ts[0]; \
> + ctx->h.tweak[1] = ts[1]; \
> +}
> +#else
> +#define debug_save_tweak(ctx)
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 256)
> +#undef RCNT
> +#define RCNT (SKEIN_256_ROUNDS_TOTAL / 8)
> +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> +#define SKEIN_UNROLL_256 (((SKEIN_LOOP) / 100) % 10)
> +#else
> +#define SKEIN_UNROLL_256 (0)
> +#endif
> +
> +#if SKEIN_UNROLL_256
> +#if (RCNT % SKEIN_UNROLL_256)
> +#error "Invalid SKEIN_UNROLL_256" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND256(p0, p1, p2, p3, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_256 == 0
> +#define R256(p0, p1, p2, p3, ROT, r_num) /* fully unrolled */ \
> + ROUND256(p0, p1, p2, p3, ROT, r_num)
> +
> +#define I256(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[((R) + 1) % 5]; \
> + X1 += ks[((R) + 2) % 5] + ts[((R) + 1) % 3]; \
> + X2 += ks[((R) + 3) % 5] + ts[((R) + 2) % 3]; \
> + X3 += ks[((R) + 4) % 5] + (R) + 1; \
> + } while (0)
> +#else
> +/* looping version */
> +#define R256(p0, p1, p2, p3, ROT, r_num) ROUND256(p0, p1, p2, p3, ROT,
> r_num)
> +
> +#define I256(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[r + (R) + 0]; \
> + X1 += ks[r + (R) + 1] + ts[r + (R) + 0];\
> + X2 += ks[r + (R) + 2] + ts[r + (R) + 1];\
> + X3 += ks[r + (R) + 3] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 4] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +#endif
> +#define R256_8_ROUNDS(R) \
> + do { \
> + R256(0, 1, 2, 3, R_256_0, 8 * (R) + 1); \
> + R256(0, 3, 2, 1, R_256_1, 8 * (R) + 2); \
> + R256(0, 1, 2, 3, R_256_2, 8 * (R) + 3); \
> + R256(0, 3, 2, 1, R_256_3, 8 * (R) + 4); \
> + I256(2 * (R)); \
> + R256(0, 1, 2, 3, R_256_4, 8 * (R) + 5); \
> + R256(0, 3, 2, 1, R_256_5, 8 * (R) + 6); \
> + R256(0, 1, 2, 3, R_256_6, 8 * (R) + 7); \
> + R256(0, 3, 2, 1, R_256_7, 8 * (R) + 8); \
> + I256(2 * (R) + 1); \
> + } while (0)
> +
> +#define R256_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_256 == 0 && \
> + SKEIN_256_ROUNDS_TOTAL / 8 > (NN)) || \
> + (SKEIN_UNROLL_256 > (NN)))
> +
> +#if (SKEIN_UNROLL_256 > 14)
> +#error "need more unrolling in skein_256_process_block"
> +#endif
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 512)
> +#undef RCNT
> +#define RCNT (SKEIN_512_ROUNDS_TOTAL/8)
> +
> +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> +#define SKEIN_UNROLL_512 (((SKEIN_LOOP)/10)%10)
> +#else
> +#define SKEIN_UNROLL_512 (0)
> +#endif
> +
> +#if SKEIN_UNROLL_512
> +#if (RCNT % SKEIN_UNROLL_512)
> +#error "Invalid SKEIN_UNROLL_512" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + X##p4 += X##p5; \
> + X##p5 = rotl_64(X##p5, ROT##_2); \
> + X##p5 ^= X##p4; \
> + X##p6 += X##p7; X##p7 = rotl_64(X##p7, ROT##_3);\
> + X##p7 ^= X##p6; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_512 == 0
> +#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) /* unrolled */ \
> + ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num)
> +
> +#define I512(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[((R) + 1) % 9]; \
> + X1 += ks[((R) + 2) % 9]; \
> + X2 += ks[((R) + 3) % 9]; \
> + X3 += ks[((R) + 4) % 9]; \
> + X4 += ks[((R) + 5) % 9]; \
> + X5 += ks[((R) + 6) % 9] + ts[((R) + 1) % 3]; \
> + X6 += ks[((R) + 7) % 9] + ts[((R) + 2) % 3]; \
> + X7 += ks[((R) + 8) % 9] + (R) + 1; \
> + } while (0)
> +
> +#else /* looping version */
> +#define R512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> + ROUND512(p0, p1, p2, p3, p4, p5, p6, p7, ROT, r_num) \
> +
> +#define I512(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X0 += ks[r + (R) + 0]; \
> + X1 += ks[r + (R) + 1]; \
> + X2 += ks[r + (R) + 2]; \
> + X3 += ks[r + (R) + 3]; \
> + X4 += ks[r + (R) + 4]; \
> + X5 += ks[r + (R) + 5] + ts[r + (R) + 0]; \
> + X6 += ks[r + (R) + 6] + ts[r + (R) + 1]; \
> + X7 += ks[r + (R) + 7] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 8] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +#endif /* end of looped code definitions */
> +#define R512_8_ROUNDS(R) /* do 8 full rounds */ \
> + do { \
> + R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_0, 8 * (R) + 1); \
> + R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_1, 8 * (R) + 2); \
> + R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_2, 8 * (R) + 3); \
> + R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_3, 8 * (R) + 4); \
> + I512(2 * (R)); \
> + R512(0, 1, 2, 3, 4, 5, 6, 7, R_512_4, 8 * (R) + 5); \
> + R512(2, 1, 4, 7, 6, 5, 0, 3, R_512_5, 8 * (R) + 6); \
> + R512(4, 1, 6, 3, 0, 5, 2, 7, R_512_6, 8 * (R) + 7); \
> + R512(6, 1, 0, 7, 2, 5, 4, 3, R_512_7, 8 * (R) + 8); \
> + I512(2 * (R) + 1); /* and key injection */ \
> + } while (0)
> +#define R512_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_512 == 0 && \
> + SKEIN_512_ROUNDS_TOTAL/8 > (NN)) || \
> + (SKEIN_UNROLL_512 > (NN)))
> +
> +#if (SKEIN_UNROLL_512 > 14)
> +#error "need more unrolling in skein_512_process_block"
> +#endif
> +#endif
> +
> +#if !(SKEIN_USE_ASM & 1024)
> +#undef RCNT
> +#define RCNT (SKEIN_1024_ROUNDS_TOTAL/8)
> +#ifdef SKEIN_LOOP /* configure how much to unroll the loop */
> +#define SKEIN_UNROLL_1024 ((SKEIN_LOOP) % 10)
> +#else
> +#define SKEIN_UNROLL_1024 (0)
> +#endif
> +
> +#if (SKEIN_UNROLL_1024 != 0)
> +#if (RCNT % SKEIN_UNROLL_1024)
> +#error "Invalid SKEIN_UNROLL_1024" /* sanity check on unroll count */
> +#endif
> +#endif
> +#define ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD,
> pE, \
> + pF, ROT, r_num) \
> + do { \
> + X##p0 += X##p1; \
> + X##p1 = rotl_64(X##p1, ROT##_0); \
> + X##p1 ^= X##p0; \
> + X##p2 += X##p3; \
> + X##p3 = rotl_64(X##p3, ROT##_1); \
> + X##p3 ^= X##p2; \
> + X##p4 += X##p5; \
> + X##p5 = rotl_64(X##p5, ROT##_2); \
> + X##p5 ^= X##p4; \
> + X##p6 += X##p7; \
> + X##p7 = rotl_64(X##p7, ROT##_3); \
> + X##p7 ^= X##p6; \
> + X##p8 += X##p9; \
> + X##p9 = rotl_64(X##p9, ROT##_4); \
> + X##p9 ^= X##p8; \
> + X##pA += X##pB; \
> + X##pB = rotl_64(X##pB, ROT##_5); \
> + X##pB ^= X##pA; \
> + X##pC += X##pD; \
> + X##pD = rotl_64(X##pD, ROT##_6); \
> + X##pD ^= X##pC; \
> + X##pE += X##pF; \
> + X##pF = rotl_64(X##pF, ROT##_7); \
> + X##pF ^= X##pE; \
> + } while (0)
> +
> +#if SKEIN_UNROLL_1024 == 0
> +#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> + ROT, rn) \
> + ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> + pF, ROT, rn) \
> +
> +#define I1024(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X00 += ks[((R) + 1) % 17]; \
> + X01 += ks[((R) + 2) % 17]; \
> + X02 += ks[((R) + 3) % 17]; \
> + X03 += ks[((R) + 4) % 17]; \
> + X04 += ks[((R) + 5) % 17]; \
> + X05 += ks[((R) + 6) % 17]; \
> + X06 += ks[((R) + 7) % 17]; \
> + X07 += ks[((R) + 8) % 17]; \
> + X08 += ks[((R) + 9) % 17]; \
> + X09 += ks[((R) + 10) % 17]; \
> + X10 += ks[((R) + 11) % 17]; \
> + X11 += ks[((R) + 12) % 17]; \
> + X12 += ks[((R) + 13) % 17]; \
> + X13 += ks[((R) + 14) % 17] + ts[((R) + 1) % 3]; \
> + X14 += ks[((R) + 15) % 17] + ts[((R) + 2) % 3]; \
> + X15 += ks[((R) + 16) % 17] + (R) + 1; \
> + } while (0)
> +#else /* looping version */
> +#define R1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE,
> pF, \
> + ROT, rn) \
> + ROUND1024(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pA, pB, pC, pD, pE, \
> + pF, ROT, rn) \
> +
> +#define I1024(R) \
> + do { \
> + /* inject the key schedule value */ \
> + X00 += ks[r + (R) + 0]; \
> + X01 += ks[r + (R) + 1]; \
> + X02 += ks[r + (R) + 2]; \
> + X03 += ks[r + (R) + 3]; \
> + X04 += ks[r + (R) + 4]; \
> + X05 += ks[r + (R) + 5]; \
> + X06 += ks[r + (R) + 6]; \
> + X07 += ks[r + (R) + 7]; \
> + X08 += ks[r + (R) + 8]; \
> + X09 += ks[r + (R) + 9]; \
> + X10 += ks[r + (R) + 10]; \
> + X11 += ks[r + (R) + 11]; \
> + X12 += ks[r + (R) + 12]; \
> + X13 += ks[r + (R) + 13] + ts[r + (R) + 0]; \
> + X14 += ks[r + (R) + 14] + ts[r + (R) + 1]; \
> + X15 += ks[r + (R) + 15] + r + (R); \
> + /* rotate key schedule */ \
> + ks[r + (R) + 16] = ks[r + (R) - 1]; \
> + ts[r + (R) + 2] = ts[r + (R) - 1]; \
> + } while (0)
> +
> +#endif
> +#define R1024_8_ROUNDS(R) \
> + do { \
> + R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> + 13, 14, 15, R1024_0, 8*(R) + 1); \
> + R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> + 05, 08, 01, R1024_1, 8*(R) + 2); \
> + R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> + 11, 10, 09, R1024_2, 8*(R) + 3); \
> + R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
> + 03, 12, 07, R1024_3, 8*(R) + 4); \
> + I1024(2*(R)); \
> + R1024(00, 01, 02, 03, 04, 05, 06, 07, 08, 09, 10, 11, 12, \
> + 13, 14, 15, R1024_4, 8*(R) + 5); \
> + R1024(00, 09, 02, 13, 06, 11, 04, 15, 10, 07, 12, 03, 14, \
> + 05, 08, 01, R1024_5, 8*(R) + 6); \
> + R1024(00, 07, 02, 05, 04, 03, 06, 01, 12, 15, 14, 13, 08, \
> + 11, 10, 09, R1024_6, 8*(R) + 7); \
> + R1024(00, 15, 02, 11, 06, 13, 04, 09, 14, 01, 08, 05, 10, \
> + 03, 12, 07, R1024_7, 8*(R) + 8); \
> + I1024(2*(R)+1); \
> + } while (0)
> +
> +#define R1024_UNROLL_R(NN) \
> + ((SKEIN_UNROLL_1024 == 0 && \
> + SKEIN_1024_ROUNDS_TOTAL/8 > (NN)) || \
> + (SKEIN_UNROLL_1024 > (NN)))
> +
> +#if (SKEIN_UNROLL_1024 > 14)
> +#error "need more unrolling in Skein_1024_Process_Block"
> +#endif
> +#endif
> --
> 2.5.0
^ permalink raw reply [flat|nested] 5+ messages in thread