all: remove scattered remnants of darwin/386

This removes all conditions and conditional code (that I could find)
that depended on darwin/386.

Fixes #37610.

Change-Id: I630d9ea13613fb7c0bcdb981e8367facff250ba0
Reviewed-on: https://go-review.googlesource.com/c/go/+/227582
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

diff --git a/api/except.txt b/api/except.txt
index 63164018973dc8e5dd6f2ca1c0271f4bdc0d7804..ccfdf06c55d469df40eefd530a0d5a11161a1d44 100644 (file)
--- a/api/except.txt
+++ b/api/except.txt
@@ -8,10 +8,6 @@ pkg os (linux-arm), const O_SYNC = 4096
 pkg os (linux-arm-cgo), const O_SYNC = 4096
 pkg os (linux-arm), const O_SYNC = 1052672
 pkg os (linux-arm-cgo), const O_SYNC = 1052672
-pkg syscall (darwin-386), const ImplementsGetwd = false
-pkg syscall (darwin-386), func Fchflags(string, int) error
-pkg syscall (darwin-386-cgo), const ImplementsGetwd = false
-pkg syscall (darwin-386-cgo), func Fchflags(string, int) error
 pkg syscall (darwin-amd64), const ImplementsGetwd = false
 pkg syscall (darwin-amd64), func Fchflags(string, int) error
 pkg syscall (darwin-amd64-cgo), const ImplementsGetwd = false

diff --git a/misc/cgo/test/sigaltstack.go b/misc/cgo/test/sigaltstack.go
index f501f9ba3aec120ed985922625781c0a85c45174..8dfa1cb5adb4e1eddd029ffda9fb0afab5951ead 100644 (file)
--- a/misc/cgo/test/sigaltstack.go
+++ b/misc/cgo/test/sigaltstack.go
@@ -64,8 +64,6 @@ func testSigaltstack(t *testing.T) {
        switch {
        case runtime.GOOS == "solaris", runtime.GOOS == "illumos", runtime.GOOS == "darwin" && runtime.GOARCH == "arm64":
                t.Skipf("switching signal stack not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
-       case runtime.GOOS == "darwin" && runtime.GOARCH == "386":
-               t.Skipf("sigaltstack fails on darwin/386")
        }
 
        C.changeSignalStack()

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index a7ef8f27d576ab83d7062cd19596cddbf28e7249..b9b78bf57de43b1af5579c4a2918ac64e5df5eba 100644 (file)
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -902,7 +902,7 @@ func (t *tester) extLink() bool {
        switch pair {
        case "aix-ppc64",
                "android-arm", "android-arm64",
-               "darwin-386", "darwin-amd64", "darwin-arm64",
+               "darwin-amd64", "darwin-arm64",
                "dragonfly-amd64",
                "freebsd-386", "freebsd-amd64", "freebsd-arm",
                "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-mips64", "linux-mips64le", "linux-mips", "linux-mipsle", "linux-s390x",
@@ -963,7 +963,7 @@ func (t *tester) supportedBuildmode(mode string) bool {
                }
                switch pair {
                case "aix-ppc64",
-                       "darwin-386", "darwin-amd64", "darwin-arm64",
+                       "darwin-amd64", "darwin-arm64",
                        "linux-amd64", "linux-386", "linux-ppc64le", "linux-s390x",
                        "freebsd-amd64",
                        "windows-amd64", "windows-386":
@@ -973,7 +973,7 @@ func (t *tester) supportedBuildmode(mode string) bool {
        case "c-shared":
                switch pair {
                case "linux-386", "linux-amd64", "linux-arm", "linux-arm64", "linux-ppc64le", "linux-s390x",
-                       "darwin-amd64", "darwin-386",
+                       "darwin-amd64",
                        "freebsd-amd64",
                        "android-arm", "android-arm64", "android-386",
                        "windows-amd64", "windows-386":
@@ -1069,7 +1069,7 @@ func (t *tester) cgoTest(dt *distTest) error {
 
        pair := gohostos + "-" + goarch
        switch pair {
-       case "darwin-386", "darwin-amd64",
+       case "darwin-amd64",
                "openbsd-386", "openbsd-amd64",
                "windows-386", "windows-amd64":
                // test linkmode=external, but __thread not supported, so skip testtls.

diff --git a/src/cmd/go/testdata/script/link_syso_issue33139.txt b/src/cmd/go/testdata/script/link_syso_issue33139.txt
index 03169bf5e9f1ddcd6c6428bafe0b7226dfd20b69..46b0ef4200e0746776ea699d61db290ca2106756 100644 (file)
--- a/src/cmd/go/testdata/script/link_syso_issue33139.txt
+++ b/src/cmd/go/testdata/script/link_syso_issue33139.txt
@@ -12,10 +12,6 @@
 # See: https://github.com/golang/go/issues/36739
 [linux] [riscv64] skip
 
-# External linking is not supported on darwin/386 (10.14+).
-# See: https://github.com/golang/go/issues/31751
-[darwin] [386] skip
-
 cc -c -o syso/objTestImpl.syso syso/src/objTestImpl.c
 go build -ldflags='-linkmode=external' ./cmd/main.go
 

diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go
index efc07af56beb21811a20f083a83267450b66d78a..c27b3b986d8b8169102dde85e0706f7b05115bee 100644 (file)
--- a/src/cmd/internal/sys/supported.go
+++ b/src/cmd/internal/sys/supported.go
@@ -69,7 +69,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool {
                case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/s390x",
                        "android/amd64", "android/arm", "android/arm64", "android/386",
                        "freebsd/amd64",
-                       "darwin/amd64", "darwin/386",
+                       "darwin/amd64",
                        "windows/amd64", "windows/386":
                        return true
                }

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index f7b8e04ddfde447e543bd5028608da771f7383ef..62cf2262bd720f7ca17ff2e283e1920c2aa2141c 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -540,7 +540,7 @@ func (ctxt *Link) loadlib() {
        // We now have enough information to determine the link mode.
        determineLinkMode(ctxt)
 
-       if ctxt.LinkMode == LinkExternal && !iscgo && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && (ctxt.Arch.Family == sys.AMD64 || ctxt.Arch.Family == sys.I386)) {
+       if ctxt.LinkMode == LinkExternal && !iscgo && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
                // This indicates a user requested -linkmode=external.
                // The startup code uses an import of runtime/cgo to decide
                // whether to initialize the TLS.  So give it one. This could

diff --git a/src/cmd/link/internal/ld/sym.go b/src/cmd/link/internal/ld/sym.go
index 2284963f59646ad990ed682fbeaf1e8dcf465deb..ff47c688b67fb39143a364accb1529955e299ff3 100644 (file)
--- a/src/cmd/link/internal/ld/sym.go
+++ b/src/cmd/link/internal/ld/sym.go
@@ -95,14 +95,11 @@ func (ctxt *Link) computeTLSOffset() {
 
                        /*
                         * For x86, Apple has reserved a slot in the TLS for Go. See issue 23617.
-                        * That slot is at offset 0x30 on amd64, and 0x18 on 386.
+                        * That slot is at offset 0x30 on amd64.
                         * The slot will hold the G pointer.
-                        * These constants should match those in runtime/sys_darwin_{386,amd64}.s
-                        * and runtime/cgo/gcc_darwin_{386,amd64}.c.
+                        * These constants should match those in runtime/sys_darwin_amd64.s
+                        * and runtime/cgo/gcc_darwin_amd64.c.
                         */
-               case sys.I386:
-                       ctxt.Tlsoffset = 0x18
-
                case sys.AMD64:
                        ctxt.Tlsoffset = 0x30
 

diff --git a/src/cmd/oldlink/internal/ld/lib.go b/src/cmd/oldlink/internal/ld/lib.go
index a6c86af6cfb8736dc5f472023a2ad25d9e2fd90a..0fc786f1bf67d741be1f4445ac37dbb79c33d85e 100644 (file)
--- a/src/cmd/oldlink/internal/ld/lib.go
+++ b/src/cmd/oldlink/internal/ld/lib.go
@@ -435,7 +435,7 @@ func (ctxt *Link) loadlib() {
        // We now have enough information to determine the link mode.
        determineLinkMode(ctxt)
 
-       if ctxt.LinkMode == LinkExternal && !iscgo && ctxt.LibraryByPkg["runtime/cgo"] == nil && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && (ctxt.Arch.Family == sys.AMD64 || ctxt.Arch.Family == sys.I386)) {
+       if ctxt.LinkMode == LinkExternal && !iscgo && ctxt.LibraryByPkg["runtime/cgo"] == nil && !(objabi.GOOS == "darwin" && ctxt.BuildMode != BuildModePlugin && ctxt.Arch.Family == sys.AMD64) {
                // This indicates a user requested -linkmode=external.
                // The startup code uses an import of runtime/cgo to decide
                // whether to initialize the TLS.  So give it one. This could

diff --git a/src/cmd/oldlink/internal/ld/sym.go b/src/cmd/oldlink/internal/ld/sym.go
index a470ddbca89e5d3367295e2683e99e673134456c..4f697d06272f5ec6a3c83e21a064fc2c875823ab 100644 (file)
--- a/src/cmd/oldlink/internal/ld/sym.go
+++ b/src/cmd/oldlink/internal/ld/sym.go
@@ -93,14 +93,11 @@ func (ctxt *Link) computeTLSOffset() {
 
                        /*
                         * For x86, Apple has reserved a slot in the TLS for Go. See issue 23617.
-                        * That slot is at offset 0x30 on amd64, and 0x18 on 386.
+                        * That slot is at offset 0x30 on amd64.
                         * The slot will hold the G pointer.
                         * These constants should match those in runtime/sys_darwin_{386,amd64}.s
                         * and runtime/cgo/gcc_darwin_{386,amd64}.c.
                         */
-               case sys.I386:
-                       ctxt.Tlsoffset = 0x18
-
                case sys.AMD64:
                        ctxt.Tlsoffset = 0x30
 

diff --git a/src/go/build/doc.go b/src/go/build/doc.go
index 47dec5a05df0bbd32be7912222c24733fb020dab..bf60ff7fc27e7ab46d71b5f673a0637d403ced0c 100644 (file)
--- a/src/go/build/doc.go
+++ b/src/go/build/doc.go
@@ -86,11 +86,11 @@
 // of the individual constraints. That is, the build constraints:
 //
 //     // +build linux darwin
-//     // +build 386
+//     // +build amd64
 //
 // corresponds to the boolean formula:
 //
-//     (linux OR darwin) AND 386
+//     (linux OR darwin) AND amd64
 //
 // During a particular build, the following words are satisfied:
 //

diff --git a/src/os/wait_waitid.go b/src/os/wait_waitid.go
index c57bace90f36a72531a64415823714df61d30fe3..6c904e54db1c51fb4678f5d85bcaeb81cef4f0dd 100644 (file)
--- a/src/os/wait_waitid.go
+++ b/src/os/wait_waitid.go
@@ -23,8 +23,7 @@ const _P_PID = 1
 func (p *Process) blockUntilWaitable() (bool, error) {
        // The waitid system call expects a pointer to a siginfo_t,
        // which is 128 bytes on all GNU/Linux systems.
-       // On Darwin, it requires greater than or equal to 64 bytes
-       // for darwin/386 and 104 bytes for darwin/amd64.
+       // On darwin/amd64, it requires 104 bytes.
        // We don't care about the values it returns.
        var siginfo [16]uint64
        psig := &siginfo[0]

diff --git a/src/runtime/asm_386.s b/src/runtime/asm_386.s
index 8f0ec08f80da63ad3bd56c9a1502e74ab5ad12a6..11863fba39a751239b6baa9e436c20478f51fbbc 100644 (file)
--- a/src/runtime/asm_386.s
+++ b/src/runtime/asm_386.s
@@ -199,10 +199,6 @@ needtls:
        // skip runtime·ldt0setup(SB) and tls test on Plan 9 in all cases
        JMP     ok
 #endif
-#ifdef GOOS_darwin
-       // skip runtime·ldt0setup(SB) on Darwin
-       JMP     ok
-#endif
 
        // set up %gs
        CALL    ldt0setup<>(SB)

diff --git a/src/runtime/defs_darwin.go b/src/runtime/defs_darwin.go
index de1489f032632b86140421ea09117a6c5731e8a8..cc8c475387963886499c7b4b3d8ccd876e793b3c 100644 (file)
--- a/src/runtime/defs_darwin.go
+++ b/src/runtime/defs_darwin.go
@@ -8,7 +8,6 @@
 Input to cgo.
 
 GOARCH=amd64 go tool cgo -cdefs defs_darwin.go >defs_darwin_amd64.h
-GOARCH=386 go tool cgo -cdefs defs_darwin.go >defs_darwin_386.h
 */
 
 package runtime

diff --git a/src/runtime/signal_386.go b/src/runtime/signal_386.go
index bceffa6f4e03d3a878e160106530eae009c57861..2f390f12f7d10c0341e8ceebbf5e6e14acc17ebe 100644 (file)
--- a/src/runtime/signal_386.go
+++ b/src/runtime/signal_386.go
@@ -37,22 +37,6 @@ func (c *sigctxt) fault() uintptr { return uintptr(c.sigaddr()) }
 
 // preparePanic sets up the stack to look like a call to sigpanic.
 func (c *sigctxt) preparePanic(sig uint32, gp *g) {
-       if GOOS == "darwin" {
-               // Work around Leopard bug that doesn't set FPE_INTDIV.
-               // Look at instruction to see if it is a divide.
-               // Not necessary in Snow Leopard (si_code will be != 0).
-               if sig == _SIGFPE && gp.sigcode0 == 0 {
-                       pc := (*[4]byte)(unsafe.Pointer(gp.sigpc))
-                       i := 0
-                       if pc[i] == 0x66 { // 16-bit instruction prefix
-                               i++
-                       }
-                       if pc[i] == 0xF6 || pc[i] == 0xF7 {
-                               gp.sigcode0 = _FPE_INTDIV
-                       }
-               }
-       }
-
        pc := uintptr(c.eip())
        sp := uintptr(c.esp())
 

diff --git a/src/runtime/sys_darwin.go b/src/runtime/sys_darwin.go
index d2d1822aaba58184fe977121beabdb0adf75aab1..1b136f88a8e4e430cc1c39036225896c0cd6e6d0 100644 (file)
--- a/src/runtime/sys_darwin.go
+++ b/src/runtime/sys_darwin.go
@@ -67,6 +67,17 @@ func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
 }
 func syscall()
 
+//go:linkname syscall_syscallX syscall.syscallX
+//go:nosplit
+//go:cgo_unsafe_args
+func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
+       entersyscallblock()
+       libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
+       exitsyscall()
+       return
+}
+func syscallX()
+
 //go:linkname syscall_syscall6 syscall.syscall6
 //go:nosplit
 //go:cgo_unsafe_args

diff --git a/src/runtime/sys_darwin_64.go b/src/runtime/sys_darwin_64.go
deleted file mode 100644 (file)
index 07b0bb5..0000000
--- a/src/runtime/sys_darwin_64.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// 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.
-
-// +build darwin
-// +build amd64 arm64
-
-package runtime
-
-import "unsafe"
-
-//go:linkname syscall_syscallX syscall.syscallX
-//go:nosplit
-//go:cgo_unsafe_args
-func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
-       entersyscallblock()
-       libcCall(unsafe.Pointer(funcPC(syscallX)), unsafe.Pointer(&fn))
-       exitsyscall()
-       return
-}
-func syscallX()

diff --git a/src/runtime/vlrt.go b/src/runtime/vlrt.go
index e4d1be5d8a5e69b84a4928315f1e75196db8ef37..87370f870d16fbd791e7b1e0a596893a290f48ab 100644 (file)
--- a/src/runtime/vlrt.go
+++ b/src/runtime/vlrt.go
@@ -130,9 +130,6 @@ func uint64mod(n, d uint64) uint64 {
        return r
 }
 
-//go:nosplit
-// nosplit because division is used in syscall context in nanotime on darwin/386
-// where stack splits are not allowed.
 func int64div(n, d int64) int64 {
        // Check for 32 bit operands
        if int64(int32(n)) == n && int64(int32(d)) == d {

diff --git a/src/syscall/mkall.sh b/src/syscall/mkall.sh
index 7e624c5a21b34d5f653d08521b00eea8d89703c5..826512a177e192b1ff83aef7cac925878b9252fb 100755 (executable)
--- a/src/syscall/mkall.sh
+++ b/src/syscall/mkall.sh
@@ -121,13 +121,6 @@ aix_ppc64)
        mksyscall="./mksyscall_libc.pl -aix"
        mktypes="GOARCH=$GOARCH go tool cgo -godefs"
        ;;
-darwin_386)
-       mkerrors="$mkerrors -m32"
-       mksyscall="./mksyscall.pl -l32 -darwin"
-       mksysnum="./mksysnum_darwin.pl /usr/include/sys/syscall.h"
-       mktypes="GOARCH=$GOARCH go tool cgo -godefs"
-       mkasm="go run mkasm_darwin.go"
-       ;;
 darwin_amd64)
        mkerrors="$mkerrors -m64"
        mksyscall="./mksyscall.pl -darwin"