Windows: don't use CommandLineToArgv to get os.Args

CommandLineToArgV is hosted in shell32.dll, which is very expensive to
load. Most go programs never need to load shell32.dll for any other reason
than to call this function, so implement the same algorithm directly.

This reduces simple process startup time from 22ms to 16ms on my machine.

Author: jstarks

src/os/exec_windows.go

@@ -10,6 +10,7 @@ import (
 	"sync/atomic"
 	"syscall"
 	"time"
+	"unicode/utf16"
 	"unsafe"
 )
 
@@ -94,17 +95,87 @@ func findProcess(pid int) (p *Process, err error) {
 	return newProcess(pid, uintptr(h)), nil
 }
 
-func init() {
-	var argc int32
-	cmd := syscall.GetCommandLine()
-	argv, e := syscall.CommandLineToArgv(cmd, &argc)
-	if e != nil {
-		return
+func isCmdSpace(c byte) bool {
+	return c == ' ' || c == '\t'
+}
+
+// CommandLineToArgv splits a command line into individual argument strings, following the
+// Windows conventions documented at https://msdn.microsoft.com/en-us/library/17w5ykft.aspx.
+func CommandLineToArgv(cmd string) []string {
+	var argv []string
+	i := 0
+	for {
+		for i < len(cmd) && isCmdSpace(cmd[i]) {
+			i++
+		}
+		if i == len(cmd) {
+			break
+		}
+
+		var arg []byte
+		inquote := false
+		for {
+			nslash := 0
+			for i < len(cmd) && cmd[i] == '\\' {
+				i++
+				nslash++
+			}
+
+			if i < len(cmd) && cmd[i] == '"' {
+				for s := 0; s < nslash/2; s++ {
+					arg = append(arg, '\\')
+				}
+
+				if nslash%2 == 0 {
+					inquote = !inquote
+					// Special case: if the next character is also a quote,
+					// then this quote gets included.
+					if !inquote && i+1 < len(cmd) && cmd[i+1] == '"' {
+						arg = append(arg, '"')
+						i++
+					}
+				} else {
+					arg = append(arg, '"')
+				}
+			} else {
+				for nslash > 0 {
+					arg = append(arg, '\\')
+					nslash--
+				}
+
+				if i == len(cmd) || (!inquote && isCmdSpace(cmd[i])) {
+					break
+				}
+
+				arg = append(arg, cmd[i])
+			}
+
+			i++
+		}
+
+		argv = append(argv, string(arg))
 	}
-	defer syscall.LocalFree(syscall.Handle(uintptr(unsafe.Pointer(argv))))
-	Args = make([]string, argc)
-	for i, v := range (*argv)[:argc] {
-		Args[i] = syscall.UTF16ToString((*v)[:])
+	return argv
+}
+
+func init() {
+	cmd := syscall.UTF16ToString((*[0xffff]uint16)(unsafe.Pointer(syscall.GetCommandLine()))[:])
+
+	if len(cmd) != 0 {
+		Args = CommandLineToArgv(cmd)
+	} else {
+		// No command line was provided, so get argv[0] from the module name.
+		dll := syscall.MustLoadDLL("kernel32.dll")
+		defer dll.Release()
+		fn := dll.MustFindProc("GetModuleFileNameW")
+
+		p := make([]uint16, syscall.MAX_PATH)
+		r, _, err := fn.Call(0, uintptr(unsafe.Pointer(&p[0])), uintptr(len(p)))
+		n := uint32(r)
+		if n == 0 || n >= uint32(len(p)) {
+			panic(err)
+		}
+		Args = []string{string(utf16.Decode(p[:n]))}
 	}
 }
 

src/os/exec_windows_test.go

@@ -0,0 +1,55 @@
+package os_test
+
+import (
+	. "os"
+	"syscall"
+	"testing"
+	"unsafe"
+)
+
+func TestCommandLineToArgv(t *testing.T) {
+	cmds := []string{
+		`test`,
+		`test a b c`,
+		`test "`,
+		`test ""`,
+		`test """`,
+		`test "" a`,
+		`test "123"`,
+		`test \"123\"`,
+		`test \"123 456\"`,
+		`test \\"`,
+		`test \\\"`,
+		`test \\\\\"`,
+		`test \\\"x`,
+		`test """"\""\\\"`,
+		`"cmd line" abc`,
+		`test \\\\\""x"""y z`,
+		"test\tb\t\"x\ty\"",
+	}
+
+	for _, cmd := range cmds {
+		var argc int32
+		c, err := syscall.CommandLineToArgv(&syscall.StringToUTF16(cmd)[0], &argc)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		out := CommandLineToArgv(cmd)
+		outwin := make([]string, len(out))
+
+		valid := len(outwin) == len(out)
+		for i := range outwin {
+			outwin[i] = syscall.UTF16ToString(c[i][:])
+			if i < len(out) && out[i] != outwin[i] {
+				valid = false
+			}
+		}
+
+		if !valid {
+			t.Errorf("%#v: %#v vs %#v", cmd, out, outwin)
+		}
+
+		syscall.LocalFree(syscall.Handle(unsafe.Pointer(c)))
+	}
+}