cmd/compile: ignore dead blocks during SSA construction

For golang#15537

Compiling github.com/gogo/protobuf/test/combos/both

Before:

       69.83 real        82.72 user         2.01 sys
4206456832  maximum resident set size

After:

       62.94 real        74.74 user         1.92 sys
3832225792  maximum resident set size


name       old time/op      new time/op      delta
Template        279ms ± 4%       277ms ± 4%    ~           (p=0.529 n=20+20)
Unicode         142ms ±10%       143ms ± 6%    ~           (p=0.461 n=20+20)
GoTypes         850ms ± 1%       846ms ± 2%    ~           (p=0.175 n=19+20)
Compiler        4.43s ± 2%       4.38s ± 1%  -1.12%        (p=0.000 n=19+20)

name       old user-ns/op   new user-ns/op   delta
Template   376user-ms ± 4%  378user-ms ± 3%    ~           (p=0.755 n=19+20)
Unicode    203user-ms ± 3%  205user-ms ± 8%    ~           (p=0.314 n=15+20)
GoTypes    1.15user-s ± 2%  1.15user-s ± 3%    ~           (p=0.799 n=20+20)
Compiler   6.14user-s ± 3%  6.12user-s ± 2%    ~           (p=0.547 n=20+20)

name       old alloc/op     new alloc/op     delta
Template       47.6MB ± 0%      46.9MB ± 0%  -1.41%        (p=0.000 n=19+20)
Unicode        37.1MB ± 0%      37.1MB ± 0%    ~           (p=0.134 n=20+20)
GoTypes         138MB ± 0%       136MB ± 0%  -1.65%        (p=0.000 n=20+20)
Compiler        632MB ± 0%       614MB ± 0%  -2.82%        (p=0.000 n=20+20)

name       old allocs/op    new allocs/op    delta
Template         445k ± 0%        444k ± 0%  -0.17%        (p=0.000 n=20+20)
Unicode          356k ± 0%        356k ± 0%    ~           (p=0.204 n=20+20)
GoTypes         1.25M ± 0%       1.25M ± 0%  -0.41%        (p=0.000 n=20+19)
Compiler        5.03M ± 0%       4.99M ± 0%  -0.87%        (p=0.000 n=19+20)


Change-Id: Iee7b56ede4c319e4194160502f0796f478a9b73f

Author: josharian

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

@@ -267,10 +267,11 @@ type state struct {
 	// symbols for PEXTERN, PAUTO and PPARAMOUT variables so they can be reused.
 	varsyms map[*Node]interface{}
 
-	// starting values. Memory, stack pointer, and globals pointer
+	// starting values. Memory, stack pointer, globals pointer, reusable dead value
 	startmem *ssa.Value
 	sp       *ssa.Value
 	sb       *ssa.Value
+	dead     *ssa.Value
 
 	// line number stack. The current line number is top of stack
 	line []int32
@@ -279,8 +280,8 @@ type state struct {
 	// Used to deduplicate panic calls.
 	panics map[funcLine]*ssa.Block
 
-	// list of FwdRef values.
-	fwdRefs []*ssa.Value
+	fwdRefs   []*ssa.Value // list of FwdRef values
+	reachable []bool       // reachable[b.ID] is whether b.ID is reachable; used during fwdRef resolution
 
 	// list of PPARAMOUT (return) variables. Does not include PPARAM|PHEAP vars.
 	returns []*Node
@@ -3741,6 +3742,13 @@ func (s *state) mem() *ssa.Value {
 	return s.variable(&memVar, ssa.TypeMem)
 }
 
+func (s *state) deadval() *ssa.Value {
+	if s.dead == nil {
+		s.dead = s.entryNewValue0(ssa.OpUnknown, nil) // type doesn't matter
+	}
+	return s.dead
+}
+
 func (s *state) linkForwardReferences() {
 	// Build SSA graph. Each variable on its first use in a basic block
 	// leaves a FwdRef in that block representing the incoming value
@@ -3753,11 +3761,19 @@ func (s *state) linkForwardReferences() {
 	//     completely built. That way we can avoid the notion of "sealed"
 	//     blocks.
 	//   - Phi optimization is a separate pass (in ../ssa/phielim.go).
+	s.reachable = ssa.ReachableBlocks(s.f)
 	for len(s.fwdRefs) > 0 {
 		v := s.fwdRefs[len(s.fwdRefs)-1]
 		s.fwdRefs = s.fwdRefs[:len(s.fwdRefs)-1]
-		s.resolveFwdRef(v)
+		if s.reachable[v.Block.ID] {
+			s.resolveFwdRef(v)
+		} else {
+			v.Op = ssa.OpUnknown
+			v.Aux = nil
+			v.AuxInt = 0
+		}
 	}
+	s.reachable = nil
 }
 
 // resolveFwdRef modifies v to be the variable's value at the start of its block.
@@ -3814,6 +3830,9 @@ func (s *state) resolveFwdRef(v *ssa.Value) {
 		if a == w {
 			continue // already have this witness
 		}
+		if a.Op == ssa.OpUnknown {
+			continue // dead value, ignore
+		}
 		if w != nil {
 			// two witnesses, need a phi value
 			v.Op = ssa.OpPhi
@@ -3837,6 +3856,10 @@ func (s *state) lookupVarOutgoing(b *ssa.Block, t ssa.Type, name *Node, line int
 			return v
 		}
 		// The variable is not defined by b and we haven't looked it up yet.
+		// If b is dead, don't bother, just return a (re-usable) placeholder.
+		if !s.reachable[b.ID] {
+			return s.deadval()
+		}
 		// If b has exactly one predecessor, loop to look it up there.
 		// Otherwise, give up and insert a new FwdRef and resolve it later.
 		if len(b.Preds) != 1 {

src/cmd/compile/internal/ssa/deadcode.go

@@ -6,13 +6,13 @@ package ssa
 
 // findlive returns the reachable blocks and live values in f.
 func findlive(f *Func) (reachable []bool, live []bool) {
-	reachable = reachableBlocks(f)
+	reachable = ReachableBlocks(f)
 	live = liveValues(f, reachable)
 	return
 }
 
-// reachableBlocks returns the reachable blocks in f.
-func reachableBlocks(f *Func) []bool {
+// ReachableBlocks returns the reachable blocks in f.
+func ReachableBlocks(f *Func) []bool {
 	reachable := make([]bool, f.NumBlocks())
 	reachable[f.Entry.ID] = true
 	p := []*Block{f.Entry} // stack-like worklist
@@ -94,7 +94,7 @@ func deadcode(f *Func) {
 	}
 
 	// Find reachable blocks.
-	reachable := reachableBlocks(f)
+	reachable := ReachableBlocks(f)
 
 	// Get rid of edges from dead to live code.
 	for _, b := range f.Blocks {

src/cmd/compile/internal/ssa/html.go

@@ -352,7 +352,9 @@ func (v *Value) LongHTML() string {
 	// maybe we could replace some of that with formatting.
 	s := fmt.Sprintf("<span class=\"%s ssa-long-value\">", v.String())
 	s += fmt.Sprintf("%s = %s", v.HTML(), v.Op.String())
-	s += " &lt;" + html.EscapeString(v.Type.String()) + "&gt;"
+	if v.Type != nil {
+		s += " &lt;" + html.EscapeString(v.Type.String()) + "&gt;"
+	}
 	s += html.EscapeString(v.auxString())
 	for _, a := range v.Args {
 		s += fmt.Sprintf(" %s", a.HTML())