@ttsc/darwin-x64 0.10.1 → 0.10.2

package/bin/go/src/internal/syscall/windows/zsyscall_windows.go

@@ -62,6 +62,8 @@ var (
 	procOpenThreadToken                   = modadvapi32.NewProc("OpenThreadToken")
 	procQueryServiceStatus                = modadvapi32.NewProc("QueryServiceStatus")
 	procRevertToSelf                      = modadvapi32.NewProc("RevertToSelf")
+	procSetEntriesInAclW                  = modadvapi32.NewProc("SetEntriesInAclW")
+	procSetNamedSecurityInfoW             = modadvapi32.NewProc("SetNamedSecurityInfoW")
 	procSetTokenInformation               = modadvapi32.NewProc("SetTokenInformation")
 	procProcessPrng                       = modbcryptprimitives.NewProc("ProcessPrng")
 	procGetAdaptersAddresses              = modiphlpapi.NewProc("GetAdaptersAddresses")
@@ -236,6 +238,31 @@ func RevertToSelf() (err error) {
 	return
 }
 
+func SetEntriesInAcl(countExplicitEntries uint32, explicitEntries *EXPLICIT_ACCESS, oldACL *ACL, newACL **ACL) (ret error) {
+	r0, _, _ := syscall.SyscallN(procSetEntriesInAclW.Addr(), uintptr(countExplicitEntries), uintptr(unsafe.Pointer(explicitEntries)), uintptr(unsafe.Pointer(oldACL)), uintptr(unsafe.Pointer(newACL)))
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
+func SetNamedSecurityInfo(objectName string, objectType uint32, securityInformation uint32, owner *syscall.SID, group *syscall.SID, dacl *ACL, sacl *ACL) (ret error) {
+	var _p0 *uint16
+	_p0, ret = syscall.UTF16PtrFromString(objectName)
+	if ret != nil {
+		return
+	}
+	return _SetNamedSecurityInfo(_p0, objectType, securityInformation, owner, group, dacl, sacl)
+}
+
+func _SetNamedSecurityInfo(objectName *uint16, objectType uint32, securityInformation uint32, owner *syscall.SID, group *syscall.SID, dacl *ACL, sacl *ACL) (ret error) {
+	r0, _, _ := syscall.SyscallN(procSetNamedSecurityInfoW.Addr(), uintptr(unsafe.Pointer(objectName)), uintptr(objectType), uintptr(securityInformation), uintptr(unsafe.Pointer(owner)), uintptr(unsafe.Pointer(group)), uintptr(unsafe.Pointer(dacl)), uintptr(unsafe.Pointer(sacl)))
+	if r0 != 0 {
+		ret = syscall.Errno(r0)
+	}
+	return
+}
+
 func SetTokenInformation(tokenHandle syscall.Token, tokenInformationClass uint32, tokenInformation unsafe.Pointer, tokenInformationLength uint32) (err error) {
 	r1, _, e1 := syscall.SyscallN(procSetTokenInformation.Addr(), uintptr(tokenHandle), uintptr(tokenInformationClass), uintptr(tokenInformation), uintptr(tokenInformationLength))
 	if r1 == 0 {

package/bin/go/src/net/cgo_unix.go

@@ -342,7 +342,10 @@ func cgoResSearch(hostname string, rtype, class int) ([]dnsmessage.Resource, err
 	// useful in the response, even though there *is* a response.
 	bufSize := maxDNSPacketSize
 	buf := (*_C_uchar)(_C_malloc(uintptr(bufSize)))
-	defer _C_free(unsafe.Pointer(buf))
+	defer func() {
+		// Free in a closure which captures buf to pick up a reallocated buffer from below.
+		_C_free(unsafe.Pointer(buf))
+	}()
 
 	s, err := syscall.BytePtrFromString(hostname)
 	if err != nil {

package/bin/go/src/net/http/doc.go

@@ -105,5 +105,4 @@ Alternatively, the following GODEBUG settings are currently supported:
 The "omithttp2" build tag may be used to disable the HTTP/2 implementation
 contained in the http package.
 */
-
 package http

package/bin/go/src/net/http/h2_bundle.go

@@ -10152,6 +10152,9 @@ func (rl *http2clientConnReadLoop) processSettingsNoWrite(f *http2SettingsFrame)
 
 	var seenMaxConcurrentStreams bool
 	err := f.ForeachSetting(func(s http2Setting) error {
+		if err := s.Valid(); err != nil {
+			return err
+		}
 		switch s.ID {
 		case http2SettingMaxFrameSize:
 			cc.maxFrameSize = s.Val
@@ -10183,9 +10186,6 @@ func (rl *http2clientConnReadLoop) processSettingsNoWrite(f *http2SettingsFrame)
 			cc.henc.SetMaxDynamicTableSize(s.Val)
 			cc.peerMaxHeaderTableSize = s.Val
 		case http2SettingEnableConnectProtocol:
-			if err := s.Valid(); err != nil {
-				return err
-			}
 			// If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL,
 			// we require that it do so in the first SETTINGS frame.
 			//

package/bin/go/src/net/http/httputil/reverseproxy.go

@@ -10,6 +10,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"internal/godebug"
 	"io"
 	"log"
 	"mime"
@@ -922,11 +923,24 @@ func (c switchProtocolCopier) copyToBackend(errc chan<- error) {
 	errc <- errCopyDone
 }
 
+var urlmaxqueryparams = godebug.New("urlmaxqueryparams")
+
+// Keep this in sync with net/url.
+const defaultMaxParams = 10000
+
 func cleanQueryParams(s string) string {
 	reencode := func(s string) string {
 		v, _ := url.ParseQuery(s)
 		return v.Encode()
 	}
+	if urlmaxqueryparams.Value() != "" {
+		// Always reencode when a non-default urlmaxqueryparams is set.
+		return reencode(s)
+	}
+	if numParams := strings.Count(s, "&") + 1; numParams > defaultMaxParams {
+		// Too many query parameters.
+		return reencode(s)
+	}
 	for i := 0; i < len(s); {
 		switch s[i] {
 		case ';':

package/bin/go/src/net/lookup_windows.go

@@ -215,8 +215,13 @@ func (r *Resolver) lookupPort(ctx context.Context, network, service string) (int
 		hints.Family = syscall.AF_INET6
 	}
 
+	servicep, err := syscall.UTF16PtrFromString(service)
+	if err != nil {
+		return 0, newDNSError(err, network+"/"+service, "")
+	}
+
 	var result *syscall.AddrinfoW
-	e := syscall.GetAddrInfoW(nil, syscall.StringToUTF16Ptr(service), &hints, &result)
+	e := syscall.GetAddrInfoW(nil, servicep, &hints, &result)
 	if e != nil {
 		if port, err := lookupPortMap(network, service); err == nil {
 			return port, nil
@@ -269,7 +274,12 @@ func (r *Resolver) lookupCNAME(ctx context.Context, name string) (string, error)
 	}
 	defer syscall.DnsRecordListFree(rec, 1)
 
-	resolved := resolveCNAME(syscall.StringToUTF16Ptr(name), rec)
+	namep, err := syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return "", newDNSError(err, name, "")
+	}
+
+	resolved := resolveCNAME(namep, rec)
 	cname := windows.UTF16PtrToString(resolved)
 	return absDomainName(cname), nil
 }
@@ -415,7 +425,10 @@ const dnsSectionMask = 0x0003
 
 // returns only results applicable to name and resolves CNAME entries.
 func validRecs(r *syscall.DNSRecord, dnstype uint16, name string) []*syscall.DNSRecord {
-	cname := syscall.StringToUTF16Ptr(name)
+	cname, err := syscall.UTF16PtrFromString(name)
+	if err != nil {
+		return nil
+	}
 	if dnstype != syscall.DNS_TYPE_CNAME {
 		cname = resolveCNAME(cname, r)
 	}

package/bin/go/src/net/mail/message.go

@@ -575,8 +575,10 @@ func (p *addrParser) consumeAddrSpec() (spec string, err error) {
 func (p *addrParser) consumePhrase() (phrase string, err error) {
 	debug.Printf("consumePhrase: [%s]", p.s)
 	// phrase = 1*word
-	var words []string
-	var isPrevEncoded bool
+	var (
+		words []string
+		sb    strings.Builder
+	)
 	for {
 		// obs-phrase allows CFWS after one word
 		if len(words) > 0 {
@@ -608,13 +610,22 @@ func (p *addrParser) consumePhrase() (phrase string, err error) {
 			break
 		}
 		debug.Printf("consumePhrase: consumed %q", word)
-		if isPrevEncoded && isEncoded {
-			words[len(words)-1] += word
-		} else {
+		switch {
+		case isEncoded:
+			sb.WriteString(word)
+		case !isEncoded && sb.Len() > 0:
+			words = append(words, sb.String())
+			sb.Reset()
+			words = append(words, word)
+		default:
 			words = append(words, word)
 		}
-		isPrevEncoded = isEncoded
 	}
+
+	if sb.Len() > 0 {
+		words = append(words, sb.String())
+	}
+
 	// Ignore any error if we got at least one word.
 	if err != nil && len(words) == 0 {
 		debug.Printf("consumePhrase: hit err: %v", err)
@@ -832,7 +843,7 @@ func (p *addrParser) consumeComment() (string, bool) {
 	// '(' already consumed.
 	depth := 1
 
-	var comment string
+	var comment strings.Builder
 	for {
 		if p.empty() || depth == 0 {
 			break
@@ -846,12 +857,12 @@ func (p *addrParser) consumeComment() (string, bool) {
 			depth--
 		}
 		if depth > 0 {
-			comment += p.s[:1]
+			comment.WriteByte(p.s[0])
 		}
 		p.s = p.s[1:]
 	}
 
-	return comment, depth == 0
+	return comment.String(), depth == 0
 }
 
 func (p *addrParser) decodeRFC2047Word(s string) (word string, isEncoded bool, err error) {

package/bin/go/src/net/sendfile.go

@@ -12,6 +12,8 @@ import (
 	"syscall"
 )
 
+var testHookSupportsSendfile func() bool
+
 // sendFile copies the contents of r to c using the sendfile
 // system call to minimize copies.
 //

package/bin/go/src/net/sendfile_stub.go

@@ -8,6 +8,8 @@ package net
 
 import "io"
 
+var testHookSupportsSendfile func() bool
+
 func supportsSendfile() bool {
 	return false
 }

package/bin/go/src/net/sendfile_windows.go

@@ -12,5 +12,8 @@ import "internal/syscall/windows"
 // https://learn.microsoft.com/en-us/windows/win32/api/mswsock/nf-mswsock-transmitfile
 // https://golang.org/issue/73746
 func supportsSendfile() bool {
+	if testHookSupportsSendfile != nil {
+		return testHookSupportsSendfile()
+	}
 	return windows.SupportUnlimitedTransmitFile()
 }

package/bin/go/src/net/url/url.go

@@ -2,14 +2,13 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+//go:generate go run gen_encoding_table.go
+
 // Package url parses URLs and implements query escaping.
 //
 // See RFC 3986. This package generally follows RFC 3986, except where
 // it deviates for compatibility reasons.
 // RFC 6874 followed for IPv6 zone literals.
-
-//go:generate go run gen_encoding_table.go
-
 package url
 
 // When sending changes, first  search old issues for history on decisions.
@@ -547,7 +546,9 @@ func parseAuthority(scheme, authority string) (user *Userinfo, host string, err
 // parseHost parses host as an authority without user
 // information. That is, as host[:port].
 func parseHost(scheme, host string) (string, error) {
-	if openBracketIdx := strings.LastIndex(host, "["); openBracketIdx != -1 {
+	if openBracketIdx := strings.LastIndex(host, "["); openBracketIdx > 0 {
+		return "", errors.New("invalid IP-literal")
+	} else if openBracketIdx == 0 {
 		// Parse an IP-Literal in RFC 3986 and RFC 6874.
 		// E.g., "[fe80::1]", "[fe80::1%25en0]", "[fe80::1]:80".
 		closeBracketIdx := strings.LastIndex(host, "]")
@@ -605,18 +606,22 @@ func parseHost(scheme, host string) (string, error) {
 	} else if i := strings.Index(host, ":"); i != -1 {
 		lastColon := strings.LastIndex(host, ":")
 		if lastColon != i {
-			if scheme == "postgresql" || scheme == "postgres" {
-				// PostgreSQL relies on non-RFC-3986 parsing to accept
-				// a comma-separated list of hosts (with optional ports)
-				// in the host subcomponent:
-				// https://www.postgresql.org/docs/11/libpq-connect.html#LIBPQ-MULTIPLE-HOSTS
-				//
-				// Since we historically permitted colons to appear in the host,
-				// continue to permit it for postgres:// URLs only.
-				// https://go.dev/issue/75223
-				i = lastColon
-			} else if urlstrictcolons.Value() == "0" {
-				urlstrictcolons.IncNonDefault()
+			// RFC 3986 does not allow colons to appear in the host subcomponent.
+			//
+			// However, a number of databases including PostgreSQL and MongoDB
+			// permit a comma-separated list of hosts (with optional ports) in the
+			// host subcomponent.
+			//
+			// Since we historically permitted colons to appear in the host,
+			// enforce strict colons only for http and https URLs.
+			//
+			// See https://go.dev/issue/75223 and https://go.dev/issue/78077.
+			if scheme == "http" || scheme == "https" {
+				if urlstrictcolons.Value() == "0" {
+					urlstrictcolons.IncNonDefault()
+					i = lastColon
+				}
+			} else {
 				i = lastColon
 			}
 		}
@@ -931,6 +936,7 @@ func ParseQuery(query string) (Values, error) {
 
 var urlmaxqueryparams = godebug.New("urlmaxqueryparams")
 
+// Keep this in sync with net/http/httputil.
 const defaultMaxParams = 10000
 
 func urlParamsWithinMax(params int) bool {

package/bin/go/src/os/dir_darwin.go

@@ -88,7 +88,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 		if mode == readdirName {
 			names = append(names, string(name))
 		} else if mode == readdirDirEntry {
-			de, err := newUnixDirent(f.name, string(name), dtToType(dirent.Type))
+			de, err := newUnixDirent(f, string(name), dtToType(dirent.Type))
 			if IsNotExist(err) {
 				// File disappeared between readdir and stat.
 				// Treat as if it didn't exist.
@@ -99,7 +99,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 			}
 			dirents = append(dirents, de)
 		} else {
-			info, err := lstat(f.name + "/" + string(name))
+			info, err := f.lstatat(string(name))
 			if IsNotExist(err) {
 				// File disappeared between readdir + stat.
 				// Treat as if it didn't exist.

package/bin/go/src/os/dir_unix.go

@@ -138,7 +138,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 		if mode == readdirName {
 			names = append(names, string(name))
 		} else if mode == readdirDirEntry {
-			de, err := newUnixDirent(f.name, string(name), direntType(rec))
+			de, err := newUnixDirent(f, string(name), direntType(rec))
 			if IsNotExist(err) {
 				// File disappeared between readdir and stat.
 				// Treat as if it didn't exist.
@@ -149,7 +149,7 @@ func (f *File) readdir(n int, mode readdirMode) (names []string, dirents []DirEn
 			}
 			dirents = append(dirents, de)
 		} else {
-			info, err := lstat(f.name + "/" + string(name))
+			info, err := f.lstatat(string(name))
 			if IsNotExist(err) {
 				// File disappeared between readdir + stat.
 				// Treat as if it didn't exist.

package/bin/go/src/os/file.go

@@ -428,9 +428,6 @@ func openDir(name string) (*File, error) {
 	return openDirNolog(name)
 }
 
-// lstat is overridden in tests.
-var lstat = Lstat
-
 // Rename renames (moves) oldpath to newpath.
 // If newpath already exists and is not a directory, Rename replaces it.
 // If newpath already exists and is a directory, Rename returns an error.

package/bin/go/src/os/file_unix.go

@@ -63,6 +63,7 @@ type file struct {
 	nonblock    bool                    // whether we set nonblocking mode
 	stdoutOrErr bool                    // whether this is stdout or stderr
 	appendMode  bool                    // whether file is opened for appending
+	inRoot      bool                    // whether file is opened in a Root
 }
 
 // fd is the Unix implementation of Fd.
@@ -458,24 +459,27 @@ func (d *unixDirent) Info() (FileInfo, error) {
 	if d.info != nil {
 		return d.info, nil
 	}
-	return lstat(d.parent + "/" + d.name)
+	return Lstat(d.parent + "/" + d.name)
 }
 
 func (d *unixDirent) String() string {
 	return fs.FormatDirEntry(d)
 }
 
-func newUnixDirent(parent, name string, typ FileMode) (DirEntry, error) {
+func newUnixDirent(parent *File, name string, typ FileMode) (DirEntry, error) {
 	ude := &unixDirent{
-		parent: parent,
+		parent: parent.name,
 		name:   name,
 		typ:    typ,
 	}
-	if typ != ^FileMode(0) {
+	// When the parent file was opened in a Root,
+	// we cannot use a lazy lstat to load the FileInfo.
+	// Use lstatat here.
+	if typ != ^FileMode(0) && !parent.inRoot {
 		return ude, nil
 	}
 
-	info, err := lstat(parent + "/" + name)
+	info, err := parent.lstatat(name)
 	if err != nil {
 		return nil, err
 	}

package/bin/go/src/os/removeall_at.go

@@ -93,10 +93,14 @@ func removeAllFrom(parentFd sysfdType, base string) error {
 			if IsNotExist(err) {
 				return nil
 			}
-			if err == syscall.ENOTDIR || isErrNoFollow(err) {
-				// Not a directory; return the error from the unix.Unlinkat.
+			if err == syscall.ENOTDIR {
+				// Not a directory; return the error from the removefileat.
 				return &PathError{Op: "unlinkat", Path: base, Err: uErr}
 			}
+			if _, ok := err.(errSymlink); ok {
+				// Not a user-visible error.
+				err = uErr
+			}
 			recurseErr = &PathError{Op: "openfdat", Path: base, Err: err}
 			break
 		}

package/bin/go/src/os/removeall_unix.go

@@ -6,14 +6,6 @@
 
 package os
 
-import (
-	"internal/syscall/unix"
-)
-
-func isErrNoFollow(err error) bool {
-	return err == unix.NoFollowErrno
-}
-
 func newDirFile(fd int, name string) (*File, error) {
 	// We use kindNoPoll because we know that this is a directory.
 	return newFile(fd, name, kindNoPoll, false), nil

package/bin/go/src/os/removeall_windows.go

@@ -8,10 +8,6 @@ package os
 
 import "syscall"
 
-func isErrNoFollow(err error) bool {
-	return err == syscall.ELOOP
-}
-
 func newDirFile(fd syscall.Handle, name string) (*File, error) {
 	return newFile(fd, name, kindOpenFile, false), nil
 }

package/bin/go/src/os/root_unix.go

@@ -104,6 +104,7 @@ func rootOpenFileNolog(root *Root, name string, flag int, perm FileMode) (*File,
 		return nil, &PathError{Op: "openat", Path: name, Err: err}
 	}
 	f := newFile(fd, joinPath(root.Name(), name), kindOpenFile, unix.HasNonblockFlag(flag))
+	f.inRoot = true
 	return f, nil
 }
 

package/bin/go/src/os/stat.go

@@ -25,3 +25,6 @@ func Lstat(name string) (FileInfo, error) {
 	testlog.Stat(name)
 	return lstatNolog(name)
 }
+
+// stathook is set in tests
+var stathook func(f *File, name string) (FileInfo, error)

package/bin/go/src/os/statat.go

@@ -0,0 +1,24 @@
+// Copyright 2026 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.
+
+//go:build !windows
+
+package os
+
+import (
+	"internal/testlog"
+)
+
+func (f *File) lstatat(name string) (FileInfo, error) {
+	if stathook != nil {
+		fi, err := stathook(f, name)
+		if fi != nil || err != nil {
+			return fi, err
+		}
+	}
+	if log := testlog.Logger(); log != nil {
+		log.Stat(joinPath(f.Name(), name))
+	}
+	return f.lstatatNolog(name)
+}

package/bin/go/src/os/statat_other.go

@@ -0,0 +1,12 @@
+// Copyright 2026 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.
+
+//go:build (js && wasm) || plan9
+
+package os
+
+func (f *File) lstatatNolog(name string) (FileInfo, error) {
+	// These platforms don't have fstatat, so use stat instead.
+	return Lstat(f.name + "/" + name)
+}

package/bin/go/src/os/statat_unix.go

@@ -0,0 +1,20 @@
+// Copyright 2026 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.
+
+//go:build aix || darwin || dragonfly || freebsd || wasip1 || linux || netbsd || openbsd || solaris
+
+package os
+
+import (
+	"internal/syscall/unix"
+)
+
+func (f *File) lstatatNolog(name string) (FileInfo, error) {
+	var fs fileStat
+	if err := f.pfd.Fstatat(name, &fs.sys, unix.AT_SYMLINK_NOFOLLOW); err != nil {
+		return nil, f.wrapErr("fstatat", err)
+	}
+	fillFileStatFromSys(&fs, name)
+	return &fs, nil
+}

package/bin/go/src/reflect/value.go

@@ -1288,9 +1288,10 @@ func (v Value) Field(i int) Value {
 		// bunch of zero-sized fields. We must return the zero-sized
 		// fields indirectly, as only ptr-shaped things can be direct.
 		// See issue 74935.
-		// We use nil instead of v.ptr as it doesn't matter and
+		// We use &zeroVal[0] instead of v.ptr as it doesn't matter and
 		// we can avoid pinning a possibly now-unused object.
-		return Value{typ, nil, fl | flagIndir}
+		// Don't use nil, see issue 77779.
+		return Value{typ, unsafe.Pointer(&zeroVal[0]), fl | flagIndir}
 	}
 
 	// Either flagIndir is set and v.ptr points at struct,

package/bin/go/src/runtime/defs_linux_386.go

@@ -152,13 +152,14 @@ func (ts *timespec32) setNsec(ns int64) {
 
 type timespec struct {
 	tv_sec  int64
-	tv_nsec int64
+	tv_nsec int32
+	_       [4]byte // the C ABI aligns int64 to 8 bytes
 }
 
 //go:nosplit
 func (ts *timespec) setNsec(ns int64) {
-	ts.tv_sec = int64(ns / 1e9)
-	ts.tv_nsec = int64(ns % 1e9)
+	ts.tv_sec = ns / 1e9
+	ts.tv_nsec = int32(ns % 1e9)
 }
 
 type timeval struct {

package/bin/go/src/runtime/defs_linux_arm.go

@@ -111,13 +111,14 @@ func (ts *timespec32) setNsec(ns int64) {
 
 type timespec struct {
 	tv_sec  int64
-	tv_nsec int64
+	tv_nsec int32
+	_       [4]byte // the C ABI aligns int64 to 8 bytes
 }
 
 //go:nosplit
 func (ts *timespec) setNsec(ns int64) {
-	ts.tv_sec = int64(ns / 1e9)
-	ts.tv_nsec = int64(ns % 1e9)
+	ts.tv_sec = ns / 1e9
+	ts.tv_nsec = int32(ns % 1e9)
 }
 
 type stackt struct {

package/bin/go/src/runtime/defs_linux_mips64x.go

@@ -12,7 +12,7 @@ const (
 	_EINTR  = 0x4
 	_EAGAIN = 0xb
 	_ENOMEM = 0xc
-	_ENOSYS = 0x26
+	_ENOSYS = 0x59
 
 	_PROT_NONE  = 0x0
 	_PROT_READ  = 0x1

package/bin/go/src/runtime/defs_linux_mipsx.go

@@ -12,7 +12,7 @@ const (
 	_EINTR  = 0x4
 	_EAGAIN = 0xb
 	_ENOMEM = 0xc
-	_ENOSYS = 0x26
+	_ENOSYS = 0x59
 
 	_PROT_NONE  = 0x0
 	_PROT_READ  = 0x1
@@ -109,13 +109,14 @@ func (ts *timespec32) setNsec(ns int64) {
 
 type timespec struct {
 	tv_sec  int64
-	tv_nsec int64
+	tv_nsec int32
+	_       [4]byte // the C ABI aligns int64 to 8 bytes
 }
 
 //go:nosplit
 func (ts *timespec) setNsec(ns int64) {
-	ts.tv_sec = int64(ns / 1e9)
-	ts.tv_nsec = int64(ns % 1e9)
+	ts.tv_sec = ns / 1e9
+	ts.tv_nsec = int32(ns % 1e9)
 }
 
 type timeval struct {