code review 6782072: crypto/md5: speed up aligned writes and test/bench unal...

src/pkg/crypto/md5/md5block.go

 package md5
 
 import (
         "runtime"
         "unsafe"
 )
 
 func block(dig *digest, p []byte) {
         a := dig.s[0]
         b := dig.s[1]
         c := dig.s[2]
         d := dig.s[3]
         var X *[16]uint32
         var xbuf [16]uint32
         for len(p) >= chunk {
                 aa, bb, cc, dd := a, b, c, d
 
                 // This is a constant condition - it is not evaluated on each iteration.
                 if runtime.GOARCH == "amd64" || runtime.GOARCH == "386" {
                         // MD5 was designed so that x86 processors can just iterate
                         // over the block data directly as uint32s, and we generate
                         // less code and run 1.3x faster if we take advantage of that.
                         // My apologies.
                         X = (*[16]uint32)(unsafe.Pointer(&p[0]))
+                } else if uintptr(unsafe.Pointer(&p[0]))&(unsafe.Alignof(uint32(0))-1) == 0 {
+                        X = (*[16]uint32)(unsafe.Pointer(&p[0]))
                 } else {
                         X = &xbuf
                         j := 0
                         for i := 0; i < 16; i++ {
                                 X[i&15] = uint32(p[j]) | uint32(p[j+1])<<8 | uint32(p[j+2])<<16 | uint32(p[j+3])<<24
                                 j += 4
                         }
                 }
 
                 // Round 1.
@@ skipping 202 matching lines @@
                 d += dd
 
                 p = p[chunk:]
         }
 
         dig.s[0] = a
         dig.s[1] = b
         dig.s[2] = c
         dig.s[3] = d
 }