libgo: update to Go1.10beta1

    
    Update the Go library to the 1.10beta1 release.
    
    Requires a few changes to the compiler for modifications to the map
    runtime code, and to handle some nowritebarrier cases in the runtime.
    
    Reviewed-on: https://go-review.googlesource.com/86455

gotools/:
	* Makefile.am (go_cmd_vet_files): New variable.
	(go_cmd_buildid_files, go_cmd_test2json_files): New variables.
	(s-zdefaultcc): Change from constants to functions.
	(noinst_PROGRAMS): Add vet, buildid, and test2json.
	(cgo$(EXEEXT)): Link against $(LIBGOTOOL).
	(vet$(EXEEXT)): New target.
	(buildid$(EXEEXT)): New target.
	(test2json$(EXEEXT)): New target.
	(install-exec-local): Install all $(noinst_PROGRAMS).
	(uninstall-local): Uninstasll all $(noinst_PROGRAMS).
	(check-go-tool): Depend on $(noinst_PROGRAMS).  Copy down
	objabi.go.
	(check-runtime): Depend on $(noinst_PROGRAMS).
	(check-cgo-test, check-carchive-test): Likewise.
	(check-vet): New target.
	(check): Depend on check-vet.  Look at cmd_vet-testlog.
	(.PHONY): Add check-vet.
	* Makefile.in: Rebuild.

From-SVN: r256365

1 files changed, 163 insertions, 37 deletions

diff --git a/libgo/go/math/bits/example_test.go b/libgo/go/math/bits/example_test.go
index 78750da..dfe7ece 100644
--- a/libgo/go/math/bits/example_test.go
+++ b/libgo/go/math/bits/example_test.go
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Code generated by go run make_examples.go. DO NOT EDIT.
+
 // +build ignore
 
 package bits_test
@@ -11,70 +13,194 @@ import (
 	"math/bits"
 )
 
+func ExampleLeadingZeros8() {
+	fmt.Printf("LeadingZeros8(%08b) = %d\n", 1, bits.LeadingZeros8(1))
+	// Output:
+	// LeadingZeros8(00000001) = 7
+}
+
 func ExampleLeadingZeros16() {
-	fmt.Println(bits.LeadingZeros16(0))
-	fmt.Println(bits.LeadingZeros16(1))
-	fmt.Println(bits.LeadingZeros16(256))
-	fmt.Println(bits.LeadingZeros16(65535))
+	fmt.Printf("LeadingZeros16(%016b) = %d\n", 1, bits.LeadingZeros16(1))
 	// Output:
-	// 16
-	// 15
-	// 7
-	// 0
+	// LeadingZeros16(0000000000000001) = 15
 }
 
 func ExampleLeadingZeros32() {
-	fmt.Println(bits.LeadingZeros32(0))
-	fmt.Println(bits.LeadingZeros32(1))
+	fmt.Printf("LeadingZeros32(%032b) = %d\n", 1, bits.LeadingZeros32(1))
 	// Output:
-	// 32
-	// 31
+	// LeadingZeros32(00000000000000000000000000000001) = 31
 }
 
 func ExampleLeadingZeros64() {
-	fmt.Println(bits.LeadingZeros64(0))
-	fmt.Println(bits.LeadingZeros64(1))
+	fmt.Printf("LeadingZeros64(%064b) = %d\n", 1, bits.LeadingZeros64(1))
 	// Output:
-	// 64
-	// 63
+	// LeadingZeros64(0000000000000000000000000000000000000000000000000000000000000001) = 63
 }
 
-func ExampleOnesCount() {
-	fmt.Printf("%b\n", 14)
-	fmt.Println(bits.OnesCount(14))
+func ExampleTrailingZeros8() {
+	fmt.Printf("TrailingZeros8(%08b) = %d\n", 14, bits.TrailingZeros8(14))
 	// Output:
-	// 1110
-	// 3
+	// TrailingZeros8(00001110) = 1
+}
+
+func ExampleTrailingZeros16() {
+	fmt.Printf("TrailingZeros16(%016b) = %d\n", 14, bits.TrailingZeros16(14))
+	// Output:
+	// TrailingZeros16(0000000000001110) = 1
+}
+
+func ExampleTrailingZeros32() {
+	fmt.Printf("TrailingZeros32(%032b) = %d\n", 14, bits.TrailingZeros32(14))
+	// Output:
+	// TrailingZeros32(00000000000000000000000000001110) = 1
+}
+
+func ExampleTrailingZeros64() {
+	fmt.Printf("TrailingZeros64(%064b) = %d\n", 14, bits.TrailingZeros64(14))
+	// Output:
+	// TrailingZeros64(0000000000000000000000000000000000000000000000000000000000001110) = 1
 }
 
 func ExampleOnesCount8() {
-	fmt.Printf("%b\n", 14)
-	fmt.Println(bits.OnesCount8(14))
+	fmt.Printf("OnesCount8(%08b) = %d\n", 14, bits.OnesCount8(14))
 	// Output:
-	// 1110
-	// 3
+	// OnesCount8(00001110) = 3
 }
 
 func ExampleOnesCount16() {
-	fmt.Printf("%b\n", 14)
-	fmt.Println(bits.OnesCount16(14))
+	fmt.Printf("OnesCount16(%016b) = %d\n", 14, bits.OnesCount16(14))
 	// Output:
-	// 1110
-	// 3
+	// OnesCount16(0000000000001110) = 3
 }
 
 func ExampleOnesCount32() {
-	fmt.Printf("%b\n", 14)
-	fmt.Println(bits.OnesCount32(14))
+	fmt.Printf("OnesCount32(%032b) = %d\n", 14, bits.OnesCount32(14))
 	// Output:
-	// 1110
-	// 3
+	// OnesCount32(00000000000000000000000000001110) = 3
 }
 
 func ExampleOnesCount64() {
-	fmt.Printf("%b\n", 14)
-	fmt.Println(bits.OnesCount64(14))
+	fmt.Printf("OnesCount64(%064b) = %d\n", 14, bits.OnesCount64(14))
+	// Output:
+	// OnesCount64(0000000000000000000000000000000000000000000000000000000000001110) = 3
+}
+
+func ExampleRotateLeft8() {
+	fmt.Printf("%08b\n", 15)
+	fmt.Printf("%08b\n", bits.RotateLeft8(15, 2))
+	fmt.Printf("%08b\n", bits.RotateLeft8(15, -2))
+	// Output:
+	// 00001111
+	// 00111100
+	// 11000011
+}
+
+func ExampleRotateLeft16() {
+	fmt.Printf("%016b\n", 15)
+	fmt.Printf("%016b\n", bits.RotateLeft16(15, 2))
+	fmt.Printf("%016b\n", bits.RotateLeft16(15, -2))
+	// Output:
+	// 0000000000001111
+	// 0000000000111100
+	// 1100000000000011
+}
+
+func ExampleRotateLeft32() {
+	fmt.Printf("%032b\n", 15)
+	fmt.Printf("%032b\n", bits.RotateLeft32(15, 2))
+	fmt.Printf("%032b\n", bits.RotateLeft32(15, -2))
+	// Output:
+	// 00000000000000000000000000001111
+	// 00000000000000000000000000111100
+	// 11000000000000000000000000000011
+}
+
+func ExampleRotateLeft64() {
+	fmt.Printf("%064b\n", 15)
+	fmt.Printf("%064b\n", bits.RotateLeft64(15, 2))
+	fmt.Printf("%064b\n", bits.RotateLeft64(15, -2))
+	// Output:
+	// 0000000000000000000000000000000000000000000000000000000000001111
+	// 0000000000000000000000000000000000000000000000000000000000111100
+	// 1100000000000000000000000000000000000000000000000000000000000011
+}
+
+func ExampleReverse8() {
+	fmt.Printf("%08b\n", 19)
+	fmt.Printf("%08b\n", bits.Reverse8(19))
+	// Output:
+	// 00010011
+	// 11001000
+}
+
+func ExampleReverse16() {
+	fmt.Printf("%016b\n", 19)
+	fmt.Printf("%016b\n", bits.Reverse16(19))
+	// Output:
+	// 0000000000010011
+	// 1100100000000000
+}
+
+func ExampleReverse32() {
+	fmt.Printf("%032b\n", 19)
+	fmt.Printf("%032b\n", bits.Reverse32(19))
+	// Output:
+	// 00000000000000000000000000010011
+	// 11001000000000000000000000000000
+}
+
+func ExampleReverse64() {
+	fmt.Printf("%064b\n", 19)
+	fmt.Printf("%064b\n", bits.Reverse64(19))
+	// Output:
+	// 0000000000000000000000000000000000000000000000000000000000010011
+	// 1100100000000000000000000000000000000000000000000000000000000000
+}
+
+func ExampleReverseBytes16() {
+	fmt.Printf("%016b\n", 15)
+	fmt.Printf("%016b\n", bits.ReverseBytes16(15))
+	// Output:
+	// 0000000000001111
+	// 0000111100000000
+}
+
+func ExampleReverseBytes32() {
+	fmt.Printf("%032b\n", 15)
+	fmt.Printf("%032b\n", bits.ReverseBytes32(15))
+	// Output:
+	// 00000000000000000000000000001111
+	// 00001111000000000000000000000000
+}
+
+func ExampleReverseBytes64() {
+	fmt.Printf("%064b\n", 15)
+	fmt.Printf("%064b\n", bits.ReverseBytes64(15))
+	// Output:
+	// 0000000000000000000000000000000000000000000000000000000000001111
+	// 0000111100000000000000000000000000000000000000000000000000000000
+}
+
+func ExampleLen8() {
+	fmt.Printf("Len8(%08b) = %d\n", 8, bits.Len8(8))
+	// Output:
+	// Len8(00001000) = 4
+}
+
+func ExampleLen16() {
+	fmt.Printf("Len16(%016b) = %d\n", 8, bits.Len16(8))
+	// Output:
+	// Len16(0000000000001000) = 4
+}
+
+func ExampleLen32() {
+	fmt.Printf("Len32(%032b) = %d\n", 8, bits.Len32(8))
+	// Output:
+	// Len32(00000000000000000000000000001000) = 4
+}
+
+func ExampleLen64() {
+	fmt.Printf("Len64(%064b) = %d\n", 8, bits.Len64(8))
 	// Output:
-	// 1110
-	// 3
+	// Len64(0000000000000000000000000000000000000000000000000000000000001000) = 4
 }