Update NSS to 3.21 RTM and NSPR to 4.11 RTM

nss/lib/freebl/sha512.c

 /*
  * sha512.c - implementation of SHA224, SHA256, SHA384 and SHA512
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifdef FREEBL_NO_DEPEND
 #include "stubs.h"
 #endif
@@ skipping 49 matching lines @@
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 
     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 };
 
 /* SHA-256 initial hash values */
 static const PRUint32 H256[8] = {
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 
     0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 };
 
+#if defined(IS_LITTLE_ENDIAN)
 #if (_MSC_VER >= 1300)
 #include <stdlib.h>
 #pragma intrinsic(_byteswap_ulong)
 #define SHA_HTONL(x) _byteswap_ulong(x)
-#define BYTESWAP4(x)  x = SHA_HTONL(x)
 #elif defined(_MSC_VER) && defined(NSS_X86_OR_X64)
 #ifndef FORCEINLINE
 #if (_MSC_VER >= 1200)
 #define FORCEINLINE __forceinline
 #else
 #define FORCEINLINE __inline
 #endif
 #endif
 #define FASTCALL __fastcall
 
 static FORCEINLINE PRUint32 FASTCALL 
 swap4b(PRUint32 dwd) 
 {
     __asm {
         mov   eax,dwd
         bswap eax
     }
 }
 
 #define SHA_HTONL(x) swap4b(x)
-#define BYTESWAP4(x)  x = SHA_HTONL(x)
 
 #elif defined(__GNUC__) && defined(NSS_X86_OR_X64)
 static __inline__ PRUint32 swap4b(PRUint32 value)
 {
     __asm__("bswap %0" : "+r" (value));
     return (value);
 }
 #define SHA_HTONL(x) swap4b(x)
-#define BYTESWAP4(x)  x = SHA_HTONL(x)
 
 #elif defined(__GNUC__) && (defined(__thumb2__) || \
       (!defined(__thumb__) && \
       (defined(__ARM_ARCH_6__) || \
        defined(__ARM_ARCH_6J__) || \
        defined(__ARM_ARCH_6K__) || \
        defined(__ARM_ARCH_6Z__) || \
        defined(__ARM_ARCH_6ZK__) || \
        defined(__ARM_ARCH_6T2__) || \
        defined(__ARM_ARCH_7__) || \
        defined(__ARM_ARCH_7A__) || \
        defined(__ARM_ARCH_7R__))))
 static __inline__ PRUint32 swap4b(PRUint32 value)
 {
     PRUint32 ret;
     __asm__("rev %0, %1" : "=r" (ret) : "r"(value));
     return ret;
 }
 #define SHA_HTONL(x) swap4b(x)
-#define BYTESWAP4(x)  x = SHA_HTONL(x)
 
 #else
 #define SWAP4MASK  0x00FF00FF
-#define SHA_HTONL(x) (t1 = (x), t1 = (t1 << 16) | (t1 >> 16), \
-                      ((t1 & SWAP4MASK) << 8) | ((t1 >> 8) & SWAP4MASK))
-#define BYTESWAP4(x)  x = SHA_HTONL(x)
+static PRUint32 swap4b(PRUint32 value)
+{
+    PRUint32 t1 = (value << 16) | (value >> 16);
+    return ((t1 & SWAP4MASK) << 8) | ((t1 >> 8) & SWAP4MASK);
+}
+#define SHA_HTONL(x) swap4b(x)
 #endif
+#define BYTESWAP4(x) x = SHA_HTONL(x)
+#endif /* defined(IS_LITTLE_ENDIAN) */
 
 #if defined(_MSC_VER)
 #pragma intrinsic (_lrotr, _lrotl) 
 #define ROTR32(x,n) _lrotr(x,n)
 #define ROTL32(x,n) _lrotl(x,n)
 #else
 #define ROTR32(x,n) ((x >> n) | (x << ((8 * sizeof x) - n)))
 #define ROTL32(x,n) ((x << n) | (x >> ((8 * sizeof x) - n)))
 #endif
 
 /* Capitol Sigma and lower case sigma functions */
 #define S0(x) (ROTR32(x, 2) ^ ROTR32(x,13) ^ ROTR32(x,22))
 #define S1(x) (ROTR32(x, 6) ^ ROTR32(x,11) ^ ROTR32(x,25))
-#define s0(x) (t1 = x, ROTR32(t1, 7) ^ ROTR32(t1,18) ^ SHR(t1, 3))
-#define s1(x) (t2 = x, ROTR32(t2,17) ^ ROTR32(t2,19) ^ SHR(t2,10))
+#define s0(x) (ROTR32(x, 7) ^ ROTR32(x,18) ^ SHR(x, 3))
+#define s1(x) (ROTR32(x,17) ^ ROTR32(x,19) ^ SHR(x,10))
 
 SHA256Context *
 SHA256_NewContext(void)
 {
     SHA256Context *ctx = PORT_New(SHA256Context);
     return ctx;
 }
 
 void 
 SHA256_DestroyContext(SHA256Context *ctx, PRBool freeit)
 {
     memset(ctx, 0, sizeof *ctx);
     if (freeit) {
         PORT_Free(ctx);
     }
 }
 
 void 
 SHA256_Begin(SHA256Context *ctx)
 {
     memset(ctx, 0, sizeof *ctx);
     memcpy(H, H256, sizeof H256);
 }
 
 static void
 SHA256_Compress(SHA256Context *ctx)
 {
   {
-    register PRUint32 t1, t2;
-
 #if defined(IS_LITTLE_ENDIAN)
     BYTESWAP4(W[0]);
     BYTESWAP4(W[1]);
     BYTESWAP4(W[2]);
     BYTESWAP4(W[3]);
     BYTESWAP4(W[4]);
     BYTESWAP4(W[5]);
     BYTESWAP4(W[6]);
     BYTESWAP4(W[7]);
     BYTESWAP4(W[8]);
@@ skipping 232 matching lines @@
         memcpy(B, input, inputLen);
 }
 
 void 
 SHA256_End(SHA256Context *ctx, unsigned char *digest,
            unsigned int *digestLen, unsigned int maxDigestLen)
 {
     unsigned int inBuf = ctx->sizeLo & 0x3f;
     unsigned int padLen = (inBuf < 56) ? (56 - inBuf) : (56 + 64 - inBuf);
     PRUint32 hi, lo;
-#ifdef SWAP4MASK
-    PRUint32 t1;
-#endif
 
     hi = (ctx->sizeHi << 3) | (ctx->sizeLo >> 29);
     lo = (ctx->sizeLo << 3);
 
     SHA256_Update(ctx, pad, padLen);
 
 #if defined(IS_LITTLE_ENDIAN)
     W[14] = SHA_HTONL(hi);
     W[15] = SHA_HTONL(lo);
 #else
@@ skipping 18 matching lines @@
     if (digestLen)
         *digestLen = padLen;
 }
 
 void
 SHA256_EndRaw(SHA256Context *ctx, unsigned char *digest,
               unsigned int *digestLen, unsigned int maxDigestLen)
 {
     PRUint32 h[8];
     unsigned int len;
-#ifdef SWAP4MASK
-    PRUint32 t1;
-#endif
 
     memcpy(h, ctx->h, sizeof(h));
 
 #if defined(IS_LITTLE_ENDIAN)
     BYTESWAP4(h[0]);
     BYTESWAP4(h[1]);
     BYTESWAP4(h[2]);
     BYTESWAP4(h[3]);
     BYTESWAP4(h[4]);
     BYTESWAP4(h[5]);
@@ skipping 164 matching lines @@
 #pragma intrinsic(_rotr64,_rotl64)
 #define ROTR64(x,n) _rotr64(x,n)
 #define ROTL64(x,n) _rotl64(x,n)
 #else
 #define ROTR64(x,n) ((x >> n) | (x << (64 - n)))
 #define ROTL64(x,n) ((x << n) | (x >> (64 - n)))
 #endif
 
 #define S0(x) (ROTR64(x,28) ^ ROTR64(x,34) ^ ROTR64(x,39))
 #define S1(x) (ROTR64(x,14) ^ ROTR64(x,18) ^ ROTR64(x,41))
-#define s0(x) (t1 = x, ROTR64(t1, 1) ^ ROTR64(t1, 8) ^ SHR(t1,7))
-#define s1(x) (t2 = x, ROTR64(t2,19) ^ ROTR64(t2,61) ^ SHR(t2,6))
+#define s0(x) (ROTR64(x, 1) ^ ROTR64(x, 8) ^ SHR(x,7))
+#define s1(x) (ROTR64(x,19) ^ ROTR64(x,61) ^ SHR(x,6))
 
 #if PR_BYTES_PER_LONG == 8
 #define ULLC(hi,lo) 0x ## hi ## lo ## UL
 #elif defined(_MSC_VER)
 #define ULLC(hi,lo) 0x ## hi ## lo ## ui64
 #else
 #define ULLC(hi,lo) 0x ## hi ## lo ## ULL
 #endif
 
+#if defined(IS_LITTLE_ENDIAN)
 #if defined(_MSC_VER)
 #pragma intrinsic(_byteswap_uint64)
 #define SHA_HTONLL(x) _byteswap_uint64(x)
 
 #elif defined(__GNUC__) && (defined(__x86_64__) || defined(__x86_64))
 static __inline__ PRUint64 swap8b(PRUint64 value)
 {
     __asm__("bswapq %0" : "+r" (value));
     return (value);
 }
 #define SHA_HTONLL(x) swap8b(x)
 
 #else
 #define SHA_MASK16 ULLC(0000FFFF,0000FFFF)
 #define SHA_MASK8  ULLC(00FF00FF,00FF00FF)
-#define SHA_HTONLL(x) (t1 = x, \
-  t1 = ((t1 & SHA_MASK8 ) <<  8) | ((t1 >>  8) & SHA_MASK8 ), \
-  t1 = ((t1 & SHA_MASK16) << 16) | ((t1 >> 16) & SHA_MASK16), \
-  (t1 >> 32) | (t1 << 32))
+static PRUint64 swap8b(PRUint64 x)
+{
+    PRUint64 t1 = x;
+    t1 = ((t1 & SHA_MASK8 ) <<  8) | ((t1 >>  8) & SHA_MASK8 );
+    t1 = ((t1 & SHA_MASK16) << 16) | ((t1 >> 16) & SHA_MASK16);
+    return (t1 >> 32) | (t1 << 32);
+}
+#define SHA_HTONLL(x) swap8b(x)
 #endif
 #define BYTESWAP8(x)  x = SHA_HTONLL(x)
+#endif /* defined(IS_LITTLE_ENDIAN) */
 
 #else /* no long long */
 
 #if defined(IS_LITTLE_ENDIAN)
 #define ULLC(hi,lo) { 0x ## lo ## U, 0x ## hi ## U }
+#define SHA_HTONLL(x) ( BYTESWAP4(x.lo), BYTESWAP4(x.hi), \
+   x.hi ^= x.lo ^= x.hi ^= x.lo, x)
+#define BYTESWAP8(x)  do { PRUint32 tmp; BYTESWAP4(x.lo); BYTESWAP4(x.hi); \
+   tmp = x.lo; x.lo = x.hi; x.hi = tmp; } while (0)
 #else
 #define ULLC(hi,lo) { 0x ## hi ## U, 0x ## lo ## U }
 #endif
 
-#define SHA_HTONLL(x) ( BYTESWAP4(x.lo), BYTESWAP4(x.hi), \
-   x.hi ^= x.lo ^= x.hi ^= x.lo, x)
-#define BYTESWAP8(x)  do { PRUint32 tmp; BYTESWAP4(x.lo); BYTESWAP4(x.hi); \
-   tmp = x.lo; x.lo = x.hi; x.hi = tmp; } while (0)
 #endif
 
 /* SHA-384 and SHA-512 constants, K512. */
 static const PRUint64 K512[80] = {
 #if PR_BYTES_PER_LONG == 8
      0x428a2f98d728ae22UL ,  0x7137449123ef65cdUL , 
      0xb5c0fbcfec4d3b2fUL ,  0xe9b5dba58189dbbcUL ,
      0x3956c25bf348b538UL ,  0x59f111f1b605d019UL , 
      0x923f82a4af194f9bUL ,  0xab1c5ed5da6d8118UL ,
      0xd807aa98a3030242UL ,  0x12835b0145706fbeUL , 
@@ skipping 208 matching lines @@
         h.hi += cy + S0hi(a) + Majx(a,b,c,hi); \
         DUMP(n,a,d,e,h) \
     }
 #endif
 
 static void
 SHA512_Compress(SHA512Context *ctx)
 {
 #if defined(IS_LITTLE_ENDIAN)
   {
-#if defined(HAVE_LONG_LONG)
-    PRUint64 t1;
-#else
-    PRUint32 t1;
-#endif
     BYTESWAP8(W[0]);
     BYTESWAP8(W[1]);
     BYTESWAP8(W[2]);
     BYTESWAP8(W[3]);
     BYTESWAP8(W[4]);
     BYTESWAP8(W[5]);
     BYTESWAP8(W[6]);
     BYTESWAP8(W[7]);
     BYTESWAP8(W[8]);
     BYTESWAP8(W[9]);
     BYTESWAP8(W[10]);
     BYTESWAP8(W[11]);
     BYTESWAP8(W[12]);
     BYTESWAP8(W[13]);
     BYTESWAP8(W[14]);
     BYTESWAP8(W[15]);
   }
 #endif
 
   {
-    PRUint64 t1, t2;
 #ifdef NOUNROLL512
     {
         /* prepare the "message schedule"   */
         int t;
         for (t = 16; t < 80; ++t) {
             INITW(t);
         }
     }
 #else
     INITW(16);
@@ skipping 250 matching lines @@
     if (inputLen) 
         memcpy(B, input, inputLen);
 }
 
 void 
 SHA512_End(SHA512Context *ctx, unsigned char *digest,
            unsigned int *digestLen, unsigned int maxDigestLen)
 {
 #if defined(HAVE_LONG_LONG)
     unsigned int inBuf  = (unsigned int)ctx->sizeLo & 0x7f;
-    PRUint64 t1;
 #else
     unsigned int inBuf  = (unsigned int)ctx->sizeLo.lo & 0x7f;
-    PRUint32 t1;
 #endif
     unsigned int padLen = (inBuf < 112) ? (112 - inBuf) : (112 + 128 - inBuf);
     PRUint64 lo;
     LL_SHL(lo, ctx->sizeLo, 3);
 
     SHA512_Update(ctx, pad, padLen);
 
 #if defined(HAVE_LONG_LONG)
     W[14] = 0;
 #else
@@ skipping 21 matching lines @@
     padLen = PR_MIN(SHA512_LENGTH, maxDigestLen);
     memcpy(digest, H, padLen);
     if (digestLen)
         *digestLen = padLen;
 }
 
 void
 SHA512_EndRaw(SHA512Context *ctx, unsigned char *digest,
               unsigned int *digestLen, unsigned int maxDigestLen)
 {
-#if defined(HAVE_LONG_LONG)
-    PRUint64 t1;
-#else
-    PRUint32 t1;
-#endif
     PRUint64 h[8];
     unsigned int len;
 
     memcpy(h, ctx->h, sizeof(h));
 
 #if defined(IS_LITTLE_ENDIAN)
     BYTESWAP8(h[0]);
     BYTESWAP8(h[1]);
     BYTESWAP8(h[2]);
     BYTESWAP8(h[3]);
@@ skipping 303 matching lines @@
         }
         printf("done\n");
     }
     return 0;
 }
 
 void *PORT_Alloc(size_t len)            { return malloc(len); }
 void PORT_Free(void *ptr)               { free(ptr); }
 void PORT_ZFree(void *ptr, size_t len)  { memset(ptr, 0, len); free(ptr); }
 #endif