libgo: update to Go1.12beta2

    
    Reviewed-on: https://go-review.googlesource.com/c/158019

gotools/:
	* Makefile.am (go_cmd_vet_files): Update for Go1.12beta2 release.
	(GOTOOLS_TEST_TIMEOUT): Increase to 600.
	(check-runtime): Export LD_LIBRARY_PATH before computing GOARCH
	and GOOS.
	(check-vet): Copy golang.org/x/tools into check-vet-dir.
	* Makefile.in: Regenerate.

gcc/testsuite/:
	* go.go-torture/execute/names-1.go: Stop using debug/xcoff, which
	is no longer externally visible.

From-SVN: r268084

3 files changed, 177 insertions, 29 deletions

diff --git a/libgo/go/image/png/reader_test.go b/libgo/go/image/png/reader_test.go
index 66bcfcb..33dcd3d 100644
--- a/libgo/go/image/png/reader_test.go
+++ b/libgo/go/image/png/reader_test.go
@@ -364,10 +364,6 @@ func TestReader(t *testing.T) {
 		}
 		defer sf.Close()
 		sb := bufio.NewScanner(sf)
-		if err != nil {
-			t.Error(fn, err)
-			continue
-		}
 
 		// Compare the two, in SNG format, line by line.
 		for {
diff --git a/libgo/go/image/png/writer.go b/libgo/go/image/png/writer.go
index 49f1ad2..c033351 100644
--- a/libgo/go/image/png/writer.go
+++ b/libgo/go/image/png/writer.go
@@ -7,6 +7,7 @@ package png
 import (
 	"bufio"
 	"compress/zlib"
+	"encoding/binary"
 	"hash/crc32"
 	"image"
 	"image/color"
@@ -62,14 +63,6 @@ const (
 	// compression level, although that is not implemented yet.
 )
 
-// Big-endian.
-func writeUint32(b []uint8, u uint32) {
-	b[0] = uint8(u >> 24)
-	b[1] = uint8(u >> 16)
-	b[2] = uint8(u >> 8)
-	b[3] = uint8(u >> 0)
-}
-
 type opaquer interface {
 	Opaque() bool
 }
@@ -108,7 +101,7 @@ func (e *encoder) writeChunk(b []byte, name string) {
 		e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b)))
 		return
 	}
-	writeUint32(e.header[:4], n)
+	binary.BigEndian.PutUint32(e.header[:4], n)
 	e.header[4] = name[0]
 	e.header[5] = name[1]
 	e.header[6] = name[2]
@@ -116,7 +109,7 @@ func (e *encoder) writeChunk(b []byte, name string) {
 	crc := crc32.NewIEEE()
 	crc.Write(e.header[4:8])
 	crc.Write(b)
-	writeUint32(e.footer[:4], crc.Sum32())
+	binary.BigEndian.PutUint32(e.footer[:4], crc.Sum32())
 
 	_, e.err = e.w.Write(e.header[:8])
 	if e.err != nil {
@@ -131,8 +124,8 @@ func (e *encoder) writeChunk(b []byte, name string) {
 
 func (e *encoder) writeIHDR() {
 	b := e.m.Bounds()
-	writeUint32(e.tmp[0:4], uint32(b.Dx()))
-	writeUint32(e.tmp[4:8], uint32(b.Dy()))
+	binary.BigEndian.PutUint32(e.tmp[0:4], uint32(b.Dx()))
+	binary.BigEndian.PutUint32(e.tmp[4:8], uint32(b.Dy()))
 	// Set bit depth and color type.
 	switch e.cb {
 	case cbG8:
@@ -144,6 +137,15 @@ func (e *encoder) writeIHDR() {
 	case cbP8:
 		e.tmp[8] = 8
 		e.tmp[9] = ctPaletted
+	case cbP4:
+		e.tmp[8] = 4
+		e.tmp[9] = ctPaletted
+	case cbP2:
+		e.tmp[8] = 2
+		e.tmp[9] = ctPaletted
+	case cbP1:
+		e.tmp[8] = 1
+		e.tmp[9] = ctPaletted
 	case cbTCA8:
 		e.tmp[8] = 8
 		e.tmp[9] = ctTrueColorAlpha
@@ -312,31 +314,38 @@ func (e *encoder) writeImage(w io.Writer, m image.Image, cb int, level int) erro
 	}
 	defer e.zw.Close()
 
-	bpp := 0 // Bytes per pixel.
+	bitsPerPixel := 0
 
 	switch cb {
 	case cbG8:
-		bpp = 1
+		bitsPerPixel = 8
 	case cbTC8:
-		bpp = 3
+		bitsPerPixel = 24
 	case cbP8:
-		bpp = 1
+		bitsPerPixel = 8
+	case cbP4:
+		bitsPerPixel = 4
+	case cbP2:
+		bitsPerPixel = 2
+	case cbP1:
+		bitsPerPixel = 1
 	case cbTCA8:
-		bpp = 4
+		bitsPerPixel = 32
 	case cbTC16:
-		bpp = 6
+		bitsPerPixel = 48
 	case cbTCA16:
-		bpp = 8
+		bitsPerPixel = 64
 	case cbG16:
-		bpp = 2
+		bitsPerPixel = 16
 	}
+
 	// cr[*] and pr are the bytes for the current and previous row.
 	// cr[0] is unfiltered (or equivalently, filtered with the ftNone filter).
 	// cr[ft], for non-zero filter types ft, are buffers for transforming cr[0] under the
 	// other PNG filter types. These buffers are allocated once and re-used for each row.
 	// The +1 is for the per-row filter type, which is at cr[*][0].
 	b := m.Bounds()
-	sz := 1 + bpp*b.Dx()
+	sz := 1 + (bitsPerPixel*b.Dx()+7)/8
 	for i := range e.cr {
 		if cap(e.cr[i]) < sz {
 			e.cr[i] = make([]uint8, sz)
@@ -412,6 +421,30 @@ func (e *encoder) writeImage(w io.Writer, m image.Image, cb int, level int) erro
 					i += 1
 				}
 			}
+
+		case cbP4, cbP2, cbP1:
+			pi := m.(image.PalettedImage)
+
+			var a uint8
+			var c int
+			for x := b.Min.X; x < b.Max.X; x++ {
+				a = a<<uint(bitsPerPixel) | pi.ColorIndexAt(x, y)
+				c++
+				if c == 8/bitsPerPixel {
+					cr[0][i] = a
+					i += 1
+					a = 0
+					c = 0
+				}
+			}
+			if c != 0 {
+				for c != 8/bitsPerPixel {
+					a = a << uint(bitsPerPixel)
+					c++
+				}
+				cr[0][i] = a
+			}
+
 		case cbTCA8:
 			if nrgba != nil {
 				offset := (y - b.Min.Y) * nrgba.Stride
@@ -467,7 +500,10 @@ func (e *encoder) writeImage(w io.Writer, m image.Image, cb int, level int) erro
 		// "filters are rarely useful on palette images" and will result
 		// in larger files (see http://www.libpng.org/pub/png/book/chapter09.html).
 		f := ftNone
-		if level != zlib.NoCompression && cb != cbP8 {
+		if level != zlib.NoCompression && cb != cbP8 && cb != cbP4 && cb != cbP2 && cb != cbP1 {
+			// Since we skip paletted images we don't have to worry about
+			// bitsPerPixel not being a multiple of 8
+			bpp := bitsPerPixel / 8
 			f = filter(&cr, pr, bpp)
 		}
 
@@ -558,7 +594,15 @@ func (enc *Encoder) Encode(w io.Writer, m image.Image) error {
 		pal, _ = m.ColorModel().(color.Palette)
 	}
 	if pal != nil {
-		e.cb = cbP8
+		if len(pal) <= 2 {
+			e.cb = cbP1
+		} else if len(pal) <= 4 {
+			e.cb = cbP2
+		} else if len(pal) <= 16 {
+			e.cb = cbP4
+		} else {
+			e.cb = cbP8
+		}
 	} else {
 		switch m.ColorModel() {
 		case color.GrayModel:
diff --git a/libgo/go/image/png/writer_test.go b/libgo/go/image/png/writer_test.go
index 1107ea0..5d131ff 100644
--- a/libgo/go/image/png/writer_test.go
+++ b/libgo/go/image/png/writer_test.go
@@ -6,9 +6,12 @@ package png
 
 import (
 	"bytes"
+	"compress/zlib"
+	"encoding/binary"
 	"fmt"
 	"image"
 	"image/color"
+	"io"
 	"io/ioutil"
 	"testing"
 )
@@ -61,12 +64,12 @@ func TestWriter(t *testing.T) {
 		m1, err := readPNG(qfn)
 		if err != nil {
 			t.Error(fn, err)
-			return
+			continue
 		}
 		m2, err := encodeDecode(m1)
 		if err != nil {
 			t.Error(fn, err)
-			return
+			continue
 		}
 		// Compare the two.
 		err = diff(m0, m2)
@@ -77,6 +80,111 @@ func TestWriter(t *testing.T) {
 	}
 }
 
+func TestWriterPaletted(t *testing.T) {
+	const width, height = 32, 16
+
+	testCases := []struct {
+		plen     int
+		bitdepth uint8
+		datalen  int
+	}{
+
+		{
+			plen:     256,
+			bitdepth: 8,
+			datalen:  (1 + width) * height,
+		},
+
+		{
+			plen:     128,
+			bitdepth: 8,
+			datalen:  (1 + width) * height,
+		},
+
+		{
+			plen:     16,
+			bitdepth: 4,
+			datalen:  (1 + width/2) * height,
+		},
+
+		{
+			plen:     4,
+			bitdepth: 2,
+			datalen:  (1 + width/4) * height,
+		},
+
+		{
+			plen:     2,
+			bitdepth: 1,
+			datalen:  (1 + width/8) * height,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(fmt.Sprintf("plen-%d", tc.plen), func(t *testing.T) {
+			// Create a paletted image with the correct palette length
+			palette := make(color.Palette, tc.plen)
+			for i := range palette {
+				palette[i] = color.NRGBA{
+					R: uint8(i),
+					G: uint8(i),
+					B: uint8(i),
+					A: 255,
+				}
+			}
+			m0 := image.NewPaletted(image.Rect(0, 0, width, height), palette)
+
+			i := 0
+			for y := 0; y < height; y++ {
+				for x := 0; x < width; x++ {
+					m0.SetColorIndex(x, y, uint8(i%tc.plen))
+					i++
+				}
+			}
+
+			// Encode the image
+			var b bytes.Buffer
+			if err := Encode(&b, m0); err != nil {
+				t.Error(err)
+				return
+			}
+			const chunkFieldsLength = 12 // 4 bytes for length, name and crc
+			data := b.Bytes()
+			i = len(pngHeader)
+
+			for i < len(data)-chunkFieldsLength {
+				length := binary.BigEndian.Uint32(data[i : i+4])
+				name := string(data[i+4 : i+8])
+
+				switch name {
+				case "IHDR":
+					bitdepth := data[i+8+8]
+					if bitdepth != tc.bitdepth {
+						t.Errorf("got bitdepth %d, want %d", bitdepth, tc.bitdepth)
+					}
+				case "IDAT":
+					// Uncompress the image data
+					r, err := zlib.NewReader(bytes.NewReader(data[i+8 : i+8+int(length)]))
+					if err != nil {
+						t.Error(err)
+						return
+					}
+					n, err := io.Copy(ioutil.Discard, r)
+					if err != nil {
+						t.Errorf("got error while reading image data: %v", err)
+					}
+					if n != int64(tc.datalen) {
+						t.Errorf("got uncompressed data length %d, want %d", n, tc.datalen)
+					}
+				}
+
+				i += chunkFieldsLength + int(length)
+			}
+		})
+
+	}
+}
+
 func TestWriterLevels(t *testing.T) {
 	m := image.NewNRGBA(image.Rect(0, 0, 100, 100))