josharian
diff --git a/‎src/cmd/compile/internal/gc/dcl.go
+4 b/‎src/cmd/compile/internal/gc/dcl.go
+4
diff --git a/‎src/cmd/compile/internal/gc/go.go
+5-1 b/‎src/cmd/compile/internal/gc/go.go
+5-1
diff --git a/‎src/cmd/compile/internal/gc/gsubr.go
+3-2 b/‎src/cmd/compile/internal/gc/gsubr.go
+3-2
diff --git a/‎src/cmd/compile/internal/gc/main.go
+59-2 b/‎src/cmd/compile/internal/gc/main.go
+59-2
diff --git a/‎src/cmd/compile/internal/gc/obj.go
+7 b/‎src/cmd/compile/internal/gc/obj.go
+7
diff --git a/‎src/cmd/compile/internal/gc/pgen.go
+23-3 b/‎src/cmd/compile/internal/gc/pgen.go
+23-3
diff --git a/‎src/cmd/compile/internal/gc/reflect.go
+18-3 b/‎src/cmd/compile/internal/gc/reflect.go
+18-3
diff --git a/‎src/cmd/compile/internal/gc/ssa.go
+20-5 b/‎src/cmd/compile/internal/gc/ssa.go
+20-5
diff --git a/‎src/cmd/compile/internal/gc/subr.go
+5-1 b/‎src/cmd/compile/internal/gc/subr.go
+5-1
@@ -1069,7 +1069,9 @@ func funcsym(s *types.Sym) *types.Sym {
 	// symbols will be created explicitly with makefuncsym.
 	// See the makefuncsym comment for details.
 	if !Ctxt.Flag_dynlink && !existed {
+		funcsymsmu.Lock()
 		funcsyms = append(funcsyms, s)
+		funcsymsmu.Unlock()
 	}
 	return sf
 }
@@ -1096,7 +1098,9 @@ func makefuncsym(s *types.Sym) {
 		return
 	}
 	if _, existed := s.Pkg.LookupOK(funcsymname(s)); !existed {
+		funcsymsmu.Lock()
 		funcsyms = append(funcsyms, s)
+		funcsymsmu.Unlock()
 	}
 }
 
 
@@ -10,6 +10,7 @@ import (
 	"cmd/internal/bio"
 	"cmd/internal/obj"
 	"cmd/internal/src"
+	"sync"
 )
 
 const (
@@ -171,7 +172,10 @@ var exportlist []*Node
 
 var importlist []*Node // imported functions and methods with inlinable bodies
 
-var funcsyms []*types.Sym
+var (
+	funcsymsmu sync.Mutex // protects funcsyms
+	funcsyms   []*types.Sym
+)
 
 var dclcontext Class // PEXTERN/PAUTO
 
 
@@ -54,10 +54,11 @@ type Progs struct {
 }
 
 // newProgs returns a new Progs for fn.
-func newProgs(fn *Node) *Progs {
+func newProgs(fn *Node, shard int) *Progs {
 	pp := new(Progs)
 	if Ctxt.CanReuseProgs() {
-		pp.progcache = sharedProgArray[:]
+		sz := len(sharedProgArray) / ncpu
+		pp.progcache = sharedProgArray[sz*shard : sz*(shard+1)]
 	}
 	pp.curfn = fn
 
 
@@ -182,6 +182,7 @@ func Main(archInit func(*Arch)) {
 	obj.Flagcount("W", "debug parse tree after type checking", &Debug['W'])
 	flag.StringVar(&asmhdr, "asmhdr", "", "write assembly header to `file`")
 	flag.StringVar(&buildid, "buildid", "", "record `id` as the build id in the export metadata")
+	flag.IntVar(&ncpu, "c", 1, "number of concurrent backend compilations")
 	flag.BoolVar(&pure_go, "complete", false, "compiling complete package (no C or assembly)")
 	flag.StringVar(&debugstr, "d", "", "print debug information about items in `list`")
 	obj.Flagcount("e", "no limit on number of errors reported", &Debug['e'])
@@ -278,6 +279,13 @@ func Main(archInit func(*Arch)) {
 	if compiling_runtime && Debug['N'] != 0 {
 		log.Fatal("cannot disable optimizations while compiling runtime")
 	}
+	if ncpu < 1 {
+		log.Fatalf("-c must be at least 1, got %d", ncpu)
+	}
+	if ncpu > 1 && !concurrentBackendAllowed() {
+		log.Fatalf("cannot use concurrent backend compilation with provided flags")
+	}
+	compilenow = ncpu == 1
 
 	// parse -d argument
 	if debugstr != "" {
@@ -548,16 +556,39 @@ func Main(archInit func(*Arch)) {
 		}
 		timings.AddEvent(fcount, "funcs")
 
+		if ncpu > 1 {
+			for _, fn := range needscompile {
+				compilec <- fn
+			}
+			close(compilec)
+			needscompile = nil
+			compilewg.Wait()
+		}
+		// We autogenerate and compile some small functions
+		// such as method wrappers and equality/hash routines
+		// while exporting code.
+		// Disable concurrent compilation from here on,
+		// at least until this convoluted structure has been unwound.
+		ncpu = 1
+		compilenow = true
+
 		if nsavederrors+nerrors == 0 {
 			fninit(xtop)
 		}
 
 		if compiling_runtime {
 			checknowritebarrierrec()
 		}
-		for _, largePos := range largeStackFrames {
-			yyerrorl(largePos, "stack frame too large (>2GB)")
+		largeStackFramesMu.Lock()
+		if len(largeStackFrames) > 0 {
+			obj.SortSlice(largeStackFrames, func(i, j int) bool {
+				return largeStackFrames[i].Before(largeStackFrames[j])
+			})
+			for _, largePos := range largeStackFrames {
+				yyerrorl(largePos, "stack frame too large (>2GB)")
+			}
 		}
+		largeStackFramesMu.Unlock()
 	}
 
 	// Phase 9: Check external declarations.
@@ -1027,3 +1058,29 @@ func clearImports() {
 func IsAlias(sym *types.Sym) bool {
 	return sym.Def != nil && asNode(sym.Def).Sym != sym
 }
+
+// By default, assume any debug flags are incompatible with concurrent compilation.
+// A few are safe and potentially in common use for normal compiles, though; mark them as such here.
+var concurrentFlagOK = [256]bool{
+	'B': true, // disabled bounds checking
+	'C': true, // disable printing of columns in error messages
+	'I': true, // add `directory` to import search path
+	'N': true, // disable optimizations
+	'l': true, // disable inlining
+}
+
+func concurrentBackendAllowed() bool {
+	for i, x := range Debug {
+		if x != 0 && !concurrentFlagOK[i] {
+			return false
+		}
+	}
+	if Debug_asm || Debug_vlog || debugstr != "" || debuglive > 0 {
+		return false
+	}
+	// TODO: fix races and enable the following flags
+	if Ctxt.Flag_shared || Ctxt.Flag_dynlink || flag_race {
+		return false
+	}
+	return true
+}
@@ -219,6 +219,11 @@ func dumpglobls() {
 		ggloblnod(n)
 	}
 
+	funcsymsmu.Lock()
+	defer funcsymsmu.Unlock()
+	obj.SortSlice(funcsyms, func(i, j int) bool {
+		return linksymname(funcsyms[i]) < linksymname(funcsyms[j])
+	})
 	for _, s := range funcsyms {
 		sf := s.Pkg.Lookup(funcsymname(s))
 		dsymptr(sf, 0, s, 0)
@@ -264,6 +269,8 @@ func Linksym(s *types.Sym) *obj.LSym {
 	if s == nil {
 		return nil
 	}
+	s.Lsymmu.Lock()
+	defer s.Lsymmu.Unlock()
 	if s.Lsym == nil {
 		s.Lsym = Ctxt.Lookup(linksymname(s), 0)
 	}
 
@@ -13,10 +13,19 @@ import (
 	"cmd/internal/sys"
 	"fmt"
 	"sort"
+	"sync"
 )
 
 // "Portable" code generation.
 
+var (
+	ncpu         int            // the number of concurrent backend compiles, set by a compiler flag
+	needscompile []*Node        // slice of functions waiting to be compiled
+	compilenow   bool           // indicates whether to compile immediately or enqueue in needscompile
+	compilewg    sync.WaitGroup // wait for all backend compilers to complete
+	compilec     chan *Node     // channel of functions for backend compilers to drain
+)
+
 func emitptrargsmap() {
 	if Curfn.Func.Nname.Sym.Name == "_" {
 		return
@@ -210,9 +219,20 @@ func compile(fn *Node) {
 	// Set up the function's LSym early to avoid data races with the assemblers.
 	fn.Func.initLSym()
 
-	// Build an SSA backend function.
-	ssafn := buildssa(fn)
-	pp := newProgs(fn)
+	if compilenow {
+		compileSSA(fn, 0)
+	} else {
+		needscompile = append(needscompile, fn)
+	}
+}
+
+// compileSSA builds an SSA backend function,
+// uses it to generate a plist,
+// and flushes that plist to machine code.
+func compileSSA(fn *Node, shard int) {
+	cache := &ssaCaches[shard]
+	ssafn := buildssa(fn, cache)
+	pp := newProgs(fn, shard)
 	genssa(ssafn, pp)
 	fieldtrack(pp.Text.From.Sym, fn.Func.FieldTrack)
 	if pp.Text.To.Offset < 1<<31 {
 
@@ -13,6 +13,7 @@ import (
 	"os"
 	"sort"
 	"strings"
+	"sync"
 )
 
 type itabEntry struct {
@@ -35,9 +36,13 @@ type ptabEntry struct {
 }
 
 // runtime interface and reflection data structures
-var signatlist = make(map[*types.Type]bool)
-var itabs []itabEntry
-var ptabs []ptabEntry
+var (
+	signatlistmu sync.Mutex // protects signatlist
+	signatlist   = make(map[*types.Type]bool)
+
+	itabs []itabEntry
+	ptabs []ptabEntry
+)
 
 type Sig struct {
 	name   string
@@ -930,7 +935,9 @@ func typenamesym(t *types.Type) *types.Sym {
 		Fatalf("typenamesym %v", t)
 	}
 	s := typesym(t)
+	signatlistmu.Lock()
 	addsignat(t)
+	signatlistmu.Unlock()
 	return s
 }
 
@@ -1420,14 +1427,17 @@ func addsignat(t *types.Type) {
 
 func dumptypestructs() {
 	// copy types from externdcl list to signatlist
+	signatlistmu.Lock()
 	for _, n := range externdcl {
 		if n.Op == OTYPE {
 			addsignat(n.Type)
 		}
 	}
+	signatlistmu.Unlock()
 
 	// Process signatlist. Use a loop, as dtypesym adds
 	// entries to signatlist while it is being processed.
+	signatlistmu.Lock()
 	signats := make([]typeAndStr, len(signatlist))
 	for len(signatlist) > 0 {
 		signats = signats[:0]
@@ -1436,6 +1446,9 @@ func dumptypestructs() {
 			signats = append(signats, typeAndStr{t: t, s: typesymname(t)})
 			delete(signatlist, t)
 		}
+		// Don't hold signatlistmu while processing signats,
+		// since signats can generate new entries for signatlist.
+		signatlistmu.Unlock()
 		sort.Sort(typesByString(signats))
 		for _, ts := range signats {
 			t := ts.t
@@ -1444,7 +1457,9 @@ func dumptypestructs() {
 				dtypesym(types.NewPtr(t))
 			}
 		}
+		signatlistmu.Lock()
 	}
+	signatlistmu.Unlock()
 
 	// process itabs
 	for _, i := range itabs {
 
@@ -19,8 +19,10 @@ import (
 	"cmd/internal/sys"
 )
 
-var ssaConfig *ssa.Config
-var ssaCache *ssa.Cache
+var (
+	ssaConfig *ssa.Config
+	ssaCaches []ssa.Cache
+)
 
 func initssaconfig() {
 	types_ := ssa.Types{
@@ -66,7 +68,20 @@ func initssaconfig() {
 	if thearch.LinkArch.Name == "386" {
 		ssaConfig.Set387(thearch.Use387)
 	}
-	ssaCache = new(ssa.Cache)
+
+	ssaCaches = make([]ssa.Cache, ncpu)
+	if ncpu > 1 {
+		compilec = make(chan *Node)
+		for i := 0; i < ncpu; i++ {
+			compilewg.Add(1)
+			go func(shard int) {
+				for fn := range compilec {
+					compileSSA(fn, shard)
+				}
+				compilewg.Done()
+			}(i)
+		}
+	}
 
 	// Set up some runtime functions we'll need to call.
 	Newproc = Sysfunc("newproc")
@@ -88,7 +103,7 @@ func initssaconfig() {
 }
 
 // buildssa builds an SSA function.
-func buildssa(fn *Node) *ssa.Func {
+func buildssa(fn *Node, cache *ssa.Cache) *ssa.Func {
 	name := fn.Func.Nname.Sym.Name
 	printssa := name == os.Getenv("GOSSAFUNC")
 	if printssa {
@@ -116,7 +131,7 @@ func buildssa(fn *Node) *ssa.Func {
 	s.f = ssa.NewFunc(&fe)
 	s.config = ssaConfig
 	s.f.Config = ssaConfig
-	s.f.Cache = ssaCache
+	s.f.Cache = cache
 	s.f.Cache.Reset()
 	s.f.DebugTest = s.f.DebugHashMatch("GOSSAHASH", name)
 	s.f.Name = name
 
@@ -17,6 +17,7 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
 	"unicode"
 	"unicode/utf8"
 )
@@ -28,7 +29,10 @@ type Error struct {
 
 var errors []Error
 
-var largeStackFrames []src.XPos // positions of functions whose stack frames are too large (rare)
+var (
+	largeStackFramesMu sync.Mutex
+	largeStackFrames   []src.XPos // positions of functions whose stack frames are too large (rare)
+)
 
 func errorexit() {
 	flusherrors()
Original file line number	Diff line number	Diff line change
`@@ -1069,7 +1069,9 @@ func funcsym(s types.Sym) types.Sym {`
`1069`	`1069`	`// symbols will be created explicitly with makefuncsym.`
`1070`	`1070`	`// See the makefuncsym comment for details.`
`1071`	`1071`	`if !Ctxt.Flag_dynlink && !existed {`
	`1072`	`+ funcsymsmu.Lock()`
`1072`	`1073`	`funcsyms = append(funcsyms, s)`
	`1074`	`+ funcsymsmu.Unlock()`
`1073`	`1075`	`}`
`1074`	`1076`	`return sf`
`1075`	`1077`	`}`
`@@ -1096,7 +1098,9 @@ func makefuncsym(s *types.Sym) {`
`1096`	`1098`	`return`
`1097`	`1099`	`}`
`1098`	`1100`	`if _, existed := s.Pkg.LookupOK(funcsymname(s)); !existed {`
	`1101`	`+ funcsymsmu.Lock()`
`1099`	`1102`	`funcsyms = append(funcsyms, s)`
	`1103`	`+ funcsymsmu.Unlock()`
`1100`	`1104`	`}`
`1101`	`1105`	`}`
`1102`	`1106`
Original file line number	Diff line number	Diff line change
`@@ -54,10 +54,11 @@ type Progs struct {`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`// newProgs returns a new Progs for fn.`
`57`		`-func newProgs(fn Node) Progs {`
	`57`	`+func newProgs(fn Node, shard int) Progs {`
`58`	`58`	`pp := new(Progs)`
`59`	`59`	`if Ctxt.CanReuseProgs() {`
`60`		`- pp.progcache = sharedProgArray[:]`
	`60`	`+ sz := len(sharedProgArray) / ncpu`
	`61`	`+ pp.progcache = sharedProgArray[szshard : sz(shard+1)]`
`61`	`62`	`}`
`62`	`63`	`pp.curfn = fn`
`63`	`64`
Original file line number	Diff line number	Diff line change
`@@ -219,6 +219,11 @@ func dumpglobls() {`
`219`	`219`	`ggloblnod(n)`
`220`	`220`	`}`
`221`	`221`
	`222`	`+ funcsymsmu.Lock()`
	`223`	`+ defer funcsymsmu.Unlock()`
	`224`	`+ obj.SortSlice(funcsyms, func(i, j int) bool {`
	`225`	`+ return linksymname(funcsyms[i]) < linksymname(funcsyms[j])`
	`226`	`+ })`
`222`	`227`	`for _, s := range funcsyms {`
`223`	`228`	`sf := s.Pkg.Lookup(funcsymname(s))`
`224`	`229`	`dsymptr(sf, 0, s, 0)`
`@@ -264,6 +269,8 @@ func Linksym(s types.Sym) obj.LSym {`
`264`	`269`	`if s == nil {`
`265`	`270`	`return nil`
`266`	`271`	`}`
	`272`	`+ s.Lsymmu.Lock()`
	`273`	`+ defer s.Lsymmu.Unlock()`
`267`	`274`	`if s.Lsym == nil {`
`268`	`275`	`s.Lsym = Ctxt.Lookup(linksymname(s), 0)`
`269`	`276`	`}`