code review 7621049: crypto/md5: faster amd64, 386 implementations

src/pkg/crypto/md5/gen.go

 // Copyright 2012 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // +build ignore
 
 // This program generates md5block.go
 // Invoke as
 //
 //      go run gen.go [-full] |gofmt >md5block.go
@@ skipping 143 matching lines @@
                 0xa3014314,
                 0x4e0811a1,
                 0xf7537e82,
                 0xbd3af235,
                 0x2ad7d2bb,
                 0xeb86d391,
         },
 }
 
 var program = `
+// DO NOT EDIT.
+// Generate with: go run gen.go{{if .Full}} -full{{end}} | gofmt >md5block.go
+
+// +build !amd64
+
 package md5
 
 import (
         "unsafe"
         "runtime"
 )
 
 {{if not .Full}}
         var t1 = [...]uint32{
         {{range .Table1}}{{printf "\t%#x,\n" .}}{{end}}
         }
 ········
         var t2 = [...]uint32{
         {{range .Table2}}{{printf "\t%#x,\n" .}}{{end}}
         }
 ········
         var t3 = [...]uint32{
         {{range .Table3}}{{printf "\t%#x,\n" .}}{{end}}
         }
 ········
         var t4 = [...]uint32{
         {{range .Table4}}{{printf "\t%#x,\n" .}}{{end}}
         }
 {{end}}
+
+const x86 = runtime.GOARCH == "amd64" || runtime.GOARCH == "386"
+
+var littleEndian bool
+
+func init() {
+        x := uint32(0x04030201)
+        y := [4]byte{0x1, 0x2, 0x3, 0x4}
+        littleEndian = *(*[4]byte)(unsafe.Pointer(&x)) == y
+}
 
 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" {
+                if x86 {
                         // 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 {
+                } else if littleEndian && 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
                         }
                 }
 
@@ skipping 74 matching lines @@
 
                 p = p[chunk:]
         }
 
         dig.s[0] = a
         dig.s[1] = b
         dig.s[2] = c
         dig.s[3] = d
 }
 `