4bc3b8589
Denys Vlasenko
2010-10-16
Subject
sha512: inline rotr64
Binary
No binary (build failed)
Architecture & Compiler Flags
—
Build Log
(log yok)
Commit Diff GitHub →
libbb/sha1.c+51 -57
| @@ -30,11 +30,29 @@ | |
| #include "libbb.h" | |
| - | #define rotl32(x,n) (((x) << (n)) | ((x) >> (32 - (n)))) |
| - | #define rotr32(x,n) (((x) >> (n)) | ((x) << (32 - (n)))) |
| - | /* for sha512: */ |
| - | #define rotr64(x,n) (((x) >> (n)) | ((x) << (64 - (n)))) |
| + | /* gcc 4.2.1 optimizes rotr64 better with inline than with macro |
| + | * (for rotX32, there is no difference). Why? My guess is that |
| + | * macro requires clever common subexpression elimination heuristics |
| + | * in gcc, while inline basically forces it to happen. |
| + | */ |
| + | //#define rotl32(x,n) (((x) << (n)) | ((x) >> (32 - (n)))) |
| + | static ALWAYS_INLINE uint32_t rotl32(uint32_t x, unsigned n) |
| + | { |
| + | return (x << n) | (x >> (32 - n)); |
| + | } |
| + | //#define rotr32(x,n) (((x) >> (n)) | ((x) << (32 - (n)))) |
| + | static ALWAYS_INLINE uint32_t rotr32(uint32_t x, unsigned n) |
| + | { |
| + | return (x >> n) | (x << (32 - n)); |
| + | } |
| + | /* rotr64 in needed for sha512 only: */ |
| + | //#define rotr64(x,n) (((x) >> (n)) | ((x) << (64 - (n)))) |
| + | static ALWAYS_INLINE uint64_t rotr64(uint64_t x, unsigned n) |
| + | { |
| + | return (x >> n) | (x << (64 - n)); |
| + | } |
| #if BB_LITTLE_ENDIAN | |
| + | /* ALWAYS_INLINE below would hurt code size, using plain inline: */ |
| static inline uint64_t hton64(uint64_t v) | |
| { | |
| return (((uint64_t)htonl(v)) << 32) | htonl(v >> 32); | |
| @@ -44,14 +62,6 @@ static inline uint64_t hton64(uint64_t v) | |
| #endif | |
| #define ntoh64(v) hton64(v) | |
| - | /* To check alignment gcc has an appropriate operator. Other |
| - | compilers don't. */ |
| - | #if defined(__GNUC__) && __GNUC__ >= 2 |
| - | # define UNALIGNED_P(p,type) (((uintptr_t) p) % __alignof__(type) != 0) |
| - | #else |
| - | # define UNALIGNED_P(p,type) (((uintptr_t) p) % sizeof(type) != 0) |
| - | #endif |
| - | |
| /* Some arch headers have conflicting defines */ | |
| #undef ch | |
| @@ -65,11 +75,8 @@ static void FAST_FUNC sha1_process_block64(sha1_ctx_t *ctx) | |
| uint32_t W[80], a, b, c, d, e; | |
| const uint32_t *words = (uint32_t*) ctx->wbuffer; | |
| - | for (t = 0; t < 16; ++t) { |
| - | W[t] = ntohl(*words); |
| - | words++; |
| - | } |
| - | |
| + | for (t = 0; t < 16; ++t) |
| + | W[t] = ntohl(words[t]); |
| for (/*t = 16*/; t < 80; ++t) { | |
| uint32_t T = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]; | |
| W[t] = rotl32(T, 1); | |
| @@ -190,11 +197,8 @@ static void FAST_FUNC sha256_process_block64(sha256_ctx_t *ctx) | |
| #define R1(x) (rotr32(x, 17) ^ rotr32(x, 19) ^ (x >> 10)) | |
| /* Compute the message schedule according to FIPS 180-2:6.2.2 step 2. */ | |
| - | for (t = 0; t < 16; ++t) { |
| - | W[t] = ntohl(*words); |
| - | words++; |
| - | } |
| - | |
| + | for (t = 0; t < 16; ++t) |
| + | W[t] = ntohl(words[t]); |
| for (/*t = 16*/; t < 64; ++t) | |
| W[t] = R1(W[t - 2]) + W[t - 7] + R0(W[t - 15]) + W[t - 16]; | |
| @@ -269,10 +273,8 @@ static void FAST_FUNC sha512_process_block128(sha512_ctx_t *ctx) | |
| #define R1(x) (rotr64(x, 19) ^ rotr64(x, 61) ^ (x >> 6)) | |
| /* Compute the message schedule according to FIPS 180-2:6.3.2 step 2. */ | |
| - | for (t = 0; t < 16; ++t) { |
| - | W[t] = ntoh64(*words); |
| - | words++; |
| - | } |
| + | for (t = 0; t < 16; ++t) |
| + | W[t] = ntoh64(words[t]); |
| for (/*t = 16*/; t < 80; ++t) | |
| W[t] = R1(W[t - 2]) + W[t - 7] + R0(W[t - 15]) + W[t - 16]; | |
| @@ -363,18 +365,19 @@ void FAST_FUNC sha512_begin(sha512_ctx_t *ctx) | |
| /* Used also for sha256 */ | |
| void FAST_FUNC sha1_hash(sha1_ctx_t *ctx, const void *buffer, size_t len) | |
| { | |
| - | #if 0 |
| unsigned bufpos = ctx->total64 & 63; | |
| - | unsigned add = 64 - bufpos; |
| + | unsigned remaining; |
| ctx->total64 += len; | |
| + | #if 0 |
| + | remaining = 64 - bufpos; |
| /* Hash whole blocks */ | |
| - | while (len >= add) { |
| - | memcpy(ctx->wbuffer + bufpos, buffer, add); |
| - | buffer = (const char *)buffer + add; |
| - | len -= add; |
| - | add = 64; |
| + | while (len >= remaining) { |
| + | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| + | buffer = (const char *)buffer + remaining; |
| + | len -= remaining; |
| + | remaining = 64; |
| bufpos = 0; | |
| ctx->process_block(ctx); | |
| } | |
| @@ -383,12 +386,8 @@ void FAST_FUNC sha1_hash(sha1_ctx_t *ctx, const void *buffer, size_t len) | |
| memcpy(ctx->wbuffer + bufpos, buffer, len); | |
| #else | |
| /* Tiny bit smaller code */ | |
| - | unsigned bufpos = ctx->total64 & 63; |
| - | |
| - | ctx->total64 += len; |
| - | |
| while (1) { | |
| - | unsigned remaining = 64 - bufpos; |
| + | remaining = 64 - bufpos; |
| if (remaining > len) | |
| remaining = len; | |
| /* Copy data into aligned buffer */ | |
| @@ -409,20 +408,24 @@ void FAST_FUNC sha1_hash(sha1_ctx_t *ctx, const void *buffer, size_t len) | |
| void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) | |
| { | |
| - | #if 0 |
| unsigned bufpos = ctx->total64[0] & 127; | |
| - | unsigned add = 128 - bufpos; |
| + | unsigned remaining; |
| + | /* First increment the byte count. FIPS 180-2 specifies the possible |
| + | length of the file up to 2^128 _bits_. |
| + | We compute the number of _bytes_ and convert to bits later. */ |
| ctx->total64[0] += len; | |
| if (ctx->total64[0] < len) | |
| ctx->total64[1]++; | |
| + | #if 0 |
| + | remaining = 128 - bufpos; |
| /* Hash whole blocks */ | |
| - | while (len >= add) { |
| - | memcpy(ctx->wbuffer + bufpos, buffer, add); |
| - | buffer = (const char *)buffer + add; |
| - | len -= add; |
| - | add = 128; |
| + | while (len >= remaining) { |
| + | memcpy(ctx->wbuffer + bufpos, buffer, remaining); |
| + | buffer = (const char *)buffer + remaining; |
| + | len -= remaining; |
| + | remaining = 128; |
| bufpos = 0; | |
| sha512_process_block128(ctx); | |
| } | |
| @@ -430,20 +433,11 @@ void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) | |
| /* Save last, partial blosk */ | |
| memcpy(ctx->wbuffer + bufpos, buffer, len); | |
| #else | |
| - | unsigned bufpos = ctx->total64[0] & 127; |
| - | |
| - | /* First increment the byte count. FIPS 180-2 specifies the possible |
| - | length of the file up to 2^128 _bits_. |
| - | We compute the number of _bytes_ and convert to bits later. */ |
| - | ctx->total64[0] += len; |
| - | if (ctx->total64[0] < len) |
| - | ctx->total64[1]++; |
| - | |
| while (1) { | |
| - | unsigned remaining = 128 - bufpos; |
| + | remaining = 128 - bufpos; |
| if (remaining > len) | |
| remaining = len; | |
| - | /* Copy data into aligned buffer. */ |
| + | /* Copy data into aligned buffer */ |
| memcpy(ctx->wbuffer + bufpos, buffer, remaining); | |
| len -= remaining; | |
| buffer = (const char *)buffer + remaining; | |
| @@ -452,7 +446,7 @@ void FAST_FUNC sha512_hash(sha512_ctx_t *ctx, const void *buffer, size_t len) | |
| bufpos -= 128; | |
| if (bufpos != 0) | |
| break; | |
| - | /* Buffer is filled up, process it. */ |
| + | /* Buffer is filled up, process it */ |
| sha512_process_block128(ctx); | |
| /*bufpos = 0; - already is */ | |
| } | |