libgo: update to Go1.16beta1 release

This does not yet include support for the //go:embed directive added
in this release.

	* Makefile.am (check-runtime): Don't create check-runtime-dir.
	(mostlyclean-local): Don't remove check-runtime-dir.
	(check-go-tool, check-vet): Copy in go.mod and modules.txt.
	(check-cgo-test, check-carchive-test): Add go.mod file.
	* Makefile.in: Regenerate.

Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/280172

26 files changed, 542 insertions, 27 deletions

diff --git a/libgo/misc/cgo/test/callback.go b/libgo/misc/cgo/test/callback.go
index e7496502931..814888e3ac5 100644
--- a/libgo/misc/cgo/test/callback.go
+++ b/libgo/misc/cgo/test/callback.go
@@ -181,7 +181,7 @@ func testCallbackCallers(t *testing.T) {
 	name := []string{
 		"runtime.cgocallbackg1",
 		"runtime.cgocallbackg",
-		"runtime.cgocallback_gofunc",
+		"runtime.cgocallback",
 		"runtime.asmcgocall",
 		"runtime.cgocall",
 		"test._Cfunc_callback",
diff --git a/libgo/misc/cgo/test/cgo_linux_test.go b/libgo/misc/cgo/test/cgo_linux_test.go
index 7b56e11a27d..a9746b552ee 100644
--- a/libgo/misc/cgo/test/cgo_linux_test.go
+++ b/libgo/misc/cgo/test/cgo_linux_test.go
@@ -15,5 +15,6 @@ func TestSetgid(t *testing.T) {
 	}
 	testSetgid(t)
 }
+func Test1435(t *testing.T)    { test1435(t) }
 func Test6997(t *testing.T)    { test6997(t) }
 func TestBuildID(t *testing.T) { testBuildID(t) }
diff --git a/libgo/misc/cgo/test/cgo_test.go b/libgo/misc/cgo/test/cgo_test.go
index b745a4417f1..f7a76d047bd 100644
--- a/libgo/misc/cgo/test/cgo_test.go
+++ b/libgo/misc/cgo/test/cgo_test.go
@@ -76,6 +76,8 @@ func TestCheckConst(t *testing.T)            { testCheckConst(t) }
 func TestConst(t *testing.T)                 { testConst(t) }
 func TestCthread(t *testing.T)               { testCthread(t) }
 func TestEnum(t *testing.T)                  { testEnum(t) }
+func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
+func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
 func TestErrno(t *testing.T)                 { testErrno(t) }
 func TestFpVar(t *testing.T)                 { testFpVar(t) }
 func TestHelpers(t *testing.T)               { testHelpers(t) }
diff --git a/libgo/misc/cgo/test/issue1435.go b/libgo/misc/cgo/test/issue1435.go
new file mode 100644
index 00000000000..a1c7cacde73
--- /dev/null
+++ b/libgo/misc/cgo/test/issue1435.go
@@ -0,0 +1,184 @@
+// Copyright 2019 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.
+
+// +build linux,cgo
+
+package cgotest
+
+import (
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+// #include <stdio.h>
+// #include <stdlib.h>
+// #include <pthread.h>
+// #include <unistd.h>
+// #include <sys/types.h>
+//
+// pthread_t *t = NULL;
+// pthread_mutex_t mu;
+// int nts = 0;
+// int all_done = 0;
+//
+// static void *aFn(void *vargp) {
+//   int done = 0;
+//   while (!done) {
+//     usleep(100);
+//     pthread_mutex_lock(&mu);
+//     done = all_done;
+//     pthread_mutex_unlock(&mu);
+//   }
+//   return NULL;
+// }
+//
+// void trial(int argc) {
+//   int i;
+//   nts = argc;
+//   t = calloc(nts, sizeof(pthread_t));
+//   pthread_mutex_init(&mu, NULL);
+//   for (i = 0; i < nts; i++) {
+//     pthread_create(&t[i], NULL, aFn, NULL);
+//   }
+// }
+//
+// void cleanup(void) {
+//   int i;
+//   pthread_mutex_lock(&mu);
+//   all_done = 1;
+//   pthread_mutex_unlock(&mu);
+//   for (i = 0; i < nts; i++) {
+//     pthread_join(t[i], NULL);
+//   }
+//   pthread_mutex_destroy(&mu);
+//   free(t);
+// }
+import "C"
+
+// compareStatus is used to confirm the contents of the thread
+// specific status files match expectations.
+func compareStatus(filter, expect string) error {
+	expected := filter + expect
+	pid := syscall.Getpid()
+	fs, err := ioutil.ReadDir(fmt.Sprintf("/proc/%d/task", pid))
+	if err != nil {
+		return fmt.Errorf("unable to find %d tasks: %v", pid, err)
+	}
+	expectedProc := fmt.Sprintf("Pid:\t%d", pid)
+	foundAThread := false
+	for _, f := range fs {
+		tf := fmt.Sprintf("/proc/%s/status", f.Name())
+		d, err := ioutil.ReadFile(tf)
+		if err != nil {
+			// There are a surprising number of ways this
+			// can error out on linux.  We've seen all of
+			// the following, so treat any error here as
+			// equivalent to the "process is gone":
+			//    os.IsNotExist(err),
+			//    "... : no such process",
+			//    "... : bad file descriptor.
+			continue
+		}
+		lines := strings.Split(string(d), "\n")
+		for _, line := range lines {
+			// Different kernel vintages pad differently.
+			line = strings.TrimSpace(line)
+			if strings.HasPrefix(line, "Pid:\t") {
+				// On loaded systems, it is possible
+				// for a TID to be reused really
+				// quickly. As such, we need to
+				// validate that the thread status
+				// info we just read is a task of the
+				// same process PID as we are
+				// currently running, and not a
+				// recently terminated thread
+				// resurfaced in a different process.
+				if line != expectedProc {
+					break
+				}
+				// Fall through in the unlikely case
+				// that filter at some point is
+				// "Pid:\t".
+			}
+			if strings.HasPrefix(line, filter) {
+				if line != expected {
+					return fmt.Errorf("%q got:%q want:%q (bad) [pid=%d file:'%s' %v]\n", tf, line, expected, pid, string(d), expectedProc)
+				}
+				foundAThread = true
+				break
+			}
+		}
+	}
+	if !foundAThread {
+		return fmt.Errorf("found no thread /proc/<TID>/status files for process %q", expectedProc)
+	}
+	return nil
+}
+
+// test1435 test 9 glibc implemented setuid/gid syscall functions are
+// mapped.  This test is a slightly more expansive test than that of
+// src/syscall/syscall_linux_test.go:TestSetuidEtc() insofar as it
+// launches concurrent threads from C code via CGo and validates that
+// they are subject to the system calls being tested. For the actual
+// Go functionality being tested here, the syscall_linux_test version
+// is considered authoritative, but non-trivial improvements to that
+// should be mirrored here.
+func test1435(t *testing.T) {
+	if syscall.Getuid() != 0 {
+		t.Skip("skipping root only test")
+	}
+
+	// Launch some threads in C.
+	const cts = 5
+	C.trial(cts)
+	defer C.cleanup()
+
+	vs := []struct {
+		call           string
+		fn             func() error
+		filter, expect string
+	}{
+		{call: "Setegid(1)", fn: func() error { return syscall.Setegid(1) }, filter: "Gid:", expect: "\t0\t1\t0\t1"},
+		{call: "Setegid(0)", fn: func() error { return syscall.Setegid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Seteuid(1)", fn: func() error { return syscall.Seteuid(1) }, filter: "Uid:", expect: "\t0\t1\t0\t1"},
+		{call: "Setuid(0)", fn: func() error { return syscall.Setuid(0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Setgid(1)", fn: func() error { return syscall.Setgid(1) }, filter: "Gid:", expect: "\t1\t1\t1\t1"},
+		{call: "Setgid(0)", fn: func() error { return syscall.Setgid(0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Setgroups([]int{0,1,2,3})", fn: func() error { return syscall.Setgroups([]int{0, 1, 2, 3}) }, filter: "Groups:", expect: "\t0 1 2 3"},
+		{call: "Setgroups(nil)", fn: func() error { return syscall.Setgroups(nil) }, filter: "Groups:", expect: ""},
+		{call: "Setgroups([]int{0})", fn: func() error { return syscall.Setgroups([]int{0}) }, filter: "Groups:", expect: "\t0"},
+
+		{call: "Setregid(101,0)", fn: func() error { return syscall.Setregid(101, 0) }, filter: "Gid:", expect: "\t101\t0\t0\t0"},
+		{call: "Setregid(0,102)", fn: func() error { return syscall.Setregid(0, 102) }, filter: "Gid:", expect: "\t0\t102\t102\t102"},
+		{call: "Setregid(0,0)", fn: func() error { return syscall.Setregid(0, 0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Setreuid(1,0)", fn: func() error { return syscall.Setreuid(1, 0) }, filter: "Uid:", expect: "\t1\t0\t0\t0"},
+		{call: "Setreuid(0,2)", fn: func() error { return syscall.Setreuid(0, 2) }, filter: "Uid:", expect: "\t0\t2\t2\t2"},
+		{call: "Setreuid(0,0)", fn: func() error { return syscall.Setreuid(0, 0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Setresgid(101,0,102)", fn: func() error { return syscall.Setresgid(101, 0, 102) }, filter: "Gid:", expect: "\t101\t0\t102\t0"},
+		{call: "Setresgid(0,102,101)", fn: func() error { return syscall.Setresgid(0, 102, 101) }, filter: "Gid:", expect: "\t0\t102\t101\t102"},
+		{call: "Setresgid(0,0,0)", fn: func() error { return syscall.Setresgid(0, 0, 0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},
+
+		{call: "Setresuid(1,0,2)", fn: func() error { return syscall.Setresuid(1, 0, 2) }, filter: "Uid:", expect: "\t1\t0\t2\t0"},
+		{call: "Setresuid(0,2,1)", fn: func() error { return syscall.Setresuid(0, 2, 1) }, filter: "Uid:", expect: "\t0\t2\t1\t2"},
+		{call: "Setresuid(0,0,0)", fn: func() error { return syscall.Setresuid(0, 0, 0) }, filter: "Uid:", expect: "\t0\t0\t0\t0"},
+	}
+
+	for i, v := range vs {
+		if err := v.fn(); err != nil {
+			t.Errorf("[%d] %q failed: %v", i, v.call, err)
+			continue
+		}
+		if err := compareStatus(v.filter, v.expect); err != nil {
+			t.Errorf("[%d] %q comparison: %v", i, v.call, err)
+		}
+	}
+}
diff --git a/libgo/misc/cgo/test/issue18146.go b/libgo/misc/cgo/test/issue18146.go
index 196d98f5079..f92d6c7f939 100644
--- a/libgo/misc/cgo/test/issue18146.go
+++ b/libgo/misc/cgo/test/issue18146.go
@@ -24,7 +24,7 @@ func test18146(t *testing.T) {
 		t.Skip("skipping in short mode")
 	}
 
-	if runtime.GOOS == "darwin" {
+	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 		t.Skipf("skipping flaky test on %s; see golang.org/issue/18202", runtime.GOOS)
 	}
 
diff --git a/libgo/misc/cgo/test/issue4029.c b/libgo/misc/cgo/test/issue4029.c
index 30646ade021..e79c5a709c8 100644
--- a/libgo/misc/cgo/test/issue4029.c
+++ b/libgo/misc/cgo/test/issue4029.c
@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 // +build !windows,!static
+// +build !darwin !internal_pie,!arm64
 
 #include <stdint.h>
 #include <dlfcn.h>
diff --git a/libgo/misc/cgo/test/issue4029.go b/libgo/misc/cgo/test/issue4029.go
index 1bf029d760a..b2d131833a9 100644
--- a/libgo/misc/cgo/test/issue4029.go
+++ b/libgo/misc/cgo/test/issue4029.go
@@ -3,6 +3,11 @@
 // license that can be found in the LICENSE file.
 
 // +build !windows,!static
+// +build !darwin !internal_pie,!arm64
+
+// Excluded in darwin internal linking PIE mode, as dynamic export is not
+// supported.
+// Excluded in internal linking mode on darwin/arm64, as it is always PIE.
 
 package cgotest
 
diff --git a/libgo/misc/cgo/test/issue4029w.go b/libgo/misc/cgo/test/issue4029w.go
index eee33f70101..b969bdd0fe8 100644
--- a/libgo/misc/cgo/test/issue4029w.go
+++ b/libgo/misc/cgo/test/issue4029w.go
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// +build windows static
+// +build windows static darwin,internal_pie darwin,arm64
 
 package cgotest
 
diff --git a/libgo/misc/cgo/test/issue42495.go b/libgo/misc/cgo/test/issue42495.go
new file mode 100644
index 00000000000..509a67d9a30
--- /dev/null
+++ b/libgo/misc/cgo/test/issue42495.go
@@ -0,0 +1,15 @@
+// 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 cgotest
+
+// typedef struct { } T42495A;
+// typedef struct { int x[0]; } T42495B;
+import "C"
+
+//export Issue42495A
+func Issue42495A(C.T42495A) {}
+
+//export Issue42495B
+func Issue42495B(C.T42495B) {}
diff --git a/libgo/misc/cgo/test/pkg_test.go b/libgo/misc/cgo/test/pkg_test.go
index 26c50ad883f..a28ad4ea74f 100644
--- a/libgo/misc/cgo/test/pkg_test.go
+++ b/libgo/misc/cgo/test/pkg_test.go
@@ -30,7 +30,7 @@ func TestCrossPackageTests(t *testing.T) {
 	switch runtime.GOOS {
 	case "android":
 		t.Skip("Can't exec cmd/go subprocess on Android.")
-	case "darwin":
+	case "darwin", "ios":
 		switch runtime.GOARCH {
 		case "arm64":
 			t.Skip("Can't exec cmd/go subprocess on iOS.")
diff --git a/libgo/misc/cgo/test/sigaltstack.go b/libgo/misc/cgo/test/sigaltstack.go
index 8dfa1cb5adb..034cc4b3719 100644
--- a/libgo/misc/cgo/test/sigaltstack.go
+++ b/libgo/misc/cgo/test/sigaltstack.go
@@ -62,7 +62,7 @@ import (
 
 func testSigaltstack(t *testing.T) {
 	switch {
-	case runtime.GOOS == "solaris", runtime.GOOS == "illumos", runtime.GOOS == "darwin" && runtime.GOARCH == "arm64":
+	case runtime.GOOS == "solaris", runtime.GOOS == "illumos", runtime.GOOS == "ios" && runtime.GOARCH == "arm64":
 		t.Skipf("switching signal stack not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
 	}
 
diff --git a/libgo/misc/cgo/test/test.go b/libgo/misc/cgo/test/test.go
index 35bc3a14475..65823b1ca0e 100644
--- a/libgo/misc/cgo/test/test.go
+++ b/libgo/misc/cgo/test/test.go
@@ -319,6 +319,7 @@ typedef enum {
 
 // issue 4339
 // We've historically permitted #include <>, so test it here.  Issue 29333.
+// Also see issue 41059.
 #include <issue4339.h>
 
 // issue 4417
@@ -999,6 +1000,32 @@ func testEnum(t *testing.T) {
 	}
 }
 
+func testNamedEnum(t *testing.T) {
+	e := new(C.enum_E)
+
+	*e = C.Enum1
+	if *e != 1 {
+		t.Error("bad enum", C.Enum1)
+	}
+
+	*e = C.Enum2
+	if *e != 2 {
+		t.Error("bad enum", C.Enum2)
+	}
+}
+
+func testCastToEnum(t *testing.T) {
+	e := C.enum_E(C.Enum1)
+	if e != 1 {
+		t.Error("bad enum", C.Enum1)
+	}
+
+	e = C.enum_E(C.Enum2)
+	if e != 2 {
+		t.Error("bad enum", C.Enum2)
+	}
+}
+
 func testAtol(t *testing.T) {
 	l := Atol("123")
 	if l != 123 {
@@ -1775,7 +1802,7 @@ func test14838(t *testing.T) {
 var sink C.int
 
 func test17065(t *testing.T) {
-	if runtime.GOOS == "darwin" {
+	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 		t.Skip("broken on darwin; issue 17065")
 	}
 	for i := range C.ii {
diff --git a/libgo/misc/cgo/test/testdata/issue9400/asm_riscv64.s b/libgo/misc/cgo/test/testdata/issue9400/asm_riscv64.s
new file mode 100644
index 00000000000..20fcc0066d6
--- /dev/null
+++ b/libgo/misc/cgo/test/testdata/issue9400/asm_riscv64.s
@@ -0,0 +1,31 @@
+// 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.
+
+// +build riscv64
+// +build !gccgo
+
+#include "textflag.h"
+
+TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
+	// Rewind stack pointer so anything that happens on the stack
+	// will clobber the test pattern created by the caller
+	ADD	$(1024*8), X2
+
+	// Ask signaller to setgid
+	MOV	$1, X5
+	FENCE
+	MOVW	X5, ·Baton(SB)
+	FENCE
+
+	// Wait for setgid completion
+loop:
+	FENCE
+	MOVW	·Baton(SB), X5
+	OR	X6, X6, X6	// hint that we're in a spin loop
+	BNE	ZERO, X5, loop
+	FENCE
+
+	// Restore stack
+	ADD	$(-1024*8), X2
+	RET
diff --git a/libgo/misc/cgo/test/testx.go b/libgo/misc/cgo/test/testx.go
index 7fbc5c64b31..2b2e69ec00f 100644
--- a/libgo/misc/cgo/test/testx.go
+++ b/libgo/misc/cgo/test/testx.go
@@ -164,7 +164,7 @@ func Add(x int) {
 }
 
 func testCthread(t *testing.T) {
-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+	if (runtime.GOOS == "darwin" || runtime.GOOS == "ios") && runtime.GOARCH == "arm64" {
 		t.Skip("the iOS exec wrapper is unable to properly handle the panic from Add")
 	}
 	sum.i = 0
diff --git a/libgo/misc/cgo/testcarchive/carchive_test.go b/libgo/misc/cgo/testcarchive/carchive_test.go
index af50e1e42e5..f3978b20cbe 100644
--- a/libgo/misc/cgo/testcarchive/carchive_test.go
+++ b/libgo/misc/cgo/testcarchive/carchive_test.go
@@ -118,9 +118,9 @@ func testMain(m *testing.M) int {
 		cc = append(cc, s[start:])
 	}
 
-	if GOOS == "darwin" {
+	if GOOS == "darwin" || GOOS == "ios" {
 		// For Darwin/ARM.
-		// TODO(crawshaw): can we do better?
+		// TODO: do we still need this?
 		cc = append(cc, []string{"-framework", "CoreFoundation", "-framework", "Foundation"}...)
 	}
 	if GOOS == "aix" {
@@ -133,7 +133,7 @@ func testMain(m *testing.M) int {
 		libbase = "gccgo_" + libbase + "_fPIC"
 	} else {
 		switch GOOS {
-		case "darwin":
+		case "darwin", "ios":
 			if GOARCH == "arm64" {
 				libbase += "_shared"
 			}
@@ -303,7 +303,7 @@ func TestInstall(t *testing.T) {
 
 func TestEarlySignalHandler(t *testing.T) {
 	switch GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		switch GOARCH {
 		case "arm64":
 			t.Skipf("skipping on %s/%s; see https://golang.org/issue/13701", GOOS, GOARCH)
@@ -384,7 +384,7 @@ func TestSignalForwarding(t *testing.T) {
 	expectSignal(t, err, syscall.SIGSEGV)
 
 	// SIGPIPE is never forwarded on darwin. See golang.org/issue/33384.
-	if runtime.GOOS != "darwin" {
+	if runtime.GOOS != "darwin" && runtime.GOOS != "ios" {
 		// Test SIGPIPE forwarding
 		cmd = exec.Command(bin[0], append(bin[1:], "3")...)
 
@@ -485,7 +485,7 @@ func TestSignalForwardingExternal(t *testing.T) {
 // doesn't work on this platform.
 func checkSignalForwardingTest(t *testing.T) {
 	switch GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		switch GOARCH {
 		case "arm64":
 			t.Skipf("skipping on %s/%s; see https://golang.org/issue/13701", GOOS, GOARCH)
@@ -603,7 +603,7 @@ func TestExtar(t *testing.T) {
 	if runtime.Compiler == "gccgo" {
 		t.Skip("skipping -extar test when using gccgo")
 	}
-	if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" {
+	if runtime.GOOS == "ios" {
 		t.Skip("shell scripts are not executable on iOS hosts")
 	}
 
@@ -645,7 +645,7 @@ func TestExtar(t *testing.T) {
 
 func TestPIE(t *testing.T) {
 	switch GOOS {
-	case "windows", "darwin", "plan9":
+	case "windows", "darwin", "ios", "plan9":
 		t.Skipf("skipping PIE test on %s", GOOS)
 	}
 
@@ -738,7 +738,7 @@ func TestSIGPROF(t *testing.T) {
 	switch GOOS {
 	case "windows", "plan9":
 		t.Skipf("skipping SIGPROF test on %s", GOOS)
-	case "darwin":
+	case "darwin", "ios":
 		t.Skipf("skipping SIGPROF test on %s; see https://golang.org/issue/19320", GOOS)
 	}
 
@@ -841,7 +841,7 @@ func TestCompileWithoutShared(t *testing.T) {
 	expectSignal(t, err, syscall.SIGSEGV)
 
 	// SIGPIPE is never forwarded on darwin. See golang.org/issue/33384.
-	if runtime.GOOS != "darwin" {
+	if runtime.GOOS != "darwin" && runtime.GOOS != "ios" {
 		binArgs := append(cmdToRun(exe), "3")
 		t.Log(binArgs)
 		out, err = exec.Command(binArgs[0], binArgs[1:]...).CombinedOutput()
diff --git a/libgo/misc/cgo/testcshared/cshared_test.go b/libgo/misc/cgo/testcshared/cshared_test.go
index bd4d341820e..3a4886cf30a 100644
--- a/libgo/misc/cgo/testcshared/cshared_test.go
+++ b/libgo/misc/cgo/testcshared/cshared_test.go
@@ -7,6 +7,8 @@ package cshared_test
 import (
 	"bytes"
 	"debug/elf"
+	"debug/pe"
+	"encoding/binary"
 	"flag"
 	"fmt"
 	"io/ioutil"
@@ -98,7 +100,7 @@ func testMain(m *testing.M) int {
 	}
 
 	switch GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		// For Darwin/ARM.
 		// TODO(crawshaw): can we do better?
 		cc = append(cc, []string{"-framework", "CoreFoundation", "-framework", "Foundation"}...)
@@ -107,7 +109,7 @@ func testMain(m *testing.M) int {
 	}
 	libgodir := GOOS + "_" + GOARCH
 	switch GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		if GOARCH == "arm64" {
 			libgodir += "_shared"
 		}
@@ -355,6 +357,101 @@ func TestExportedSymbols(t *testing.T) {
 	}
 }
 
+func checkNumberOfExportedFunctionsWindows(t *testing.T, exportAllSymbols bool) {
+	const prog = `
+package main
+
+import "C"
+
+//export GoFunc
+func GoFunc() {
+	println(42)
+}
+
+//export GoFunc2
+func GoFunc2() {
+	println(24)
+}
+
+func main() {
+}
+`
+
+	tmpdir := t.TempDir()
+
+	srcfile := filepath.Join(tmpdir, "test.go")
+	objfile := filepath.Join(tmpdir, "test.dll")
+	if err := ioutil.WriteFile(srcfile, []byte(prog), 0666); err != nil {
+		t.Fatal(err)
+	}
+	argv := []string{"build", "-buildmode=c-shared"}
+	if exportAllSymbols {
+		argv = append(argv, "-ldflags", "-extldflags=-Wl,--export-all-symbols")
+	}
+	argv = append(argv, "-o", objfile, srcfile)
+	out, err := exec.Command("go", argv...).CombinedOutput()
+	if err != nil {
+		t.Fatalf("build failure: %s\n%s\n", err, string(out))
+	}
+
+	f, err := pe.Open(objfile)
+	if err != nil {
+		t.Fatalf("pe.Open failed: %v", err)
+	}
+	defer f.Close()
+	section := f.Section(".edata")
+	if section == nil {
+		t.Fatalf(".edata section is not present")
+	}
+
+	// TODO: deduplicate this struct from cmd/link/internal/ld/pe.go
+	type IMAGE_EXPORT_DIRECTORY struct {
+		_                 [2]uint32
+		_                 [2]uint16
+		_                 [2]uint32
+		NumberOfFunctions uint32
+		NumberOfNames     uint32
+		_                 [3]uint32
+	}
+	var e IMAGE_EXPORT_DIRECTORY
+	if err := binary.Read(section.Open(), binary.LittleEndian, &e); err != nil {
+		t.Fatalf("binary.Read failed: %v", err)
+	}
+
+	// Only the two exported functions and _cgo_dummy_export should be exported
+	expectedNumber := uint32(3)
+
+	if exportAllSymbols {
+		if e.NumberOfFunctions <= expectedNumber {
+			t.Fatalf("missing exported functions: %v", e.NumberOfFunctions)
+		}
+		if e.NumberOfNames <= expectedNumber {
+			t.Fatalf("missing exported names: %v", e.NumberOfNames)
+		}
+	} else {
+		if e.NumberOfFunctions != expectedNumber {
+			t.Fatalf("got %d exported functions; want %d", e.NumberOfFunctions, expectedNumber)
+		}
+		if e.NumberOfNames != expectedNumber {
+			t.Fatalf("got %d exported names; want %d", e.NumberOfNames, expectedNumber)
+		}
+	}
+}
+
+func TestNumberOfExportedFunctions(t *testing.T) {
+	if GOOS != "windows" {
+		t.Skip("skipping windows only test")
+	}
+	t.Parallel()
+
+	t.Run("OnlyExported", func(t *testing.T) {
+		checkNumberOfExportedFunctionsWindows(t, false)
+	})
+	t.Run("All", func(t *testing.T) {
+		checkNumberOfExportedFunctionsWindows(t, true)
+	})
+}
+
 // test1: shared library can be dynamically loaded and exported symbols are accessible.
 func TestExportedSymbolsWithDynamicLoad(t *testing.T) {
 	t.Parallel()
@@ -407,7 +504,7 @@ func TestUnexportedSymbols(t *testing.T) {
 	adbPush(t, libname)
 
 	linkFlags := "-Wl,--no-as-needed"
-	if GOOS == "darwin" {
+	if GOOS == "darwin" || GOOS == "ios" {
 		linkFlags = ""
 	}
 
@@ -636,7 +733,7 @@ func copyFile(t *testing.T, dst, src string) {
 
 func TestGo2C2Go(t *testing.T) {
 	switch GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		// Darwin shared libraries don't support the multiple
 		// copies of the runtime package implied by this test.
 		t.Skip("linking c-shared into Go programs not supported on Darwin; issue 29061")
diff --git a/libgo/misc/cgo/testgodefs/testdata/bitfields.go b/libgo/misc/cgo/testgodefs/testdata/bitfields.go
new file mode 100644
index 00000000000..6a9724dcd15
--- /dev/null
+++ b/libgo/misc/cgo/testgodefs/testdata/bitfields.go
@@ -0,0 +1,31 @@
+// 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.
+//
+// +build ignore
+
+package main
+
+// This file tests that we don't generate an incorrect field location
+// for a bitfield that appears aligned.
+
+/*
+struct bitfields {
+    unsigned int B1     :  5;
+    unsigned int B2     :  1;
+    unsigned int B3     :  1;
+    unsigned int B4     :  1;
+    unsigned int Short1 : 16; // misaligned on 8 bit boundary
+    unsigned int B5     :  1;
+    unsigned int B6     :  1;
+    unsigned int B7     :  1;
+    unsigned int B8     :  1;
+    unsigned int B9     :  1;
+    unsigned int B10    :  3;
+    unsigned int Short2 : 16; // alignment is OK
+    unsigned int Short3 : 16; // alignment is OK
+};
+*/
+import "C"
+
+type bitfields C.struct_bitfields
diff --git a/libgo/misc/cgo/testgodefs/testdata/main.go b/libgo/misc/cgo/testgodefs/testdata/main.go
index 2e1ad3376a1..4a3f6a701cc 100644
--- a/libgo/misc/cgo/testgodefs/testdata/main.go
+++ b/libgo/misc/cgo/testgodefs/testdata/main.go
@@ -4,6 +4,12 @@
 
 package main
 
+import (
+	"fmt"
+	"os"
+	"reflect"
+)
+
 // Test that the struct field in anonunion.go was promoted.
 var v1 T
 var v2 = v1.L
@@ -23,4 +29,26 @@ var v7 = S{}
 var _ = issue38649{X: 0}
 
 func main() {
+	pass := true
+
+	// The Go translation of bitfields should not have any of the
+	// bitfield types. The order in which bitfields are laid out
+	// in memory is implementation defined, so we can't easily
+	// know how a bitfield should correspond to a Go type, even if
+	// it appears to be aligned correctly.
+	bitfieldType := reflect.TypeOf(bitfields{})
+	check := func(name string) {
+		_, ok := bitfieldType.FieldByName(name)
+		if ok {
+			fmt.Fprintf(os.Stderr, "found unexpected bitfields field %s\n", name)
+			pass = false
+		}
+	}
+	check("Short1")
+	check("Short2")
+	check("Short3")
+
+	if !pass {
+		os.Exit(1)
+	}
 }
diff --git a/libgo/misc/cgo/testgodefs/testgodefs_test.go b/libgo/misc/cgo/testgodefs/testgodefs_test.go
index e4085f9ca80..4c2312c1c89 100644
--- a/libgo/misc/cgo/testgodefs/testgodefs_test.go
+++ b/libgo/misc/cgo/testgodefs/testgodefs_test.go
@@ -19,6 +19,7 @@ import (
 // import "C" block.  Add more tests here.
 var filePrefixes = []string{
 	"anonunion",
+	"bitfields",
 	"issue8478",
 	"fieldtypedef",
 	"issue37479",
diff --git a/libgo/misc/cgo/testplugin/plugin_test.go b/libgo/misc/cgo/testplugin/plugin_test.go
index 2875271c03b..9055dbda044 100644
--- a/libgo/misc/cgo/testplugin/plugin_test.go
+++ b/libgo/misc/cgo/testplugin/plugin_test.go
@@ -196,3 +196,17 @@ func TestIssue25756(t *testing.T) {
 		})
 	}
 }
+
+func TestMethod(t *testing.T) {
+	// Exported symbol's method must be live.
+	goCmd(t, "build", "-buildmode=plugin", "-o", "plugin.so", "./method/plugin.go")
+	goCmd(t, "build", "-o", "method.exe", "./method/main.go")
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	cmd := exec.CommandContext(ctx, "./method.exe")
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, out)
+	}
+}
diff --git a/libgo/misc/cgo/testplugin/testdata/method/main.go b/libgo/misc/cgo/testplugin/testdata/method/main.go
new file mode 100644
index 00000000000..5e9189b4500
--- /dev/null
+++ b/libgo/misc/cgo/testplugin/testdata/method/main.go
@@ -0,0 +1,26 @@
+// 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.
+
+// Issue 42579: methods of symbols exported from plugin must be live.
+
+package main
+
+import (
+	"plugin"
+	"reflect"
+)
+
+func main() {
+	p, err := plugin.Open("plugin.so")
+	if err != nil {
+		panic(err)
+	}
+
+	x, err := p.Lookup("X")
+	if err != nil {
+		panic(err)
+	}
+
+	reflect.ValueOf(x).Elem().MethodByName("M").Call(nil)
+}
diff --git a/libgo/misc/cgo/testplugin/testdata/method/plugin.go b/libgo/misc/cgo/testplugin/testdata/method/plugin.go
new file mode 100644
index 00000000000..240edd3bc45
--- /dev/null
+++ b/libgo/misc/cgo/testplugin/testdata/method/plugin.go
@@ -0,0 +1,13 @@
+// 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 main
+
+func main() {}
+
+type T int
+
+func (T) M() { println("M") }
+
+var X T
diff --git a/libgo/misc/cgo/testsanitizers/msan_test.go b/libgo/misc/cgo/testsanitizers/msan_test.go
index 88b90d3d70d..5e2f9759bae 100644
--- a/libgo/misc/cgo/testsanitizers/msan_test.go
+++ b/libgo/misc/cgo/testsanitizers/msan_test.go
@@ -28,6 +28,7 @@ func TestMSAN(t *testing.T) {
 		{src: "msan4.go"},
 		{src: "msan5.go"},
 		{src: "msan6.go"},
+		{src: "msan7.go"},
 		{src: "msan_fail.go", wantErr: true},
 	}
 	for _, tc := range cases {
diff --git a/libgo/misc/cgo/testsanitizers/testdata/msan7.go b/libgo/misc/cgo/testsanitizers/testdata/msan7.go
new file mode 100644
index 00000000000..2f29fd21b2e
--- /dev/null
+++ b/libgo/misc/cgo/testsanitizers/testdata/msan7.go
@@ -0,0 +1,38 @@
+// 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 main
+
+// Test passing C struct to exported Go function.
+
+/*
+#include <stdint.h>
+#include <stdlib.h>
+
+// T is a C struct with alignment padding after b.
+// The padding bytes are not considered initialized by MSAN.
+// It is big enough to be passed on stack in C ABI (and least
+// on AMD64).
+typedef struct { char b; uintptr_t x, y; } T;
+
+extern void F(T);
+
+// Use weak as a hack to permit defining a function even though we use export.
+void CF(int x) __attribute__ ((weak));
+void CF(int x) {
+	T *t = malloc(sizeof(T));
+	t->b = (char)x;
+	t->x = x;
+	t->y = x;
+	F(*t);
+}
+*/
+import "C"
+
+//export F
+func F(t C.T) { println(t.b, t.x, t.y) }
+
+func main() {
+	C.CF(C.int(0))
+}
diff --git a/libgo/misc/cgo/testso/so_test.go b/libgo/misc/cgo/testso/so_test.go
index bdd6bd84685..57f0fd34f78 100644
--- a/libgo/misc/cgo/testso/so_test.go
+++ b/libgo/misc/cgo/testso/so_test.go
@@ -21,7 +21,7 @@ func requireTestSOSupported(t *testing.T) {
 	t.Helper()
 	switch runtime.GOARCH {
 	case "arm64":
-		if runtime.GOOS == "darwin" {
+		if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 			t.Skip("No exec facility on iOS.")
 		}
 	case "ppc64":
@@ -74,7 +74,7 @@ func TestSO(t *testing.T) {
 	ext := "so"
 	args := append(gogccflags, "-shared")
 	switch runtime.GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		ext = "dylib"
 		args = append(args, "-undefined", "suppress", "-flat_namespace")
 	case "windows":
@@ -119,7 +119,7 @@ func TestSO(t *testing.T) {
 	cmd.Env = append(os.Environ(), "GOPATH="+GOPATH)
 	if runtime.GOOS != "windows" {
 		s := "LD_LIBRARY_PATH"
-		if runtime.GOOS == "darwin" {
+		if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 			s = "DYLD_LIBRARY_PATH"
 		}
 		cmd.Env = append(os.Environ(), s+"=.")
diff --git a/libgo/misc/cgo/testsovar/so_test.go b/libgo/misc/cgo/testsovar/so_test.go
index bdd6bd84685..57f0fd34f78 100644
--- a/libgo/misc/cgo/testsovar/so_test.go
+++ b/libgo/misc/cgo/testsovar/so_test.go
@@ -21,7 +21,7 @@ func requireTestSOSupported(t *testing.T) {
 	t.Helper()
 	switch runtime.GOARCH {
 	case "arm64":
-		if runtime.GOOS == "darwin" {
+		if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 			t.Skip("No exec facility on iOS.")
 		}
 	case "ppc64":
@@ -74,7 +74,7 @@ func TestSO(t *testing.T) {
 	ext := "so"
 	args := append(gogccflags, "-shared")
 	switch runtime.GOOS {
-	case "darwin":
+	case "darwin", "ios":
 		ext = "dylib"
 		args = append(args, "-undefined", "suppress", "-flat_namespace")
 	case "windows":
@@ -119,7 +119,7 @@ func TestSO(t *testing.T) {
 	cmd.Env = append(os.Environ(), "GOPATH="+GOPATH)
 	if runtime.GOOS != "windows" {
 		s := "LD_LIBRARY_PATH"
-		if runtime.GOOS == "darwin" {
+		if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
 			s = "DYLD_LIBRARY_PATH"
 		}
 		cmd.Env = append(os.Environ(), s+"=.")