Source: sys_darwin.go in package runtime


package runtime

import "unsafe"

The X versions of syscall expect the libc call to return a 64-bit result. Otherwise (the non-X version) expects a 32-bit result. This distinction is required because an error is indicated by returning -1, and we need to know whether to check 32 or 64 bits of the result. (Some libc functions that return 32 bits put junk in the upper 32 bits of AX.)

go:linkname syscall_syscall syscall.syscallgo:nosplitgo:cgo_unsafe_args

func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscall()

go:linkname syscall_syscallX syscall.syscallXgo:nosplitgo: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.syscall6go:nosplitgo:cgo_unsafe_args

func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscall6()

go:linkname syscall_syscall6X syscall.syscall6Xgo:nosplitgo:cgo_unsafe_args

func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(funcPC(syscall6X)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscall6X()

go:linkname syscall_syscallPtr syscall.syscallPtrgo:nosplitgo:cgo_unsafe_args

func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(funcPC(syscallPtr)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscallPtr()

go:linkname syscall_rawSyscall syscall.rawSyscallgo:nosplitgo:cgo_unsafe_args

func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
	libcCall(unsafe.Pointer(funcPC(syscall)), unsafe.Pointer(&fn))
	return
}

go:linkname syscall_rawSyscall6 syscall.rawSyscall6go:nosplitgo:cgo_unsafe_args

func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
	libcCall(unsafe.Pointer(funcPC(syscall6)), unsafe.Pointer(&fn))
	return
}

syscallNoErr is used in crypto/x509 to call into Security.framework and CF.

go:linkname crypto_x509_syscall crypto/x509/internal/macos.syscallgo:nosplitgo:cgo_unsafe_args

func crypto_x509_syscall(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1 uintptr) {
	entersyscall()
	libcCall(unsafe.Pointer(funcPC(syscallNoErr)), unsafe.Pointer(&fn))
	exitsyscall()
	return
}
func syscallNoErr()

The *_trampoline functions convert from the Go calling convention to the C calling convention and then call the underlying libc function. They are defined in sys_darwin_$ARCH.s.

go:nosplitgo:cgo_unsafe_args

func pthread_attr_init(attr *pthreadattr) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
}
func pthread_attr_init_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
}
func pthread_attr_getstacksize_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
}
func pthread_attr_setdetachstate_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_create_trampoline)), unsafe.Pointer(&attr))
}
func pthread_create_trampoline()

go:nosplitgo:cgo_unsafe_args

func raise(sig uint32) {
	libcCall(unsafe.Pointer(funcPC(raise_trampoline)), unsafe.Pointer(&sig))
}
func raise_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_self() (t pthread) {
	libcCall(unsafe.Pointer(funcPC(pthread_self_trampoline)), unsafe.Pointer(&t))
	return
}
func pthread_self_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_kill(t pthread, sig uint32) {
	libcCall(unsafe.Pointer(funcPC(pthread_kill_trampoline)), unsafe.Pointer(&t))
	return
}
func pthread_kill_trampoline()

mmap is used to do low-level memory allocation via mmap. Don't allow stack splits, since this function (used by sysAlloc) is called in a lot of low-level parts of the runtime and callers often assume it won't acquire any locks. go:nosplit

func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
	args := struct {
		addr            unsafe.Pointer
		n               uintptr
		prot, flags, fd int32
		off             uint32
		ret1            unsafe.Pointer
		ret2            int
	}{addr, n, prot, flags, fd, off, nil, 0}
	libcCall(unsafe.Pointer(funcPC(mmap_trampoline)), unsafe.Pointer(&args))
	return args.ret1, args.ret2
}
func mmap_trampoline()

go:nosplitgo:cgo_unsafe_args

func munmap(addr unsafe.Pointer, n uintptr) {
	libcCall(unsafe.Pointer(funcPC(munmap_trampoline)), unsafe.Pointer(&addr))
}
func munmap_trampoline()

go:nosplitgo:cgo_unsafe_args

func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
	libcCall(unsafe.Pointer(funcPC(madvise_trampoline)), unsafe.Pointer(&addr))
}
func madvise_trampoline()

go:nosplitgo:cgo_unsafe_args

func mlock(addr unsafe.Pointer, n uintptr) {
	libcCall(unsafe.Pointer(funcPC(mlock_trampoline)), unsafe.Pointer(&addr))
}
func mlock_trampoline()

go:nosplitgo:cgo_unsafe_args

func read(fd int32, p unsafe.Pointer, n int32) int32 {
	return libcCall(unsafe.Pointer(funcPC(read_trampoline)), unsafe.Pointer(&fd))
}
func read_trampoline()

func pipe() (r, w int32, errno int32) {
	var p [2]int32
	errno = libcCall(unsafe.Pointer(funcPC(pipe_trampoline)), noescape(unsafe.Pointer(&p)))
	return p[0], p[1], errno
}
func pipe_trampoline()

go:nosplitgo:cgo_unsafe_args

func closefd(fd int32) int32 {
	return libcCall(unsafe.Pointer(funcPC(close_trampoline)), unsafe.Pointer(&fd))
}
func close_trampoline()

go:nosplitgo:cgo_unsafe_args This is exported via linkname to assembly in runtime/cgo.go:linkname exit

func exit(code int32) {
	libcCall(unsafe.Pointer(funcPC(exit_trampoline)), unsafe.Pointer(&code))
}
func exit_trampoline()

go:nosplitgo:cgo_unsafe_args

func usleep(usec uint32) {
	libcCall(unsafe.Pointer(funcPC(usleep_trampoline)), unsafe.Pointer(&usec))
}
func usleep_trampoline()

go:nosplitgo:cgo_unsafe_args

func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
	return libcCall(unsafe.Pointer(funcPC(write_trampoline)), unsafe.Pointer(&fd))
}
func write_trampoline()

go:nosplitgo:cgo_unsafe_args

func open(name *byte, mode, perm int32) (ret int32) {
	return libcCall(unsafe.Pointer(funcPC(open_trampoline)), unsafe.Pointer(&name))
}
func open_trampoline()

go:nosplitgo:cgo_unsafe_args

func nanotime1() int64 {
	var r struct {
		t            int64  // raw timer
		numer, denom uint32 // conversion factors. nanoseconds = t * numer / denom.
	}

Note: Apple seems unconcerned about overflow here. See https://developer.apple.com/library/content/qa/qa1398/_index.html Note also, numer == denom == 1 is common.

	t := r.t
	if r.numer != 1 {
		t *= int64(r.numer)
	}
	if r.denom != 1 {
		t /= int64(r.denom)
	}
	return t
}
func nanotime_trampoline()

go:nosplitgo:cgo_unsafe_args

func walltime1() (int64, int32) {
	var t timespec
	libcCall(unsafe.Pointer(funcPC(walltime_trampoline)), unsafe.Pointer(&t))
	return t.tv_sec, int32(t.tv_nsec)
}
func walltime_trampoline()

go:nosplitgo:cgo_unsafe_args

func sigaction(sig uint32, new *usigactiont, old *usigactiont) {
	libcCall(unsafe.Pointer(funcPC(sigaction_trampoline)), unsafe.Pointer(&sig))
}
func sigaction_trampoline()

go:nosplitgo:cgo_unsafe_args

func sigprocmask(how uint32, new *sigset, old *sigset) {
	libcCall(unsafe.Pointer(funcPC(sigprocmask_trampoline)), unsafe.Pointer(&how))
}
func sigprocmask_trampoline()

go:nosplitgo:cgo_unsafe_args

func sigaltstack(new *stackt, old *stackt) {

Despite the fact that Darwin's sigaltstack man page says it ignores the size when SS_DISABLE is set, it doesn't. sigaltstack returns ENOMEM if we don't give it a reasonable size. ref: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20140421/214296.html

		new.ss_size = 32768
	}
	libcCall(unsafe.Pointer(funcPC(sigaltstack_trampoline)), unsafe.Pointer(&new))
}
func sigaltstack_trampoline()

go:nosplitgo:cgo_unsafe_args

func raiseproc(sig uint32) {
	libcCall(unsafe.Pointer(funcPC(raiseproc_trampoline)), unsafe.Pointer(&sig))
}
func raiseproc_trampoline()

go:nosplitgo:cgo_unsafe_args

func setitimer(mode int32, new, old *itimerval) {
	libcCall(unsafe.Pointer(funcPC(setitimer_trampoline)), unsafe.Pointer(&mode))
}
func setitimer_trampoline()

go:nosplitgo:cgo_unsafe_args

func sysctl(mib *uint32, miblen uint32, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
	return libcCall(unsafe.Pointer(funcPC(sysctl_trampoline)), unsafe.Pointer(&mib))
}
func sysctl_trampoline()

go:nosplitgo:cgo_unsafe_args

func sysctlbyname(name *byte, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
	return libcCall(unsafe.Pointer(funcPC(sysctlbyname_trampoline)), unsafe.Pointer(&name))
}
func sysctlbyname_trampoline()

go:nosplitgo:cgo_unsafe_args

func fcntl(fd, cmd, arg int32) int32 {
	return libcCall(unsafe.Pointer(funcPC(fcntl_trampoline)), unsafe.Pointer(&fd))
}
func fcntl_trampoline()

go:nosplitgo:cgo_unsafe_args

func kqueue() int32 {
	v := libcCall(unsafe.Pointer(funcPC(kqueue_trampoline)), nil)
	return v
}
func kqueue_trampoline()

go:nosplitgo:cgo_unsafe_args

func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 {
	return libcCall(unsafe.Pointer(funcPC(kevent_trampoline)), unsafe.Pointer(&kq))
}
func kevent_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_mutex_init(m *pthreadmutex, attr *pthreadmutexattr) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
}
func pthread_mutex_init_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_mutex_lock(m *pthreadmutex) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
}
func pthread_mutex_lock_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_mutex_unlock(m *pthreadmutex) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
}
func pthread_mutex_unlock_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_cond_init(c *pthreadcond, attr *pthreadcondattr) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
}
func pthread_cond_init_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_cond_wait(c *pthreadcond, m *pthreadmutex) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
}
func pthread_cond_wait_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_cond_timedwait_relative_np(c *pthreadcond, m *pthreadmutex, t *timespec) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
}
func pthread_cond_timedwait_relative_np_trampoline()

go:nosplitgo:cgo_unsafe_args

func pthread_cond_signal(c *pthreadcond) int32 {
	return libcCall(unsafe.Pointer(funcPC(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
}
func pthread_cond_signal_trampoline()

Not used on Darwin, but must be defined.

func exitThread(wait *uint32) {
}

go:nosplit

func closeonexec(fd int32) {
	fcntl(fd, _F_SETFD, _FD_CLOEXEC)
}

go:nosplit

func setNonblock(fd int32) {
	flags := fcntl(fd, _F_GETFL, 0)
	fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
}

Tell the linker that the libc_* functions are to be found in a system library, with the libc_ prefix missing.

go:cgo_import_dynamic libc_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_attr_getstacksize pthread_attr_getstacksize "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_attr_setdetachstate pthread_attr_setdetachstate "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_create pthread_create "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_self pthread_self "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_kill pthread_kill "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_exit _exit "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_raise raise "/usr/lib/libSystem.B.dylib"

go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"

go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_error __error "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_usleep usleep "/usr/lib/libSystem.B.dylib"

go:cgo_import_dynamic libc_mach_timebase_info mach_timebase_info "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_mach_absolute_time mach_absolute_time "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_sigaction sigaction "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_sigaltstack sigaltstack "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_setitimer setitimer "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_sysctlbyname sysctlbyname "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"

go:cgo_import_dynamic libc_pthread_mutex_init pthread_mutex_init "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_mutex_lock pthread_mutex_lock "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_mutex_unlock pthread_mutex_unlock "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_cond_init pthread_cond_init "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_cond_wait pthread_cond_wait "/usr/lib/libSystem.B.dylib"go:cgo_import_dynamic libc_pthread_cond_timedwait_relative_np pthread_cond_timedwait_relative_np "/usr/lib/libSystem.B.dylib"