2 files changed, 315 insertions, 0 deletions
diff --git a/src/cmd/internal/pkgpath/pkgpath.go b/src/cmd/internal/pkgpath/pkgpath.go
new file mode 100644
index 0000000..72e3bdb
--- /dev/null
+++ b/src/cmd/internal/pkgpath/pkgpath.go
@@ -0,0 +1,174 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package pkgpath determines the package path used by gccgo/GoLLVM symbols.
+// This package is not used for the gc compiler.
+package pkgpath
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	exec "internal/execabs"
+	"io/ioutil"
+	"os"
+	"strings"
+)
+
+// ToSymbolFunc returns a function that may be used to convert a
+// package path into a string suitable for use as a symbol.
+// cmd is the gccgo/GoLLVM compiler in use, and tmpdir is a temporary
+// directory to pass to ioutil.TempFile.
+// For example, this returns a function that converts "net/http"
+// into a string like "net..z2fhttp". The actual string varies for
+// different gccgo/GoLLVM versions, which is why this returns a function
+// that does the conversion appropriate for the compiler in use.
+func ToSymbolFunc(cmd, tmpdir string) (func(string) string, error) {
+	// To determine the scheme used by cmd, we compile a small
+	// file and examine the assembly code. Older versions of gccgo
+	// use a simple mangling scheme where there can be collisions
+	// between packages whose paths are different but mangle to
+	// the same string. More recent versions use a new mangler
+	// that avoids these collisions.
+	const filepat = "*_gccgo_manglechck.go"
+	f, err := ioutil.TempFile(tmpdir, filepat)
+	if err != nil {
+		return nil, err
+	}
+	gofilename := f.Name()
+	f.Close()
+	defer os.Remove(gofilename)
+
+	if err := ioutil.WriteFile(gofilename, []byte(mangleCheckCode), 0644); err != nil {
+		return nil, err
+	}
+
+	command := exec.Command(cmd, "-S", "-o", "-", gofilename)
+	buf, err := command.Output()
+	if err != nil {
+		return nil, err
+	}
+
+	// Original mangling: go.l__ufer.Run
+	// Mangling v2: go.l..u00e4ufer.Run
+	// Mangling v3: go_0l_u00e4ufer.Run
+	if bytes.Contains(buf, []byte("go_0l_u00e4ufer.Run")) {
+		return toSymbolV3, nil
+	} else if bytes.Contains(buf, []byte("go.l..u00e4ufer.Run")) {
+		return toSymbolV2, nil
+	} else if bytes.Contains(buf, []byte("go.l__ufer.Run")) {
+		return toSymbolV1, nil
+	} else {
+		return nil, errors.New(cmd + ": unrecognized mangling scheme")
+	}
+}
+
+// mangleCheckCode is the package we compile to determine the mangling scheme.
+const mangleCheckCode = `
+package läufer
+func Run(x int) int {
+  return 1
+}
+`
+
+// toSymbolV1 converts a package path using the original mangling scheme.
+func toSymbolV1(ppath string) string {
+	clean := func(r rune) rune {
+		switch {
+		case 'A' <= r && r <= 'Z', 'a' <= r && r <= 'z',
+			'0' <= r && r <= '9':
+			return r
+		}
+		return '_'
+	}
+	return strings.Map(clean, ppath)
+}
+
+// toSymbolV2 converts a package path using the second mangling scheme.
+func toSymbolV2(ppath string) string {
+	// This has to build at boostrap time, so it has to build
+	// with Go 1.4, so we don't use strings.Builder.
+	bsl := make([]byte, 0, len(ppath))
+	changed := false
+	for _, c := range ppath {
+		if ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9') || c == '_' {
+			bsl = append(bsl, byte(c))
+			continue
+		}
+		var enc string
+		switch {
+		case c == '.':
+			enc = ".x2e"
+		case c < 0x80:
+			enc = fmt.Sprintf("..z%02x", c)
+		case c < 0x10000:
+			enc = fmt.Sprintf("..u%04x", c)
+		default:
+			enc = fmt.Sprintf("..U%08x", c)
+		}
+		bsl = append(bsl, enc...)
+		changed = true
+	}
+	if !changed {
+		return ppath
+	}
+	return string(bsl)
+}
+
+// v3UnderscoreCodes maps from a character that supports an underscore
+// encoding to the underscore encoding character.
+var v3UnderscoreCodes = map[byte]byte{
+	'_': '_',
+	'.': '0',
+	'/': '1',
+	'*': '2',
+	',': '3',
+	'{': '4',
+	'}': '5',
+	'[': '6',
+	']': '7',
+	'(': '8',
+	')': '9',
+	'"': 'a',
+	' ': 'b',
+	';': 'c',
+}
+
+// toSymbolV3 converts a package path using the third mangling scheme.
+func toSymbolV3(ppath string) string {
+	// This has to build at boostrap time, so it has to build
+	// with Go 1.4, so we don't use strings.Builder.
+	bsl := make([]byte, 0, len(ppath))
+	changed := false
+	for _, c := range ppath {
+		if ('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z') || ('0' <= c && c <= '9') {
+			bsl = append(bsl, byte(c))
+			continue
+		}
+
+		if c < 0x80 {
+			if u, ok := v3UnderscoreCodes[byte(c)]; ok {
+				bsl = append(bsl, '_', u)
+				changed = true
+				continue
+			}
+		}
+
+		var enc string
+		switch {
+		case c < 0x80:
+			enc = fmt.Sprintf("_x%02x", c)
+		case c < 0x10000:
+			enc = fmt.Sprintf("_u%04x", c)
+		default:
+			enc = fmt.Sprintf("_U%08x", c)
+		}
+		bsl = append(bsl, enc...)
+		changed = true
+	}
+	if !changed {
+		return ppath
+	}
+	return string(bsl)
+}
diff --git a/src/cmd/internal/pkgpath/pkgpath_test.go b/src/cmd/internal/pkgpath/pkgpath_test.go
new file mode 100644
index 0000000..232e803
--- /dev/null
+++ b/src/cmd/internal/pkgpath/pkgpath_test.go
@@ -0,0 +1,141 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pkgpath
+
+import (
+	"os"
+	"testing"
+)
+
+const testEnvName = "GO_PKGPATH_TEST_COMPILER"
+
+// This init function supports TestToSymbolFunc. For simplicity,
+// we use the test binary itself as a sample gccgo driver.
+// We set an environment variable to specify how it should behave.
+func init() {
+	switch os.Getenv(testEnvName) {
+	case "":
+		return
+	case "v1":
+		os.Stdout.WriteString(`.string	"go.l__ufer.Run"`)
+		os.Exit(0)
+	case "v2":
+		os.Stdout.WriteString(`.string	"go.l..u00e4ufer.Run"`)
+		os.Exit(0)
+	case "v3":
+		os.Stdout.WriteString(`.string	"go_0l_u00e4ufer.Run"`)
+		os.Exit(0)
+	case "error":
+		os.Stdout.WriteString(`unknown string`)
+		os.Exit(0)
+	}
+}
+
+func TestToSymbolFunc(t *testing.T) {
+	const input = "pä世🜃"
+	tests := []struct {
+		env     string
+		fail    bool
+		mangled string
+	}{
+		{
+			env:     "v1",
+			mangled: "p___",
+		},
+		{
+			env:     "v2",
+			mangled: "p..u00e4..u4e16..U0001f703",
+		},
+		{
+			env:     "v3",
+			mangled: "p_u00e4_u4e16_U0001f703",
+		},
+		{
+			env:  "error",
+			fail: true,
+		},
+	}
+
+	cmd := os.Args[0]
+	tmpdir := t.TempDir()
+
+	defer os.Unsetenv(testEnvName)
+
+	for _, test := range tests {
+		t.Run(test.env, func(t *testing.T) {
+			os.Setenv(testEnvName, test.env)
+
+			fn, err := ToSymbolFunc(cmd, tmpdir)
+			if err != nil {
+				if !test.fail {
+					t.Errorf("ToSymbolFunc(%q, %q): unexpected error %v", cmd, tmpdir, err)
+				}
+			} else if test.fail {
+				t.Errorf("ToSymbolFunc(%q, %q) succeeded but expected to fail", cmd, tmpdir)
+			} else if got, want := fn(input), test.mangled; got != want {
+				t.Errorf("ToSymbolFunc(%q, %q)(%q) = %q, want %q", cmd, tmpdir, input, got, want)
+			}
+		})
+	}
+}
+
+var symbolTests = []struct {
+	input, v1, v2, v3 string
+}{
+	{
+		"",
+		"",
+		"",
+		"",
+	},
+	{
+		"bytes",
+		"bytes",
+		"bytes",
+		"bytes",
+	},
+	{
+		"net/http",
+		"net_http",
+		"net..z2fhttp",
+		"net_1http",
+	},
+	{
+		"golang.org/x/net/http",
+		"golang_org_x_net_http",
+		"golang.x2eorg..z2fx..z2fnet..z2fhttp",
+		"golang_0org_1x_1net_1http",
+	},
+	{
+		"pä世.🜃",
+		"p____",
+		"p..u00e4..u4e16.x2e..U0001f703",
+		"p_u00e4_u4e16_0_U0001f703",
+	},
+}
+
+func TestV1(t *testing.T) {
+	for _, test := range symbolTests {
+		if got, want := toSymbolV1(test.input), test.v1; got != want {
+			t.Errorf("toSymbolV1(%q) = %q, want %q", test.input, got, want)
+		}
+	}
+}
+
+func TestV2(t *testing.T) {
+	for _, test := range symbolTests {
+		if got, want := toSymbolV2(test.input), test.v2; got != want {
+			t.Errorf("toSymbolV2(%q) = %q, want %q", test.input, got, want)
+		}
+	}
+}
+
+func TestV3(t *testing.T) {
+	for _, test := range symbolTests {
+		if got, want := toSymbolV3(test.input), test.v3; got != want {
+			t.Errorf("toSymbolV3(%q) = %q, want %q", test.input, got, want)
+		}
+	}
+}