@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/syscall/fs_wasip1.go

@@ -944,6 +944,12 @@ func Pipe(fd []int) error {
 }
 
 func RandomGet(b []byte) error {
+	// random_get in WASI preview1 takes a 32-bit length.
+	// If b is larger than 32-bit, return EINVAL. Otherwise overflow occurs,
+	// e.g. if b is exactly 2^32 byte long, no data will be written to b.
+	if uint64(len(b)) > uint64(^size(0)) {
+		return EINVAL
+	}
 	errno := random_get(unsafe.SliceData(b), size(len(b)))
 	return errnoErr(errno)
 }

package/bin/go/src/syscall/js/js.go

@@ -414,7 +414,7 @@ func storeArgs(args []any, argValsDst []Value, argRefsDst []ref) {
 // It panics if v is not a JavaScript object.
 func (v Value) Length() int {
 	if vType := v.Type(); !vType.isObject() {
-		panic(&ValueError{"Value.SetIndex", vType})
+		panic(&ValueError{"Value.Length", vType})
 	}
 	r := valueLength(v.ref)
 	runtime.KeepAlive(v)
@@ -496,7 +496,7 @@ func (v Value) New(args ...any) Value {
 	runtime.KeepAlive(argVals)
 	if !ok {
 		if vType := v.Type(); vType != TypeFunction { // check here to avoid overhead in success case
-			panic(&ValueError{"Value.Invoke", vType})
+			panic(&ValueError{"Value.New", vType})
 		}
 		panic(Error{makeValue(res)})
 	}

package/bin/go/src/syscall/linkname_bsd.go

@@ -15,3 +15,11 @@ import _ "unsafe"
 // Do not remove or change the type signature.
 //
 //go:linkname sysctl
+
+// golang.org/x/sys accesses these in assembly.
+//
+//go:linkname Syscall
+//go:linkname Syscall6
+//go:linkname Syscall9
+//go:linkname RawSyscall
+//go:linkname RawSyscall6

package/bin/go/src/syscall/linkname_libc.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.
 
-//go:build aix || darwin || (openbsd && !mips64) || solaris
+//go:build aix || darwin || openbsd || solaris
 
 package syscall
 

package/bin/go/src/syscall/linkname_openbsd.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build openbsd && !mips64
-
 package syscall
 
 import _ "unsafe"

package/bin/go/src/syscall/mkall.sh

@@ -302,7 +302,7 @@ netbsd_arm64)
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
 	;;
 openbsd_386)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m32"
 	mksyscall="./mksyscall.pl -l32 -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"
@@ -312,7 +312,7 @@ openbsd_386)
 	mkasm="go run mkasm.go"
 	;;
 openbsd_amd64)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m64"
 	mksyscall="./mksyscall.pl -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"
@@ -322,7 +322,7 @@ openbsd_amd64)
 	mkasm="go run mkasm.go"
 	;;
 openbsd_arm)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors"
 	mksyscall="./mksyscall.pl -l32 -openbsd -arm -libc"
 	mksysctl="./mksysctl_openbsd.pl"
@@ -334,7 +334,7 @@ openbsd_arm)
 	mkasm="go run mkasm.go"
 	;;
 openbsd_arm64)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m64"
 	mksyscall="./mksyscall.pl -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"
@@ -345,19 +345,8 @@ openbsd_arm64)
 	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
 	mkasm="go run mkasm.go"
 	;;
-openbsd_mips64)
-	GOOSARCH_in="syscall_openbsd1.go syscall_openbsd_$GOARCH.go"
-	mkerrors="$mkerrors -m64"
-	mksyscall="./mksyscall.pl -openbsd"
-	mksysctl="./mksysctl_openbsd.pl"
-	zsysctl="zsysctl_openbsd.go"
-	mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' | ./mksysnum_openbsd.pl"
-	# Let the type of C char be signed to make the bare syscall
-	# API consistent between platforms.
-	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
-	;;
 openbsd_ppc64)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m64"
 	mksyscall="./mksyscall.pl -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"
@@ -369,7 +358,7 @@ openbsd_ppc64)
 	mkasm="go run mkasm.go"
 	;;
 openbsd_riscv64)
-	GOOSARCH_in="syscall_openbsd_libc.go syscall_openbsd_$GOARCH.go"
+	GOOSARCH_in="syscall_openbsd_$GOARCH.go"
 	mkerrors="$mkerrors -m64"
 	mksyscall="./mksyscall.pl -openbsd -libc"
 	mksysctl="./mksysctl_openbsd.pl"

package/bin/go/src/syscall/syscall_aix.go

@@ -21,7 +21,12 @@ func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 
 // Implemented in runtime/syscall_aix.go.
+// Accessed in assembly in x/sys/unix and x/sys/cpu.
+//
+//go:linkname rawSyscall6
 func rawSyscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+//go:linkname syscall6
 func syscall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 
 // Constant expected by package but not supported

package/bin/go/src/syscall/syscall_linux_386.go

@@ -74,6 +74,10 @@ func mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int6
 
 // Underlying system call writes to newoffset via pointer.
 // Implemented in assembly to avoid allocation.
+//
+// Accessed via assembly in x/sys/unix.
+//
+//go:linkname seek
 func seek(fd int, offset int64, whence int) (newoffset int64, err Errno)
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
@@ -121,7 +125,12 @@ const (
 	_SENDMMSG    = 20
 )
 
+// socketcall and rawsocketcall are accessed via assembly in x/sys/unix and x/net.
+//
+//go:linkname socketcall
 func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
+
+//go:linkname rawsocketcall
 func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
 
 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {

package/bin/go/src/syscall/syscall_linux_amd64.go

@@ -4,6 +4,8 @@
 
 package syscall
 
+import _ "unsafe" // for linkname
+
 const (
 	_SYS_setgroups  = SYS_SETGROUPS
 	_SYS_clone3     = 435
@@ -71,7 +73,10 @@ func Lstat(path string, stat *Stat_t) (err error) {
 
 //sys	futimesat(dirfd int, path string, times *[2]Timeval) (err error)
 
+// Accessed via assembly in x/sys/unix.
+//
 //go:noescape
+//go:linkname gettimeofday
 func gettimeofday(tv *Timeval) (err Errno)
 
 func Gettimeofday(tv *Timeval) (err error) {

package/bin/go/src/syscall/syscall_linux_arm.go

@@ -23,6 +23,10 @@ func setTimeval(sec, usec int64) Timeval {
 
 // Underlying system call writes to newoffset via pointer.
 // Implemented in assembly to avoid allocation.
+//
+// Accessed via assembly in x/sys/unix.
+//
+//go:linkname seek
 func seek(fd int, offset int64, whence int) (newoffset int64, err Errno)
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {

package/bin/go/src/syscall/syscall_linux_arm64.go

@@ -119,6 +119,9 @@ func Time(t *Time_t) (Time_t, error) {
 }
 
 func Utime(path string, buf *Utimbuf) error {
+	if buf == nil {
+		return Utimes(path, nil)
+	}
 	tv := []Timeval{
 		{Sec: buf.Actime},
 		{Sec: buf.Modtime},

package/bin/go/src/syscall/syscall_linux_loong64.go

@@ -164,6 +164,9 @@ func Time(t *Time_t) (Time_t, error) {
 }
 
 func Utime(path string, buf *Utimbuf) error {
+	if buf == nil {
+		return Utimes(path, nil)
+	}
 	tv := []Timeval{
 		{Sec: buf.Actime},
 		{Sec: buf.Modtime},

package/bin/go/src/syscall/syscall_linux_mipsx.go

@@ -15,6 +15,10 @@ const (
 	_SYS_fchmodat2  = 4452
 )
 
+// Syscall9 is accessed via assembly in x/sys/unix.
+//
+//go:linkname Syscall9
+
 func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno)
 
 //sys	Dup2(oldfd int, newfd int) (err error)

package/bin/go/src/syscall/syscall_linux_riscv64.go

@@ -123,6 +123,9 @@ func Time(t *Time_t) (Time_t, error) {
 }
 
 func Utime(path string, buf *Utimbuf) error {
+	if buf == nil {
+		return Utimes(path, nil)
+	}
 	tv := []Timeval{
 		{Sec: buf.Actime},
 		{Sec: buf.Modtime},

package/bin/go/src/syscall/syscall_linux_s390x.go

@@ -111,7 +111,12 @@ const (
 	_SENDMMSG    = 20
 )
 
+// socketcall and rawsocketcall are accessed via assembly in x/net.
+//
+//go:linkname socketcall
 func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
+
+//go:linkname rawsocketcall
 func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err Errno)
 
 func accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) {

package/bin/go/src/syscall/syscall_openbsd.go

@@ -1,4 +1,4 @@
-// Copyright 2009,2010 The Go Authors. All rights reserved.
+// Copyright 2009,2010,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.
 
@@ -12,7 +12,71 @@
 
 package syscall
 
-import "unsafe"
+import (
+	"internal/abi"
+	"unsafe"
+)
+
+var dupTrampoline = abi.FuncPCABI0(libc_dup3_trampoline)
+
+func init() {
+	execveLibc = execve
+}
+
+func syscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
+	// OpenBSD 7.5+ no longer supports indirect syscalls. A number of Go
+	// packages make use of syscall.Syscall with SYS_IOCTL since it is
+	// not well supported by golang.org/x/sys/unix. Reroute this system
+	// call number to the respective libc stub so that it continues to
+	// work for the time being. See #63900 for further details.
+	if trap == SYS_IOCTL {
+		return syscallX(abi.FuncPCABI0(libc_ioctl_trampoline), a1, a2, a3)
+	}
+	return 0, 0, ENOSYS
+}
+
+func syscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
+	// OpenBSD 7.5+ no longer supports indirect syscalls. A number of Go
+	// packages make use of syscall.Syscall with SYS___SYSCTL since it is
+	// not well supported by golang.org/x/sys/unix. Reroute this system
+	// call number to the respective libc stub so that it continues to
+	// work for the time being. See #63900 for further details.
+	if trap == SYS___SYSCTL {
+		return syscall6X(abi.FuncPCABI0(libc_sysctl_trampoline), a1, a2, a3, a4, a5, a6)
+	}
+	return 0, 0, ENOSYS
+}
+
+func rawSyscallInternal(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
+	return 0, 0, ENOSYS
+}
+
+func rawSyscall6Internal(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno) {
+	return 0, 0, ENOSYS
+}
+
+func syscall9Internal(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+	return 0, 0, ENOSYS
+}
+
+// Implemented in the runtime package (runtime/sys_openbsd.go)
+func syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscallX(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+func syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+func rawSyscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10 uintptr) (r1, r2 uintptr, err Errno)
+
+func syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+	return syscall10(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0)
+}
+func syscall9X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) {
+	return syscall10X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, 0)
+}
 
 func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
@@ -209,3 +273,14 @@ func Getfsstat(buf []Statfs_t, flags int) (n int, err error) {
 //sys	munmap(addr uintptr, length uintptr) (err error)
 //sys	getfsstat(stat *Statfs_t, bufsize uintptr, flags int) (n int, err error)
 //sys	utimensat(dirfd int, path string, times *[2]Timespec, flag int) (err error)
+//sys	readlen(fd int, buf *byte, nbuf int) (n int, err error) = SYS_read
+//sys	Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_lseek
+//sys	getcwd(buf []byte) (n int, err error)
+//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error)
+//sysnb fork() (pid int, err error)
+//sysnb execve(path *byte, argv **byte, envp **byte) (err error)
+//sysnb exit(res int) (err error)
+//sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)
+//sys   fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
+//sys   unlinkat(fd int, path string, flags int) (err error)
+//sys   openat(fd int, path string, flags int, perm uint32) (fdret int, err error)

package/bin/go/src/syscall/syscall_plan9.go

@@ -14,6 +14,7 @@ package syscall
 import (
 	"errors"
 	"internal/oserror"
+	"internal/strconv"
 	"runtime"
 	"unsafe"
 )
@@ -21,6 +22,19 @@ import (
 const ImplementsGetwd = true
 const bitSize16 = 2
 
+// Errno is not used with GOOS plan9.
+//
+// It exists because because the Go 1 API contract
+// (api/go1.txt's "pkg syscall, type Errno uintptr")
+// says it exists, and so code in the ecosystem often
+// assume it exists. This lets portable code be written
+// without build-tagged files, using runtime.GOOS checks instead.
+type Errno uintptr
+
+func (e Errno) Error() string   { return "errno " + strconv.Itoa(int(e)) }
+func (e Errno) Temporary() bool { return false }
+func (e Errno) Timeout() bool   { return false }
+
 // ErrorString implements Error's String method by returning itself.
 //
 // ErrorString values can be tested against error values using [errors.Is].
@@ -102,6 +116,13 @@ var (
 // creation of IPv6 sockets to return [EAFNOSUPPORT].
 var SocketDisableIPv6 bool
 
+// x/sys/plan9 accesses these in assembly.
+//
+//go:linkname Syscall
+//go:linkname Syscall6
+//go:linkname RawSyscall
+//go:linkname RawSyscall6
+
 func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
 func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err ErrorString)
 func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
@@ -213,6 +234,10 @@ func Pipe(p []int) (err error) {
 
 // Underlying system call writes to newoffset via pointer.
 // Implemented in assembly to avoid allocation.
+//
+// Accessed via assembly from x/sys/plan9.
+//
+//go:linkname seek
 func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
 
 func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {

package/bin/go/src/syscall/syscall_solaris.go

@@ -22,7 +22,15 @@ func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
 func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 
 // Implemented in asm_solaris_amd64.s.
+//
+// Accessed via assembly in x/sys/unix.
+//
+//go:linkname rawSysvicall6
 func rawSysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
+
+// Accessed via assembly in x/sys/unix and x/net/lif.
+//
+//go:linkname sysvicall6
 func sysvicall6(trap, nargs, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
 
 type SockaddrDatalink struct {
@@ -71,6 +79,9 @@ func Pipe2(p []int, flags int) error {
 	return err
 }
 
+//go:cgo_ldflag "-lxnet"
+//go:cgo_ldflag "-lsocket"
+
 //sys   accept4(s int, rsa *RawSockaddrAny, addrlen *_Socklen, flags int) (fd int, err error) = libsocket.accept4
 
 func Accept4(fd int, flags int) (int, Sockaddr, error) {

package/bin/go/src/syscall/syscall_unix.go

@@ -385,6 +385,9 @@ func recvmsgInet6(fd int, p, oob []byte, flags int, from *SockaddrInet6) (n, oob
 func Recvmsg(fd int, p, oob []byte, flags int) (n, oobn int, recvflags int, from Sockaddr, err error) {
 	var rsa RawSockaddrAny
 	n, oobn, recvflags, err = recvmsgRaw(fd, p, oob, flags, &rsa)
+	if err != nil {
+		return
+	}
 	// source address is only specified if the socket is unconnected
 	if rsa.Addr.Family != AF_UNSPEC {
 		from, err = anyToSockaddr(&rsa)
@@ -522,6 +525,22 @@ func Socketpair(domain, typ, proto int) (fd [2]int, err error) {
 	return
 }
 
+// Sendfile copies up to count bytes from file descriptor infd to file descriptor outfd.
+//
+// It wraps the sendfile system call. The behavior varies by operating system,
+// particularly regarding the offset argument and how partial writes are reported.
+//
+// On Linux, if offset is nil, Sendfile uses and updates the current file
+// position of infd. If offset is non-nil, the current file position is
+// unchanged, and the offset pointer is updated to reflect the bytes written.
+// A non-nil error typically implies that no bytes were written.
+//
+// On BSD-derived systems (including macOS), if offset is nil, Sendfile panics.
+// The offset argument is not updated by the system call; the caller must manually
+// update the offset using the number of bytes written. These systems may
+// return a non-zero byte count together with an error (for example, EAGAIN).
+//
+// For precise semantics, see the system documentation (e.g., man 2 sendfile).
 func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
 	if race.Enabled {
 		race.ReleaseMerge(unsafe.Pointer(&ioSync))

package/bin/go/src/syscall/syscall_windows.go

@@ -717,7 +717,7 @@ func Utimes(path string, tv []Timeval) (err error) {
 	if tv[0].Nanoseconds() != 0 {
 		a = NsecToFiletime(tv[0].Nanoseconds())
 	}
-	if tv[0].Nanoseconds() != 0 {
+	if tv[1].Nanoseconds() != 0 {
 		w = NsecToFiletime(tv[1].Nanoseconds())
 	}
 	return SetFileTime(h, nil, &a, &w)

package/bin/go/src/testing/synctest/synctest.go

@@ -268,6 +268,7 @@ package synctest
 import (
 	"internal/synctest"
 	"testing"
+	"time"
 	_ "unsafe" // for linkname
 )
 
@@ -309,3 +310,23 @@ func testingSynctestTest(t *testing.T, f func(*testing.T)) bool
 func Wait() {
 	synctest.Wait()
 }
+
+// Sleep blocks until the current bubble's clock has advanced
+// by the duration of d and every goroutine within the current bubble,
+// other than the current goroutine, is durably blocked.
+//
+// This is exactly equivalent to
+//
+//	time.Sleep(d)
+//	synctest.Wait()
+//
+// In tests, this is often preferable to calling only [time.Sleep].
+// If the test itself and another goroutine running the system under test
+// sleeps for the exact same amount of time, it's unpredictable which
+// of the two goroutines will run first. The test itself usually wants
+// to wait for the system under test to "settle" after sleeping.
+// This is what Sleep accomplishes.
+func Sleep(d time.Duration) {
+	time.Sleep(d)
+	Wait()
+}