cmd/compile: clean up encoding of export version info

Replace ad-hoc encoding of export version info with a
more systematic approach.

Continue to read (but not write) the Go1.7 format for backward-
compatibility. This will avoid spurious errors with old installed
packages.

Fixes #16244.

Change-Id: I945e79ffd5e22b883250f6f9fac218370c2505a2
Reviewed-on: https://go-review.googlesource.com/27452Reviewed-by: Matthew Dempsky <mdempsky@google.com>

src/cmd/compile/internal/gc/bexport.go

@@ -51,13 +51,16 @@ they are automatically encoded with a known and fixed type index.
 
 2) Encoding format:
 
-The export data starts with a single byte indicating the encoding format
-(compact, or with debugging information), followed by a version string
-(so we can evolve the encoding if need be), and then the package object
-for the exported package (with an empty path).
+The export data starts with two newline-terminated strings: a version
+string and either an empty string, or "debug", when emitting the debug
+format. These strings are followed by version-specific encoding options.
 
-After this header, two lists of objects and the list of inlined function
-bodies follows.
+(The Go1.7 version starts with a couple of bytes specifying the format.
+That format encoding is no longer used but is supported to avoid spurious
+errors when importing old installed package files.)
+
+The header is followed by the package object for the exported package,
+two lists of objects, and the list of inlined function bodies.
 
 The encoding of objects is straight-forward: Constants, variables, and
 functions start with their name, type, and possibly a value. Named types
@@ -77,7 +80,8 @@ Strings are canonicalized similar to objects that may occur multiple times:
 If the string was exported already, it is represented by its index only.
 Otherwise, the export data starts with the negative string length (negative,
 so we can distinguish from string index), followed by the string bytes.
-The empty string is mapped to index 0.
+The empty string is mapped to index 0. (The initial format string is an
+exception; it is encoded as the string bytes followed by a newline).
 
 The exporter and importer are completely symmetric in implementation: For
 each encoding routine there is a matching and symmetric decoding routine.
@@ -154,8 +158,8 @@ const debugFormat = false // default: false
 const forceObjFileStability = true
 
 // Current export format version.
-// TODO(gri) Make this more systematic (issue #16244).
-const exportVersion = "v1"
+// Must not start with 'c' or 'd' (initials of prior format).
+const exportVersion = "version 1"
 
 // exportInlined enables the export of inlined function bodies and related
 // dependencies. The compiler should work w/o any loss of functionality with
@@ -212,43 +216,18 @@ func export(out *bufio.Writer, trace bool) int {
 		trace:         trace,
 	}
 
-	// TODO(gri) clean up the ad-hoc encoding of the file format below
-	// (we need this so we can read the builtin package export data
-	// easily w/o being affected by format changes)
-
-	// first byte indicates low-level encoding format
-	var format byte = 'c' // compact
+	// write version info
+	p.rawStringln(exportVersion)
+	var debug string
 	if debugFormat {
-		format = 'd'
-	}
-	p.rawByte(format)
-
-	format = 'n' // track named types only
-	if trackAllTypes {
-		format = 'a'
+		debug = "debug"
 	}
-	p.rawByte(format)
-
-	// posInfo exported or not?
+	p.rawStringln(debug) // cannot use p.bool since it's affected by debugFormat; also want to see this clearly
+	p.bool(trackAllTypes)
 	p.bool(p.posInfoFormat)
 
 	// --- generic export data ---
 
-	if p.trace {
-		p.tracef("\n--- package ---\n")
-		if p.indent != 0 {
-			Fatalf("exporter: incorrect indentation %d", p.indent)
-		}
-	}
-
-	if p.trace {
-		p.tracef("version = ")
-	}
-	p.string(exportVersion)
-	if p.trace {
-		p.tracef("\n")
-	}
-
 	// populate type map with predeclared "known" types
 	predecl := predeclared()
 	for index, typ := range predecl {
@@ -1725,7 +1704,7 @@ func (p *exporter) marker(m byte) {
 	p.rawInt64(int64(p.written))
 }
 
-// rawInt64 should only be used by low-level encoders
+// rawInt64 should only be used by low-level encoders.
 func (p *exporter) rawInt64(x int64) {
 	var tmp [binary.MaxVarintLen64]byte
 	n := binary.PutVarint(tmp[:], x)
@@ -1734,6 +1713,14 @@ func (p *exporter) rawInt64(x int64) {
 	}
 }
 
+// rawStringln should only be used to emit the initial version string.
+func (p *exporter) rawStringln(s string) {
+	for i := 0; i < len(s); i++ {
+		p.rawByte(s[i])
+	}
+	p.rawByte('\n')
+}
+
 // rawByte is the bottleneck interface to write to p.out.
 // rawByte escapes b as follows (any encoding does that
 // hides '$'):

src/cmd/compile/internal/gc/bimport.go

@@ -51,26 +51,35 @@ func Import(in *bufio.Reader) {
 		strList: []string{""}, // empty string is mapped to 0
 	}
 
-	// read low-level encoding format
-	switch format := p.rawByte(); format {
-	case 'c':
-		// compact format - nothing to do
-	case 'd':
+	// read version info
+	if b := p.rawByte(); b == 'c' || b == 'd' {
+		// Go1.7 encoding; first byte encodes low-level
+		// encoding format (compact vs debug).
+		// For backward-compatibility only (avoid problems with
+		// old installed packages). Newly compiled packages use
+		// the extensible format string.
+		// TODO(gri) Remove this support eventually; after Go1.8.
+		if b == 'd' {
 			p.debugFormat = true
-	default:
-		Fatalf("importer: invalid encoding format in export data: got %q; want 'c' or 'd'", format)
 		}
-
 		p.trackAllTypes = p.rawByte() == 'a'
-
 		p.posInfoFormat = p.bool()
+		const go17version = "v1"
+		if s := p.string(); s != go17version {
+			Fatalf("importer: unknown export data format: %s (imported package compiled with old compiler?)", s)
+		}
+	} else {
+		// Go1.8 extensible encoding
+		if s := p.rawStringln(b); s != exportVersion {
+			Fatalf("importer: unknown export data format: %s (imported package compiled with old compiler?)", s)
+		}
+		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
+		p.trackAllTypes = p.bool()
+		p.posInfoFormat = p.bool()
+	}
 
 	// --- generic export data ---
 
-	if v := p.string(); v != exportVersion {
-		Fatalf("importer: unknown export data version: %s", v)
-	}
-
 	// populate typList with predeclared "known" types
 	p.typList = append(p.typList, predeclared()...)
 
@@ -1185,7 +1194,7 @@ func (p *importer) marker(want byte) {
 	}
 }
 
-// rawInt64 should only be used by low-level decoders
+// rawInt64 should only be used by low-level decoders.
 func (p *importer) rawInt64() int64 {
 	i, err := binary.ReadVarint(p)
 	if err != nil {
@@ -1194,6 +1203,16 @@ func (p *importer) rawInt64() int64 {
 	return i
 }
 
+// rawStringln should only be used to read the initial version string.
+func (p *importer) rawStringln(b byte) string {
+	p.buf = p.buf[:0]
+	for b != '\n' {
+		p.buf = append(p.buf, b)
+		b = p.rawByte()
+	}
+	return string(p.buf)
+}
+
 // needed for binary.ReadVarint in rawInt64
 func (p *importer) ReadByte() (byte, error) {
 	return p.rawByte(), nil

src/go/internal/gcimporter/bimport.go

@@ -50,26 +50,36 @@ func BImportData(imports map[string]*types.Package, data []byte, path string) (i
 		strList: []string{""}, // empty string is mapped to 0
 	}
 
-	// read low-level encoding format
-	switch format := p.rawByte(); format {
-	case 'c':
-		// compact format - nothing to do
-	case 'd':
+	// read version info
+	if b := p.rawByte(); b == 'c' || b == 'd' {
+		// Go1.7 encoding; first byte encodes low-level
+		// encoding format (compact vs debug).
+		// For backward-compatibility only (avoid problems with
+		// old installed packages). Newly compiled packages use
+		// the extensible format string.
+		// TODO(gri) Remove this support eventually; after Go1.8.
+		if b == 'd' {
 			p.debugFormat = true
-	default:
-		return p.read, nil, fmt.Errorf("invalid encoding format in export data: got %q; want 'c' or 'd'", format)
 		}
-
 		p.trackAllTypes = p.rawByte() == 'a'
-
 		p.posInfoFormat = p.int() != 0
+		const go17version = "v1"
+		if s := p.string(); s != go17version {
+			return p.read, nil, fmt.Errorf("importer: unknown export data format: %s (imported package compiled with old compiler?)", s)
+		}
+	} else {
+		// Go1.8 extensible encoding
+		const exportVersion = "version 1"
+		if s := p.rawStringln(b); s != exportVersion {
+			return p.read, nil, fmt.Errorf("importer: unknown export data format: %s (imported package compiled with old compiler?)", s)
+		}
+		p.debugFormat = p.rawStringln(p.rawByte()) == "debug"
+		p.trackAllTypes = p.int() != 0
+		p.posInfoFormat = p.int() != 0
+	}
 
 	// --- generic export data ---
 
-	if v := p.string(); v != "v1" {
-		return p.read, nil, fmt.Errorf("unknown export data version: %s", v)
-	}
-
 	// populate typList with predeclared "known" types
 	p.typList = append(p.typList, predeclared...)
 
@@ -682,7 +692,7 @@ func (p *importer) marker(want byte) {
 	}
 }
 
-// rawInt64 should only be used by low-level decoders
+// rawInt64 should only be used by low-level decoders.
 func (p *importer) rawInt64() int64 {
 	i, err := binary.ReadVarint(p)
 	if err != nil {
@@ -691,6 +701,16 @@ func (p *importer) rawInt64() int64 {
 	return i
 }
 
+// rawStringln should only be used to read the initial version string.
+func (p *importer) rawStringln(b byte) string {
+	p.buf = p.buf[:0]
+	for b != '\n' {
+		p.buf = append(p.buf, b)
+		b = p.rawByte()
+	}
+	return string(p.buf)
+}
+
 // needed for binary.ReadVarint in rawInt64
 func (p *importer) ReadByte() (byte, error) {
 	return p.rawByte(), nil