Imported Upstream version 4.8.1

[platform/upstream/gcc48.git] / libgo / go / crypto / sha512 / sha512.go

diff --git a/libgo/go/crypto/sha512/sha512.go b/libgo/go/crypto/sha512/sha512.go
index a245fd6..4aec529 100644 (file)
--- a/libgo/go/crypto/sha512/sha512.go
+++ b/libgo/go/crypto/sha512/sha512.go
@@ -26,29 +26,29 @@ const Size384 = 48
 const BlockSize = 128
 
 const (
-       _Chunk     = 128
-       _Init0     = 0x6a09e667f3bcc908
-       _Init1     = 0xbb67ae8584caa73b
-       _Init2     = 0x3c6ef372fe94f82b
-       _Init3     = 0xa54ff53a5f1d36f1
-       _Init4     = 0x510e527fade682d1
-       _Init5     = 0x9b05688c2b3e6c1f
-       _Init6     = 0x1f83d9abfb41bd6b
-       _Init7     = 0x5be0cd19137e2179
-       _Init0_384 = 0xcbbb9d5dc1059ed8
-       _Init1_384 = 0x629a292a367cd507
-       _Init2_384 = 0x9159015a3070dd17
-       _Init3_384 = 0x152fecd8f70e5939
-       _Init4_384 = 0x67332667ffc00b31
-       _Init5_384 = 0x8eb44a8768581511
-       _Init6_384 = 0xdb0c2e0d64f98fa7
-       _Init7_384 = 0x47b5481dbefa4fa4
+       chunk     = 128
+       init0     = 0x6a09e667f3bcc908
+       init1     = 0xbb67ae8584caa73b
+       init2     = 0x3c6ef372fe94f82b
+       init3     = 0xa54ff53a5f1d36f1
+       init4     = 0x510e527fade682d1
+       init5     = 0x9b05688c2b3e6c1f
+       init6     = 0x1f83d9abfb41bd6b
+       init7     = 0x5be0cd19137e2179
+       init0_384 = 0xcbbb9d5dc1059ed8
+       init1_384 = 0x629a292a367cd507
+       init2_384 = 0x9159015a3070dd17
+       init3_384 = 0x152fecd8f70e5939
+       init4_384 = 0x67332667ffc00b31
+       init5_384 = 0x8eb44a8768581511
+       init6_384 = 0xdb0c2e0d64f98fa7
+       init7_384 = 0x47b5481dbefa4fa4
 )
 
 // digest represents the partial evaluation of a checksum.
 type digest struct {
        h     [8]uint64
-       x     [_Chunk]byte
+       x     [chunk]byte
        nx    int
        len   uint64
        is384 bool // mark if this digest is SHA-384
@@ -56,23 +56,23 @@ type digest struct {
 
 func (d *digest) Reset() {
        if !d.is384 {
-               d.h[0] = _Init0
-               d.h[1] = _Init1
-               d.h[2] = _Init2
-               d.h[3] = _Init3
-               d.h[4] = _Init4
-               d.h[5] = _Init5
-               d.h[6] = _Init6
-               d.h[7] = _Init7
+               d.h[0] = init0
+               d.h[1] = init1
+               d.h[2] = init2
+               d.h[3] = init3
+               d.h[4] = init4
+               d.h[5] = init5
+               d.h[6] = init6
+               d.h[7] = init7
        } else {
-               d.h[0] = _Init0_384
-               d.h[1] = _Init1_384
-               d.h[2] = _Init2_384
-               d.h[3] = _Init3_384
-               d.h[4] = _Init4_384
-               d.h[5] = _Init5_384
-               d.h[6] = _Init6_384
-               d.h[7] = _Init7_384
+               d.h[0] = init0_384
+               d.h[1] = init1_384
+               d.h[2] = init2_384
+               d.h[3] = init3_384
+               d.h[4] = init4_384
+               d.h[5] = init5_384
+               d.h[6] = init6_384
+               d.h[7] = init7_384
        }
        d.nx = 0
        d.len = 0
@@ -107,21 +107,24 @@ func (d *digest) Write(p []byte) (nn int, err error) {
        d.len += uint64(nn)
        if d.nx > 0 {
                n := len(p)
-               if n > _Chunk-d.nx {
-                       n = _Chunk - d.nx
+               if n > chunk-d.nx {
+                       n = chunk - d.nx
                }
                for i := 0; i < n; i++ {
                        d.x[d.nx+i] = p[i]
                }
                d.nx += n
-               if d.nx == _Chunk {
-                       _Block(d, d.x[0:])
+               if d.nx == chunk {
+                       block(d, d.x[0:])
                        d.nx = 0
                }
                p = p[n:]
        }
-       n := _Block(d, p)
-       p = p[n:]
+       if len(p) >= chunk {
+               n := len(p) &^ (chunk - 1)
+               block(d, p[:n])
+               p = p[n:]
+       }
        if len(p) > 0 {
                d.nx = copy(d.x[:], p)
        }