From 19bd145d0721a28658b15deb548f22a3405d83bd Mon Sep 17 00:00:00 2001
From: Matthew Dempsky <mdempsky@google.com>
Date: Fri, 7 Apr 2017 00:42:51 +0000
Subject: [PATCH] Revert "cmd/compile: make typenamesym do less work"

This reverts commit 91433eb5772ab4aa62efb9f5cde07e4a1556e96e.

Reason for revert: broke deterministic build.

Fixes #19872.

Change-Id: Ia1a0fc651b818bdf69454df43bd189689c0348a0
Reviewed-on: https://go-review.googlesource.com/39871
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>
---
 src/cmd/compile/internal/gc/reflect.go | 60 ++++++++------------------
 src/cmd/compile/internal/gc/type.go    |  2 -
 2 files changed, 18 insertions(+), 44 deletions(-)

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 2ba2457209..639a460572 100644
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -34,7 +34,7 @@ type ptabEntry struct {
 }
 
 // runtime interface and reflection data structures
-var signatlist = make(map[*Type]bool)
+var signatlist []*Type
 var itabs []itabEntry
 var ptabs []ptabEntry
 
@@ -933,22 +933,24 @@ func typesymprefix(prefix string, t *Type) *Sym {
 
 func typenamesym(t *Type) *Sym {
 	if t == nil || (t.IsPtr() && t.Elem() == nil) || t.IsUntyped() {
-		Fatalf("typenamesym %v", t)
+		Fatalf("typename %v", t)
 	}
 	s := typesym(t)
-	addsignat(t)
-	return s
-}
-
-func typename(t *Type) *Node {
-	s := typenamesym(t)
 	if s.Def == nil {
 		n := newnamel(src.NoXPos, s)
 		n.Type = Types[TUINT8]
 		n.Class = PEXTERN
 		n.Typecheck = 1
 		s.Def = n
+
+		signatlist = append(signatlist, t)
 	}
+
+	return s.Def.Sym
+}
+
+func typename(t *Type) *Node {
+	s := typenamesym(t)
 	n := nod(OADDR, s.Def, nil)
 	n.Type = typPtr(s.Def.Type)
 	n.SetAddable(true)
@@ -1415,35 +1417,21 @@ func itabsym(it *obj.LSym, offset int64) *obj.LSym {
 	return syms[methodnum]
 }
 
-func addsignat(t *Type) {
-	signatlist[t] = true
-}
-
 func dumptypestructs() {
 	// copy types from externdcl list to signatlist
 	for _, n := range externdcl {
 		if n.Op == OTYPE {
-			addsignat(n.Type)
+			signatlist = append(signatlist, n.Type)
 		}
 	}
 
-	// Process signatlist. Use a loop, as dtypesym adds
-	// entries to signatlist while it is being processed.
-	signats := make([]typeAndStr, len(signatlist))
-	for len(signatlist) > 0 {
-		signats = signats[:0]
-		// Transfer entries to a slice and sort, for reproducible builds.
-		for t := range signatlist {
-			signats = append(signats, typeAndStr{t: t, s: t.LongString()})
-			delete(signatlist, t)
-		}
-		sort.Sort(typesByLongString(signats))
-		for _, ts := range signats {
-			t := ts.t
-			dtypesym(t)
-			if t.Sym != nil {
-				dtypesym(typPtr(t))
-			}
+	// Process signatlist.  This can't use range, as entries are
+	// added to the list while it is being processed.
+	for i := 0; i < len(signatlist); i++ {
+		t := signatlist[i]
+		dtypesym(t)
+		if t.Sym != nil {
+			dtypesym(typPtr(t))
 		}
 	}
 
@@ -1539,18 +1527,6 @@ func dumptypestructs() {
 	}
 }
 
-type typeAndStr struct {
-	t *Type
-	s string
-}
-
-// TODO(josharian): simplify this to just use Type.cmp once issue 19869 has been fixed.
-type typesByLongString []typeAndStr
-
-func (a typesByLongString) Len() int           { return len(a) }
-func (a typesByLongString) Less(i, j int) bool { return a[i].s < a[j].s }
-func (a typesByLongString) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
 type pkgByPath []*Pkg
 
 func (a pkgByPath) Len() int           { return len(a) }
diff --git a/src/cmd/compile/internal/gc/type.go b/src/cmd/compile/internal/gc/type.go
index 442dd752cc..cbf9b06afb 100644
--- a/src/cmd/compile/internal/gc/type.go
+++ b/src/cmd/compile/internal/gc/type.go
@@ -976,8 +976,6 @@ func (r *Sym) cmpsym(s *Sym) ssa.Cmp {
 // cmp compares two *Types t and x, returning ssa.CMPlt,
 // ssa.CMPeq, ssa.CMPgt as t<x, t==x, t>x, for an arbitrary
 // and optimizer-centric notion of comparison.
-// TODO(josharian): make this safe for recursive interface types
-// and use in signatlist sorting. See issue 19869.
 func (t *Type) cmp(x *Type) ssa.Cmp {
 	// This follows the structure of eqtype in subr.go
 	// with two exceptions.