cmd/compile,cmd/internal/objabi: move -d flag parser to objabi

This moves and slightly generalizes the -d debug flag parser from
cmd/compile/internal/base to cmd/internal/objabi so that we can use
the same debug flag syntax in other tools.

This makes a few minor tweaks to implementation details. The flag
itself is now just a flag.Value that gets constructed explicitly,
rather than at init time, and we've cleaned up the implementation a
little (e.g., using a map instead of a linear search of a slice). The
help text is now automatically alphabetized. Rather than describing
the values of some flags in the help text footer, we simply include it
in the flags' help text and make sure multi-line help text renders
sensibly.

For #48297.

Change-Id: Id373ee3b767e456be483fb28c110d025149be532
Reviewed-on: https://go-review.googlesource.com/c/go/+/359956
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>

1 files changed, 164 insertions, 0 deletions

diff --git a/src/cmd/internal/objabi/flag.go b/src/cmd/internal/objabi/flag.go
index e41fc570b0..f75c054fcb 100644
--- a/src/cmd/internal/objabi/flag.go
+++ b/src/cmd/internal/objabi/flag.go
@@ -13,6 +13,8 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
+	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 )
@@ -202,3 +204,165 @@ func DecodeArg(arg string) string {
 	}
 	return b.String()
 }
+
+type debugField struct {
+	name string
+	help string
+	val  interface{} // *int or *string
+}
+
+type DebugFlag struct {
+	tab map[string]debugField
+	any *bool
+
+	debugSSA DebugSSA
+}
+
+// A DebugSSA function is called to set a -d ssa/... option.
+// If nil, those options are reported as invalid options.
+// If DebugSSA returns a non-empty string, that text is reported as a compiler error.
+// If phase is "help", it should print usage information and terminate the process.
+type DebugSSA func(phase, flag string, val int, valString string) string
+
+// NewDebugFlag constructs a DebugFlag for the fields of debug, which
+// must be a pointer to a struct.
+//
+// Each field of *debug is a different value, named for the lower-case of the field name.
+// Each field must be an int or string and must have a `help` struct tag.
+// There may be an "Any bool" field, which will be set if any debug flags are set.
+//
+// The returned flag takes a comma-separated list of settings.
+// Each setting is name=value; for ints, name is short for name=1.
+//
+// If debugSSA is non-nil, any debug flags of the form ssa/... will be
+// passed to debugSSA for processing.
+func NewDebugFlag(debug interface{}, debugSSA DebugSSA) *DebugFlag {
+	flag := &DebugFlag{
+		tab:      make(map[string]debugField),
+		debugSSA: debugSSA,
+	}
+
+	v := reflect.ValueOf(debug).Elem()
+	t := v.Type()
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		ptr := v.Field(i).Addr().Interface()
+		if f.Name == "Any" {
+			switch ptr := ptr.(type) {
+			default:
+				panic("debug.Any must have type bool")
+			case *bool:
+				flag.any = ptr
+			}
+			continue
+		}
+		name := strings.ToLower(f.Name)
+		help := f.Tag.Get("help")
+		if help == "" {
+			panic(fmt.Sprintf("debug.%s is missing help text", f.Name))
+		}
+		switch ptr.(type) {
+		default:
+			panic(fmt.Sprintf("debug.%s has invalid type %v (must be int or string)", f.Name, f.Type))
+		case *int, *string:
+			// ok
+		}
+		flag.tab[name] = debugField{name, help, ptr}
+	}
+
+	return flag
+}
+
+func (f *DebugFlag) Set(debugstr string) error {
+	if debugstr == "" {
+		return nil
+	}
+	if f.any != nil {
+		*f.any = true
+	}
+	for _, name := range strings.Split(debugstr, ",") {
+		if name == "" {
+			continue
+		}
+		// display help about the debug option itself and quit
+		if name == "help" {
+			fmt.Print(debugHelpHeader)
+			maxLen, names := 0, []string{}
+			if f.debugSSA != nil {
+				maxLen = len("ssa/help")
+			}
+			for name := range f.tab {
+				if len(name) > maxLen {
+					maxLen = len(name)
+				}
+				names = append(names, name)
+			}
+			sort.Strings(names)
+			// Indent multi-line help messages.
+			nl := fmt.Sprintf("\n\t%-*s\t", maxLen, "")
+			for _, name := range names {
+				help := f.tab[name].help
+				fmt.Printf("\t%-*s\t%s\n", maxLen, name, strings.Replace(help, "\n", nl, -1))
+			}
+			if f.debugSSA != nil {
+				// ssa options have their own help
+				fmt.Printf("\t%-*s\t%s\n", maxLen, "ssa/help", "print help about SSA debugging")
+			}
+			os.Exit(0)
+		}
+
+		val, valstring, haveInt := 1, "", true
+		if i := strings.IndexAny(name, "=:"); i >= 0 {
+			var err error
+			name, valstring = name[:i], name[i+1:]
+			val, err = strconv.Atoi(valstring)
+			if err != nil {
+				val, haveInt = 1, false
+			}
+		}
+
+		if t, ok := f.tab[name]; ok {
+			switch vp := t.val.(type) {
+			case nil:
+				// Ignore
+			case *string:
+				*vp = valstring
+			case *int:
+				if !haveInt {
+					log.Fatalf("invalid debug value %v", name)
+				}
+				*vp = val
+			default:
+				panic("bad debugtab type")
+			}
+		} else if f.debugSSA != nil && strings.HasPrefix(name, "ssa/") {
+			// expect form ssa/phase/flag
+			// e.g. -d=ssa/generic_cse/time
+			// _ in phase name also matches space
+			phase := name[4:]
+			flag := "debug" // default flag is debug
+			if i := strings.Index(phase, "/"); i >= 0 {
+				flag = phase[i+1:]
+				phase = phase[:i]
+			}
+			err := f.debugSSA(phase, flag, val, valstring)
+			if err != "" {
+				log.Fatalf(err)
+			}
+		} else {
+			return fmt.Errorf("unknown debug key %s\n", name)
+		}
+	}
+
+	return nil
+}
+
+const debugHelpHeader = `usage: -d arg[,arg]* and arg is <key>[=<value>]
+
+<key> is one of:
+
+`
+
+func (f *DebugFlag) String() string {
+	return ""
+}