cmd/compile: reduce rulegen's output by 200 KiB

First, renove unnecessary "// cond:" lines from the generated files.
This shaves off about ~7k lines.

Second, join "if cond { break }" statements via "||", which allows us to
deduplicate a large number of them. This shaves off another ~25k lines.

This change is not for readability or simplicity; but rather, to avoid
unnecessary verbosity that makes the generated files larger. All in all,
git reports that the generated files overall weigh ~200KiB less, or
about 2.7% less.

While at it, add a -trace flag to rulegen.

Updates #33644.

Change-Id: I3fac0290a6066070cc62400bf970a4ae0929470a
Reviewed-on: https://go-review.googlesource.com/c/go/+/196498
Run-TryBot: Daniel Martí <[email protected]>
TryBot-Result: Gobot Gobot <[email protected]>
Reviewed-by: Keith Randall <[email protected]>

Author: mvdan

src/cmd/compile/internal/ssa/gen/main.go

@@ -20,6 +20,7 @@ import (
 	"regexp"
 	"runtime"
 	"runtime/pprof"
+	"runtime/trace"
 	"sort"
 	"strings"
 	"sync"
@@ -101,6 +102,7 @@ var archs []arch
 
 var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to `file`")
 var memprofile = flag.String("memprofile", "", "write memory profile to `file`")
+var tracefile = flag.String("trace", "", "write trace to `file`")
 
 func main() {
 	flag.Parse()
@@ -115,6 +117,23 @@ func main() {
 		}
 		defer pprof.StopCPUProfile()
 	}
+	if *tracefile != "" {
+		f, err := os.Create(*tracefile)
+		if err != nil {
+			log.Fatalf("failed to create trace output file: %v", err)
+		}
+		defer func() {
+			if err := f.Close(); err != nil {
+				log.Fatalf("failed to close trace file: %v", err)
+			}
+		}()
+
+		if err := trace.Start(f); err != nil {
+			log.Fatalf("failed to start trace: %v", err)
+		}
+		defer trace.Stop()
+	}
+
 	sort.Sort(ArchsByName(archs))
 
 	// The generate tasks are run concurrently, since they are CPU-intensive

src/cmd/compile/internal/ssa/gen/rulegen.go

@@ -587,7 +587,9 @@ func fprint(w io.Writer, n Node) {
 		}
 	case *RuleRewrite:
 		fmt.Fprintf(w, "// match: %s\n", n.match)
-		fmt.Fprintf(w, "// cond: %s\n", n.cond)
+		if n.cond != "" {
+			fmt.Fprintf(w, "// cond: %s\n", n.cond)
+		}
 		fmt.Fprintf(w, "// result: %s\n", n.result)
 		if n.checkOp != "" {
 			fmt.Fprintf(w, "for v.Op == %s {\n", n.checkOp)
@@ -636,13 +638,26 @@ type bodyBase struct {
 	canFail bool
 }
 
-func (w *bodyBase) add(nodes ...Statement) {
-	w.list = append(w.list, nodes...)
-	for _, node := range nodes {
-		if _, ok := node.(*CondBreak); ok {
-			w.canFail = true
+func (w *bodyBase) add(node Statement) {
+	var last Statement
+	if len(w.list) > 0 {
+		last = w.list[len(w.list)-1]
+	}
+	if node, ok := node.(*CondBreak); ok {
+		w.canFail = true
+		if last, ok := last.(*CondBreak); ok {
+			// Add to the previous "if <cond> { break }" via a
+			// logical OR, which will save verbosity.
+			last.expr = &ast.BinaryExpr{
+				Op: token.LOR,
+				X:  last.expr,
+				Y:  node.expr,
+			}
+			return
 		}
 	}
+
+	w.list = append(w.list, node)
 }
 
 // declared reports if the body contains a Declare with the given name.