src/crypto/md5/gen.go - go - Git at Google

 // 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] -output md5block.go
 //
 // The -full flag causes the generated code to do a full
 // (16x) unrolling instead of a 4x unrolling.

 package main

 import (
 	"bytes"
 	"flag"
 	"go/format"
 	"io/ioutil"
 	"log"
 	"strings"
 	"text/template"
 )

 var filename = flag.String("output", "md5block.go", "output file name")

 func main() {
 	flag.Parse()

 	var buf bytes.Buffer

 	t := template.Must(template.New("main").Funcs(funcs).Parse(program))
 	if err := t.Execute(&buf, data); err != nil {
 		log.Fatal(err)
 	}

 	data, err := format.Source(buf.Bytes())
 	if err != nil {
 		log.Fatal(err)
 	}
 	err = ioutil.WriteFile(*filename, data, 0644)
 	if err != nil {
 		log.Fatal(err)
 	}
 }

 type Data struct {
 	a, b, c, d string
 	Shift1     []int
 	Shift2     []int
 	Shift3     []int
 	Shift4     []int
 	Table1     []uint32
 	Table2     []uint32
 	Table3     []uint32
 	Table4     []uint32
 	Full       bool
 }

 var funcs = template.FuncMap{
 	"dup":     dup,
 	"relabel": relabel,
 	"rotate":  rotate,
 }

 func dup(count int, x []int) []int {
 	var out []int
 	for i := 0; i < count; i++ {
 		out = append(out, x...)
 	}
 	return out
 }

 func relabel(s string) string {
 	return strings.NewReplacer("a", data.a, "b", data.b, "c", data.c, "d", data.d).Replace(s)
 }

 func rotate() string {
 	data.a, data.b, data.c, data.d = data.d, data.a, data.b, data.c
 	return "" // no output
 }

 func init() {
 	flag.BoolVar(&data.Full, "full", false, "complete unrolling")
 }

 var data = Data{
 	a:      "a",
 	b:      "b",
 	c:      "c",
 	d:      "d",
 	Shift1: []int{7, 12, 17, 22},
 	Shift2: []int{5, 9, 14, 20},
 	Shift3: []int{4, 11, 16, 23},
 	Shift4: []int{6, 10, 15, 21},

 	// table[i] = int((1<<32) * abs(sin(i+1 radians))).
 	Table1: []uint32{
 		// round 1
 		0xd76aa478,
 		0xe8c7b756,
 		0x242070db,
 		0xc1bdceee,
 		0xf57c0faf,
 		0x4787c62a,
 		0xa8304613,
 		0xfd469501,
 		0x698098d8,
 		0x8b44f7af,
 		0xffff5bb1,
 		0x895cd7be,
 		0x6b901122,
 		0xfd987193,
 		0xa679438e,
 		0x49b40821,
 	},
 	Table2: []uint32{
 		// round 2
 		0xf61e2562,
 		0xc040b340,
 		0x265e5a51,
 		0xe9b6c7aa,
 		0xd62f105d,
 		0x2441453,
 		0xd8a1e681,
 		0xe7d3fbc8,
 		0x21e1cde6,
 		0xc33707d6,
 		0xf4d50d87,
 		0x455a14ed,
 		0xa9e3e905,
 		0xfcefa3f8,
 		0x676f02d9,
 		0x8d2a4c8a,
 	},
 	Table3: []uint32{
 		// round3
 		0xfffa3942,
 		0x8771f681,
 		0x6d9d6122,
 		0xfde5380c,
 		0xa4beea44,
 		0x4bdecfa9,
 		0xf6bb4b60,
 		0xbebfbc70,
 		0x289b7ec6,
 		0xeaa127fa,
 		0xd4ef3085,
 		0x4881d05,
 		0xd9d4d039,
 		0xe6db99e5,
 		0x1fa27cf8,
 		0xc4ac5665,
 	},
 	Table4: []uint32{
 		// round 4
 		0xf4292244,
 		0x432aff97,
 		0xab9423a7,
 		0xfc93a039,
 		0x655b59c3,
 		0x8f0ccc92,
 		0xffeff47d,
 		0x85845dd1,
 		0x6fa87e4f,
 		0xfe2ce6e0,
 		0xa3014314,
 		0x4e0811a1,
 		0xf7537e82,
 		0xbd3af235,
 		0x2ad7d2bb,
 		0xeb86d391,
 	},
 }

 var program = `// Copyright 2013 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.

 // DO NOT EDIT.
 // Generate with: go run gen.go{{if .Full}} -full{{end}} -output md5block.go

 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 blockGeneric(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 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 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
 			}
 		}

 		{{if .Full}}
 			// Round 1.
 			{{range $i, $s := dup 4 .Shift1}}
 				{{index $.Table1 $i | printf "a += (((c^d)&b)^d) + X[%d] + %d" $i | relabel}}
 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 				{{rotate}}
 			{{end}}

 			// Round 2.
 			{{range $i, $s := dup 4 .Shift2}}
 				{{index $.Table2 $i | printf "a += (((b^c)&d)^c) + X[(1+5*%d)&15] + %d" $i | relabel}}
 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 				{{rotate}}
 			{{end}}

 			// Round 3.
 			{{range $i, $s := dup 4 .Shift3}}
 				{{index $.Table3 $i | printf "a += (b^c^d) + X[(5+3*%d)&15] + %d" $i | relabel}}
 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 				{{rotate}}
 			{{end}}

 			// Round 4.
 			{{range $i, $s := dup 4 .Shift4}}
 				{{index $.Table4 $i | printf "a += (c^(b|^d)) + X[(7*%d)&15] + %d" $i | relabel}}
 				{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 				{{rotate}}
 			{{end}}
 		{{else}}
 			// Round 1.
 			for i := uint(0); i < 16; {
 				{{range $s := .Shift1}}
 					{{printf "a += (((c^d)&b)^d) + X[i&15] + t1[i&15]" | relabel}}
 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 					i++
 					{{rotate}}
 				{{end}}
 			}

 			// Round 2.
 			for i := uint(0); i < 16; {
 				{{range $s := .Shift2}}
 					{{printf "a += (((b^c)&d)^c) + X[(1+5*i)&15] + t2[i&15]" | relabel}}
 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 					i++
 					{{rotate}}
 				{{end}}
 			}

 			// Round 3.
 			for i := uint(0); i < 16; {
 				{{range $s := .Shift3}}
 					{{printf "a += (b^c^d) + X[(5+3*i)&15] + t3[i&15]" | relabel}}
 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 					i++
 					{{rotate}}
 				{{end}}
 			}

 			// Round 4.
 			for i := uint(0); i < 16; {
 				{{range $s := .Shift4}}
 					{{printf "a += (c^(b|^d)) + X[(7*i)&15] + t4[i&15]" | relabel}}
 					{{printf "a = a<<%d | a>>(32-%d) + b" $s $s | relabel}}
 					i++
 					{{rotate}}
 				{{end}}
 			}
 		{{end}}

 		a += aa
 		b += bb
 		c += cc
 		d += dd

 		p = p[chunk:]
 	}

 	dig.s[0] = a
 	dig.s[1] = b
 	dig.s[2] = c
 	dig.s[3] = d
 }
 `
	// 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] -output md5block.go
	//
	// The -full flag causes the generated code to do a full
	// (16x) unrolling instead of a 4x unrolling.

	package main

	import (
	"bytes"
	"flag"
	"go/format"
	"io/ioutil"
	"log"
	"strings"
	"text/template"
	)

	var filename = flag.String("output", "md5block.go", "output file name")

	func main() {
	flag.Parse()

	var buf bytes.Buffer

	t := template.Must(template.New("main").Funcs(funcs).Parse(program))
	if err := t.Execute(&buf, data); err != nil {
	log.Fatal(err)
	}

	data, err := format.Source(buf.Bytes())
	if err != nil {
	log.Fatal(err)
	}
	err = ioutil.WriteFile(*filename, data, 0644)
	if err != nil {
	log.Fatal(err)
	}
	}

	type Data struct {
	a, b, c, d string
	Shift1 []int
	Shift2 []int
	Shift3 []int
	Shift4 []int
	Table1 []uint32
	Table2 []uint32
	Table3 []uint32
	Table4 []uint32
	Full bool
	}

	var funcs = template.FuncMap{
	"dup": dup,
	"relabel": relabel,
	"rotate": rotate,
	}

	func dup(count int, x []int) []int {
	var out []int
	for i := 0; i < count; i++ {
	out = append(out, x...)
	}
	return out
	}

	func relabel(s string) string {
	return strings.NewReplacer("a", data.a, "b", data.b, "c", data.c, "d", data.d).Replace(s)
	}

	func rotate() string {
	data.a, data.b, data.c, data.d = data.d, data.a, data.b, data.c
	return "" // no output
	}

	func init() {
	flag.BoolVar(&data.Full, "full", false, "complete unrolling")
	}

	var data = Data{
	a: "a",
	b: "b",
	c: "c",
	d: "d",
	Shift1: []int{7, 12, 17, 22},
	Shift2: []int{5, 9, 14, 20},
	Shift3: []int{4, 11, 16, 23},
	Shift4: []int{6, 10, 15, 21},

	// table[i] = int((1<<32) * abs(sin(i+1 radians))).
	Table1: []uint32{
	// round 1
	0xd76aa478,
	0xe8c7b756,
	0x242070db,
	0xc1bdceee,
	0xf57c0faf,
	0x4787c62a,
	0xa8304613,
	0xfd469501,
	0x698098d8,
	0x8b44f7af,
	0xffff5bb1,
	0x895cd7be,
	0x6b901122,
	0xfd987193,
	0xa679438e,
	0x49b40821,
	},
	Table2: []uint32{
	// round 2
	0xf61e2562,
	0xc040b340,
	0x265e5a51,
	0xe9b6c7aa,
	0xd62f105d,
	0x2441453,
	0xd8a1e681,
	0xe7d3fbc8,
	0x21e1cde6,
	0xc33707d6,
	0xf4d50d87,
	0x455a14ed,
	0xa9e3e905,
	0xfcefa3f8,
	0x676f02d9,
	0x8d2a4c8a,
	},
	Table3: []uint32{
	// round3
	0xfffa3942,
	0x8771f681,
	0x6d9d6122,
	0xfde5380c,
	0xa4beea44,
	0x4bdecfa9,
	0xf6bb4b60,
	0xbebfbc70,
	0x289b7ec6,
	0xeaa127fa,
	0xd4ef3085,
	0x4881d05,
	0xd9d4d039,
	0xe6db99e5,
	0x1fa27cf8,
	0xc4ac5665,
	},
	Table4: []uint32{
	// round 4
	0xf4292244,
	0x432aff97,
	0xab9423a7,
	0xfc93a039,
	0x655b59c3,
	0x8f0ccc92,
	0xffeff47d,
	0x85845dd1,
	0x6fa87e4f,
	0xfe2ce6e0,
	0xa3014314,
	0x4e0811a1,
	0xf7537e82,
	0xbd3af235,
	0x2ad7d2bb,
	0xeb86d391,
	},
	}

	var program = `// Copyright 2013 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.

	// DO NOT EDIT.
	// Generate with: go run gen.go{{if .Full}} -full{{end}} -output md5block.go

	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 blockGeneric(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 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 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
	}
	}

	{{if .Full}}
	// Round 1.
	{{range $i, $s := dup 4 .Shift1}}
	{{index $.Table1 $i \| printf "a += (((c^d)&b)^d) + X[%d] + %d" $i \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	{{rotate}}
	{{end}}

	// Round 2.
	{{range $i, $s := dup 4 .Shift2}}
	{{index $.Table2 $i \| printf "a += (((b^c)&d)^c) + X[(1+5*%d)&15] + %d" $i \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	{{rotate}}
	{{end}}

	// Round 3.
	{{range $i, $s := dup 4 .Shift3}}
	{{index $.Table3 $i \| printf "a += (b^c^d) + X[(5+3*%d)&15] + %d" $i \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	{{rotate}}
	{{end}}

	// Round 4.
	{{range $i, $s := dup 4 .Shift4}}
	{{index $.Table4 $i \| printf "a += (c^(b\|^d)) + X[(7*%d)&15] + %d" $i \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	{{rotate}}
	{{end}}
	{{else}}
	// Round 1.
	for i := uint(0); i < 16; {
	{{range $s := .Shift1}}
	{{printf "a += (((c^d)&b)^d) + X[i&15] + t1[i&15]" \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	i++
	{{rotate}}
	{{end}}
	}

	// Round 2.
	for i := uint(0); i < 16; {
	{{range $s := .Shift2}}
	{{printf "a += (((b^c)&d)^c) + X[(1+5*i)&15] + t2[i&15]" \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	i++
	{{rotate}}
	{{end}}
	}

	// Round 3.
	for i := uint(0); i < 16; {
	{{range $s := .Shift3}}
	{{printf "a += (b^c^d) + X[(5+3*i)&15] + t3[i&15]" \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	i++
	{{rotate}}
	{{end}}
	}

	// Round 4.
	for i := uint(0); i < 16; {
	{{range $s := .Shift4}}
	{{printf "a += (c^(b\|^d)) + X[(7*i)&15] + t4[i&15]" \| relabel}}
	{{printf "a = a<<%d \| a>>(32-%d) + b" $s $s \| relabel}}
	i++
	{{rotate}}
	{{end}}
	}
	{{end}}

	a += aa
	b += bb
	c += cc
	d += dd

	p = p[chunk:]
	}

	dig.s[0] = a
	dig.s[1] = b
	dig.s[2] = c
	dig.s[3] = d
	}
	`