Adding upstream version 1.18.10.upstream/1.18.10upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

4 files changed, 435 insertions, 0 deletions

diff --git a/src/cmd/internal/sys/arch.go b/src/cmd/internal/sys/arch.go
new file mode 100644
index 0000000..ea76b59
--- /dev/null
+++ b/src/cmd/internal/sys/arch.go
@@ -0,0 +1,237 @@
+// Copyright 2016 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 sys
+
+import "encoding/binary"
+
+// ArchFamily represents a family of one or more related architectures.
+// For example, ppc64 and ppc64le are both members of the PPC64 family.
+type ArchFamily byte
+
+const (
+	NoArch ArchFamily = iota
+	AMD64
+	ARM
+	ARM64
+	I386
+	Loong64
+	MIPS
+	MIPS64
+	PPC64
+	RISCV64
+	S390X
+	Wasm
+)
+
+// Arch represents an individual architecture.
+type Arch struct {
+	Name   string
+	Family ArchFamily
+
+	ByteOrder binary.ByteOrder
+
+	// PtrSize is the size in bytes of pointers and the
+	// predeclared "int", "uint", and "uintptr" types.
+	PtrSize int
+
+	// RegSize is the size in bytes of general purpose registers.
+	RegSize int
+
+	// MinLC is the minimum length of an instruction code.
+	MinLC int
+
+	// Alignment is maximum alignment required by the architecture
+	// for any (compiler-generated) load or store instruction.
+	// Loads or stores smaller than Alignment must be naturally aligned.
+	// Loads or stores larger than Alignment need only be Alignment-aligned.
+	Alignment int8
+
+	// CanMergeLoads reports whether the backend optimization passes
+	// can combine adjacent loads into a single larger, possibly unaligned, load.
+	// Note that currently the optimizations must be able to handle little endian byte order.
+	CanMergeLoads bool
+}
+
+// InFamily reports whether a is a member of any of the specified
+// architecture families.
+func (a *Arch) InFamily(xs ...ArchFamily) bool {
+	for _, x := range xs {
+		if a.Family == x {
+			return true
+		}
+	}
+	return false
+}
+
+var Arch386 = &Arch{
+	Name:          "386",
+	Family:        I386,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       4,
+	RegSize:       4,
+	MinLC:         1,
+	Alignment:     1,
+	CanMergeLoads: true,
+}
+
+var ArchAMD64 = &Arch{
+	Name:          "amd64",
+	Family:        AMD64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         1,
+	Alignment:     1,
+	CanMergeLoads: true,
+}
+
+var ArchARM = &Arch{
+	Name:          "arm",
+	Family:        ARM,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       4,
+	RegSize:       4,
+	MinLC:         4,
+	Alignment:     4, // TODO: just for arm5?
+	CanMergeLoads: false,
+}
+
+var ArchARM64 = &Arch{
+	Name:          "arm64",
+	Family:        ARM64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     1,
+	CanMergeLoads: true,
+}
+
+var ArchLoong64 = &Arch{
+	Name:          "loong64",
+	Family:        Loong64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     8, // Unaligned accesses are not guaranteed to be fast
+	CanMergeLoads: false,
+}
+
+var ArchMIPS = &Arch{
+	Name:          "mips",
+	Family:        MIPS,
+	ByteOrder:     binary.BigEndian,
+	PtrSize:       4,
+	RegSize:       4,
+	MinLC:         4,
+	Alignment:     4,
+	CanMergeLoads: false,
+}
+
+var ArchMIPSLE = &Arch{
+	Name:          "mipsle",
+	Family:        MIPS,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       4,
+	RegSize:       4,
+	MinLC:         4,
+	Alignment:     4,
+	CanMergeLoads: false,
+}
+
+var ArchMIPS64 = &Arch{
+	Name:          "mips64",
+	Family:        MIPS64,
+	ByteOrder:     binary.BigEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     8,
+	CanMergeLoads: false,
+}
+
+var ArchMIPS64LE = &Arch{
+	Name:          "mips64le",
+	Family:        MIPS64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     8,
+	CanMergeLoads: false,
+}
+
+var ArchPPC64 = &Arch{
+	Name:          "ppc64",
+	Family:        PPC64,
+	ByteOrder:     binary.BigEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     1,
+	CanMergeLoads: false,
+}
+
+var ArchPPC64LE = &Arch{
+	Name:          "ppc64le",
+	Family:        PPC64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     1,
+	CanMergeLoads: true,
+}
+
+var ArchRISCV64 = &Arch{
+	Name:          "riscv64",
+	Family:        RISCV64,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         4,
+	Alignment:     8, // riscv unaligned loads work, but are really slow (trap + simulated by OS)
+	CanMergeLoads: false,
+}
+
+var ArchS390X = &Arch{
+	Name:          "s390x",
+	Family:        S390X,
+	ByteOrder:     binary.BigEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         2,
+	Alignment:     1,
+	CanMergeLoads: true,
+}
+
+var ArchWasm = &Arch{
+	Name:          "wasm",
+	Family:        Wasm,
+	ByteOrder:     binary.LittleEndian,
+	PtrSize:       8,
+	RegSize:       8,
+	MinLC:         1,
+	Alignment:     1,
+	CanMergeLoads: false,
+}
+
+var Archs = [...]*Arch{
+	Arch386,
+	ArchAMD64,
+	ArchARM,
+	ArchARM64,
+	ArchLoong64,
+	ArchMIPS,
+	ArchMIPSLE,
+	ArchMIPS64,
+	ArchMIPS64LE,
+	ArchPPC64,
+	ArchPPC64LE,
+	ArchRISCV64,
+	ArchS390X,
+	ArchWasm,
+}
diff --git a/src/cmd/internal/sys/args.go b/src/cmd/internal/sys/args.go
new file mode 100644
index 0000000..cc9fb64
--- /dev/null
+++ b/src/cmd/internal/sys/args.go
@@ -0,0 +1,13 @@
+// Copyright 2021 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 sys
+
+// ExecArgLengthLimit is the number of bytes we can safely
+// pass as arguments to an exec.Command.
+//
+// Windows has a limit of 32 KB. To be conservative and not worry about whether
+// that includes spaces or not, just use 30 KB. Darwin's limit is less clear.
+// The OS claims 256KB, but we've seen failures with arglen as small as 50KB.
+const ExecArgLengthLimit = (30 << 10)
diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go
new file mode 100644
index 0000000..82b6551
--- /dev/null
+++ b/src/cmd/internal/sys/supported.go
@@ -0,0 +1,167 @@
+// Copyright 2018 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 sys
+
+// RaceDetectorSupported reports whether goos/goarch supports the race
+// detector. There is a copy of this function in cmd/dist/test.go.
+// Race detector only supports 48-bit VMA on arm64. But it will always
+// return true for arm64, because we don't have VMA size information during
+// the compile time.
+func RaceDetectorSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64"
+	case "darwin":
+		return goarch == "amd64" || goarch == "arm64"
+	case "freebsd", "netbsd", "openbsd", "windows":
+		return goarch == "amd64"
+	default:
+		return false
+	}
+}
+
+// MSanSupported reports whether goos/goarch supports the memory
+// sanitizer option.
+// There is a copy of this function in misc/cgo/testsanitizers/cc_test.go.
+func MSanSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "amd64" || goarch == "arm64"
+	default:
+		return false
+	}
+}
+
+// ASanSupported reports whether goos/goarch supports the address
+// sanitizer option.
+// There is a copy of this function in misc/cgo/testsanitizers/cc_test.go.
+func ASanSupported(goos, goarch string) bool {
+	switch goos {
+	case "linux":
+		return goarch == "arm64" || goarch == "amd64"
+	default:
+		return false
+	}
+}
+
+// FuzzSupported reports whether goos/goarch supports fuzzing
+// ('go test -fuzz=.').
+func FuzzSupported(goos, goarch string) bool {
+	switch goos {
+	case "darwin", "freebsd", "linux", "windows":
+		return true
+	default:
+		return false
+	}
+}
+
+// FuzzInstrumented reports whether fuzzing on goos/goarch uses coverage
+// instrumentation. (FuzzInstrumented implies FuzzSupported.)
+func FuzzInstrumented(goos, goarch string) bool {
+	switch goarch {
+	case "amd64", "arm64":
+		// TODO(#14565): support more architectures.
+		return FuzzSupported(goos, goarch)
+	default:
+		return false
+	}
+}
+
+// MustLinkExternal reports whether goos/goarch requires external linking.
+// (This is the opposite of internal/testenv.CanInternalLink. Keep them in sync.)
+func MustLinkExternal(goos, goarch string) bool {
+	switch goos {
+	case "android":
+		if goarch != "arm64" {
+			return true
+		}
+	case "ios":
+		if goarch == "arm64" {
+			return true
+		}
+	}
+	return false
+}
+
+// BuildModeSupported reports whether goos/goarch supports the given build mode
+// using the given compiler.
+func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
+	if compiler == "gccgo" {
+		return true
+	}
+
+	platform := goos + "/" + goarch
+
+	switch buildmode {
+	case "archive":
+		return true
+
+	case "c-archive":
+		// TODO(bcmills): This seems dubious.
+		// Do we really support c-archive mode on js/wasm‽
+		return platform != "linux/ppc64"
+
+	case "c-shared":
+		switch platform {
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/riscv64", "linux/s390x",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"freebsd/amd64",
+			"darwin/amd64", "darwin/arm64",
+			"windows/amd64", "windows/386", "windows/arm64":
+			return true
+		}
+		return false
+
+	case "default":
+		return true
+
+	case "exe":
+		return true
+
+	case "pie":
+		switch platform {
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/riscv64", "linux/s390x",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"freebsd/amd64",
+			"darwin/amd64", "darwin/arm64",
+			"ios/amd64", "ios/arm64",
+			"aix/ppc64",
+			"windows/386", "windows/amd64", "windows/arm":
+			return true
+		}
+		return false
+
+	case "shared":
+		switch platform {
+		case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x":
+			return true
+		}
+		return false
+
+	case "plugin":
+		switch platform {
+		case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/ppc64le",
+			"android/amd64", "android/arm", "android/arm64", "android/386",
+			"darwin/amd64", "darwin/arm64",
+			"freebsd/amd64":
+			return true
+		}
+		return false
+
+	default:
+		return false
+	}
+}
+
+func InternalLinkPIESupported(goos, goarch string) bool {
+	switch goos + "/" + goarch {
+	case "darwin/amd64", "darwin/arm64",
+		"linux/amd64", "linux/arm64", "linux/ppc64le",
+		"android/arm64",
+		"windows-amd64", "windows-386", "windows-arm":
+		return true
+	}
+	return false
+}
diff --git a/src/cmd/internal/sys/supported_test.go b/src/cmd/internal/sys/supported_test.go
new file mode 100644
index 0000000..1217814
--- /dev/null
+++ b/src/cmd/internal/sys/supported_test.go
@@ -0,0 +1,18 @@
+// 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 sys
+
+import (
+	"internal/testenv"
+	"runtime"
+	"testing"
+)
+
+func TestMustLinkExternalMatchesTestenv(t *testing.T) {
+	// MustLinkExternal and testenv.CanInternalLink are the exact opposite.
+	if b := MustLinkExternal(runtime.GOOS, runtime.GOARCH); b != !testenv.CanInternalLink() {
+		t.Fatalf("MustLinkExternal() == %v, testenv.CanInternalLink() == %v, don't match", b, testenv.CanInternalLink())
+	}
+}