src/runtime/os_darwin.go - go - Git at Google

 // Copyright 2009 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 runtime

 import "unsafe"

 type mOS struct {
 	machport uint32 // return address for mach ipc
 	waitsema uint32 // semaphore for parking on locks
 }

 var darwinVersion int

 func bsdthread_create(stk, arg unsafe.Pointer, fn uintptr) int32
 func bsdthread_register() int32

 //go:noescape
 func mach_msg_trap(h unsafe.Pointer, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32

 func mach_reply_port() uint32
 func mach_task_self() uint32
 func mach_thread_self() uint32

 //go:noescape
 func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32

 func unimplemented(name string) {
 	println(name, "not implemented")
 	*(*int)(unsafe.Pointer(uintptr(1231))) = 1231
 }

 //go:nosplit
 func semawakeup(mp *m) {
 	mach_semrelease(mp.waitsema)
 }

 //go:nosplit
 func semacreate(mp *m) {
 	if mp.waitsema != 0 {
 		return
 	}
 	systemstack(func() {
 		mp.waitsema = mach_semcreate()
 	})
 }

 // BSD interface for threading.
 func osinit() {
 	// bsdthread_register delayed until end of goenvs so that we
 	// can look at the environment first.

 	ncpu = getncpu()
 	physPageSize = getPageSize()
 	darwinVersion = getDarwinVersion()
 }

 const (
 	_CTL_KERN       = 1
 	_CTL_HW         = 6
 	_KERN_OSRELEASE = 2
 	_HW_NCPU        = 3
 	_HW_PAGESIZE    = 7
 )

 func getDarwinVersion() int {
 	// Use sysctl to fetch kern.osrelease
 	mib := [2]uint32{_CTL_KERN, _KERN_OSRELEASE}
 	var out [32]byte
 	nout := unsafe.Sizeof(out)
 	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
 	if ret >= 0 {
 		ver := 0
 		for i := 0; i < int(nout) && out[i] >= '0' && out[i] <= '9'; i++ {
 			ver *= 10
 			ver += int(out[i] - '0')
 		}
 		return ver
 	}
 	return 17 // should not happen: default to a newish version
 }

 func getncpu() int32 {
 	// Use sysctl to fetch hw.ncpu.
 	mib := [2]uint32{_CTL_HW, _HW_NCPU}
 	out := uint32(0)
 	nout := unsafe.Sizeof(out)
 	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
 	if ret >= 0 && int32(out) > 0 {
 		return int32(out)
 	}
 	return 1
 }

 func getPageSize() uintptr {
 	// Use sysctl to fetch hw.pagesize.
 	mib := [2]uint32{_CTL_HW, _HW_PAGESIZE}
 	out := uint32(0)
 	nout := unsafe.Sizeof(out)
 	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
 	if ret >= 0 && int32(out) > 0 {
 		return uintptr(out)
 	}
 	return 0
 }

 var urandom_dev = []byte("/dev/urandom\x00")

 //go:nosplit
 func getRandomData(r []byte) {
 	fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
 	n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
 	closefd(fd)
 	extendRandom(r, int(n))
 }

 func goenvs() {
 	goenvs_unix()

 	// Register our thread-creation callback (see sys_darwin_{amd64,386}.s)
 	// but only if we're not using cgo. If we are using cgo we need
 	// to let the C pthread library install its own thread-creation callback.
 	if !iscgo {
 		if bsdthread_register() != 0 {
 			if gogetenv("DYLD_INSERT_LIBRARIES") != "" {
 				throw("runtime: bsdthread_register error (unset DYLD_INSERT_LIBRARIES)")
 			}
 			throw("runtime: bsdthread_register error")
 		}
 	}
 }

 // May run with m.p==nil, so write barriers are not allowed.
 //go:nowritebarrier
 func newosproc(mp *m, stk unsafe.Pointer) {
 	if false {
 		print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " id=", mp.id, " ostk=", &mp, "\n")
 	}

 	var oset sigset
 	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
 	errno := bsdthread_create(stk, unsafe.Pointer(mp), funcPC(mstart))
 	sigprocmask(_SIG_SETMASK, &oset, nil)

 	if errno < 0 {
 		print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", -errno, ")\n")
 		throw("runtime.newosproc")
 	}
 }

 // newosproc0 is a version of newosproc that can be called before the runtime
 // is initialized.
 //
 // As Go uses bsdthread_register when running without cgo, this function is
 // not safe to use after initialization as it does not pass an M as fnarg.
 //
 //go:nosplit
 func newosproc0(stacksize uintptr, fn uintptr) {
 	stack := sysAlloc(stacksize, &memstats.stacks_sys)
 	if stack == nil {
 		write(2, unsafe.Pointer(&failallocatestack[0]), int32(len(failallocatestack)))
 		exit(1)
 	}
 	stk := unsafe.Pointer(uintptr(stack) + stacksize)

 	var oset sigset
 	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
 	errno := bsdthread_create(stk, nil, fn)
 	sigprocmask(_SIG_SETMASK, &oset, nil)

 	if errno < 0 {
 		write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
 		exit(1)
 	}
 }

 var failallocatestack = []byte("runtime: failed to allocate stack for the new OS thread\n")
 var failthreadcreate = []byte("runtime: failed to create new OS thread\n")

 // Called to do synchronous initialization of Go code built with
 // -buildmode=c-archive or -buildmode=c-shared.
 // None of the Go runtime is initialized.
 //go:nosplit
 //go:nowritebarrierrec
 func libpreinit() {
 	initsig(true)
 }

 // Called to initialize a new m (including the bootstrap m).
 // Called on the parent thread (main thread in case of bootstrap), can allocate memory.
 func mpreinit(mp *m) {
 	mp.gsignal = malg(32 * 1024) // OS X wants >= 8K
 	mp.gsignal.m = mp
 }

 // Called to initialize a new m (including the bootstrap m).
 // Called on the new thread, cannot allocate memory.
 func minit() {
 	// The alternate signal stack is buggy on arm and arm64.
 	// The signal handler handles it directly.
 	// The sigaltstack assembly function does nothing.
 	if GOARCH != "arm" && GOARCH != "arm64" {
 		minitSignalStack()
 	}
 	minitSignalMask()
 }

 // Called from dropm to undo the effect of an minit.
 //go:nosplit
 func unminit() {
 	// The alternate signal stack is buggy on arm and arm64.
 	// See minit.
 	if GOARCH != "arm" && GOARCH != "arm64" {
 		unminitSignals()
 	}
 }

 // Mach IPC, to get at semaphores
 // Definitions are in /usr/include/mach on a Mac.

 func macherror(r int32, fn string) {
 	print("mach error ", fn, ": ", r, "\n")
 	throw("mach error")
 }

 const _DebugMach = false

 var zerondr machndr

 func mach_msgh_bits(a, b uint32) uint32 {
 	return a | b<<8
 }

 func mach_msg(h *machheader, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32 {
 	// TODO: Loop on interrupt.
 	return mach_msg_trap(unsafe.Pointer(h), op, send_size, rcv_size, rcv_name, timeout, notify)
 }

 // Mach RPC (MIG)
 const (
 	_MinMachMsg = 48
 	_MachReply  = 100
 )

 type codemsg struct {
 	h    machheader
 	ndr  machndr
 	code int32
 }

 func machcall(h *machheader, maxsize int32, rxsize int32) int32 {
 	_g_ := getg()
 	port := _g_.m.machport
 	if port == 0 {
 		port = mach_reply_port()
 		_g_.m.machport = port
 	}

 	h.msgh_bits |= mach_msgh_bits(_MACH_MSG_TYPE_COPY_SEND, _MACH_MSG_TYPE_MAKE_SEND_ONCE)
 	h.msgh_local_port = port
 	h.msgh_reserved = 0
 	id := h.msgh_id

 	if _DebugMach {
 		p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
 		print("send:\t")
 		var i uint32
 		for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
 			print(" ", p[i])
 			if i%8 == 7 {
 				print("\n\t")
 			}
 		}
 		if i%8 != 0 {
 			print("\n")
 		}
 	}
 	ret := mach_msg(h, _MACH_SEND_MSG|_MACH_RCV_MSG, h.msgh_size, uint32(maxsize), port, 0, 0)
 	if ret != 0 {
 		if _DebugMach {
 			print("mach_msg error ", ret, "\n")
 		}
 		return ret
 	}
 	if _DebugMach {
 		p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
 		var i uint32
 		for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
 			print(" ", p[i])
 			if i%8 == 7 {
 				print("\n\t")
 			}
 		}
 		if i%8 != 0 {
 			print("\n")
 		}
 	}
 	if h.msgh_id != id+_MachReply {
 		if _DebugMach {
 			print("mach_msg _MachReply id mismatch ", h.msgh_id, " != ", id+_MachReply, "\n")
 		}
 		return -303 // MIG_REPLY_MISMATCH
 	}
 	// Look for a response giving the return value.
 	// Any call can send this back with an error,
 	// and some calls only have return values so they
 	// send it back on success too. I don't quite see how
 	// you know it's one of these and not the full response
 	// format, so just look if the message is right.
 	c := (*codemsg)(unsafe.Pointer(h))
 	if uintptr(h.msgh_size) == unsafe.Sizeof(*c) && h.msgh_bits&_MACH_MSGH_BITS_COMPLEX == 0 {
 		if _DebugMach {
 			print("mig result ", c.code, "\n")
 		}
 		return c.code
 	}
 	if h.msgh_size != uint32(rxsize) {
 		if _DebugMach {
 			print("mach_msg _MachReply size mismatch ", h.msgh_size, " != ", rxsize, "\n")
 		}
 		return -307 // MIG_ARRAY_TOO_LARGE
 	}
 	return 0
 }

 // Semaphores!

 const (
 	tmach_semcreate = 3418
 	rmach_semcreate = tmach_semcreate + _MachReply

 	tmach_semdestroy = 3419
 	rmach_semdestroy = tmach_semdestroy + _MachReply

 	_KERN_ABORTED             = 14
 	_KERN_OPERATION_TIMED_OUT = 49
 )

 type tmach_semcreatemsg struct {
 	h      machheader
 	ndr    machndr
 	policy int32
 	value  int32
 }

 type rmach_semcreatemsg struct {
 	h         machheader
 	body      machbody
 	semaphore machport
 }

 type tmach_semdestroymsg struct {
 	h         machheader
 	body      machbody
 	semaphore machport
 }

 func mach_semcreate() uint32 {
 	var m [256]uint8
 	tx := (*tmach_semcreatemsg)(unsafe.Pointer(&m))
 	rx := (*rmach_semcreatemsg)(unsafe.Pointer(&m))

 	tx.h.msgh_bits = 0
 	tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
 	tx.h.msgh_remote_port = mach_task_self()
 	tx.h.msgh_id = tmach_semcreate
 	tx.ndr = zerondr

 	tx.policy = 0 // 0 = SYNC_POLICY_FIFO
 	tx.value = 0

 	for {
 		r := machcall(&tx.h, int32(unsafe.Sizeof(m)), int32(unsafe.Sizeof(*rx)))
 		if r == 0 {
 			break
 		}
 		if r == _KERN_ABORTED { // interrupted
 			continue
 		}
 		macherror(r, "semaphore_create")
 	}
 	if rx.body.msgh_descriptor_count != 1 {
 		unimplemented("mach_semcreate desc count")
 	}
 	return rx.semaphore.name
 }

 func mach_semdestroy(sem uint32) {
 	var m [256]uint8
 	tx := (*tmach_semdestroymsg)(unsafe.Pointer(&m))

 	tx.h.msgh_bits = _MACH_MSGH_BITS_COMPLEX
 	tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
 	tx.h.msgh_remote_port = mach_task_self()
 	tx.h.msgh_id = tmach_semdestroy
 	tx.body.msgh_descriptor_count = 1
 	tx.semaphore.name = sem
 	tx.semaphore.disposition = _MACH_MSG_TYPE_MOVE_SEND
 	tx.semaphore._type = 0

 	for {
 		r := machcall(&tx.h, int32(unsafe.Sizeof(m)), 0)
 		if r == 0 {
 			break
 		}
 		if r == _KERN_ABORTED { // interrupted
 			continue
 		}
 		macherror(r, "semaphore_destroy")
 	}
 }

 // The other calls have simple system call traps in sys_darwin_{amd64,386}.s

 func mach_semaphore_wait(sema uint32) int32
 func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
 func mach_semaphore_signal(sema uint32) int32
 func mach_semaphore_signal_all(sema uint32) int32

 func semasleep1(ns int64) int32 {
 	_g_ := getg()

 	if ns >= 0 {
 		var nsecs int32
 		secs := timediv(ns, 1000000000, &nsecs)
 		r := mach_semaphore_timedwait(_g_.m.waitsema, uint32(secs), uint32(nsecs))
 		if r == _KERN_ABORTED || r == _KERN_OPERATION_TIMED_OUT {
 			return -1
 		}
 		if r != 0 {
 			macherror(r, "semaphore_wait")
 		}
 		return 0
 	}

 	for {
 		r := mach_semaphore_wait(_g_.m.waitsema)
 		if r == 0 {
 			break
 		}
 		// Note: We don't know how this call (with no timeout) can get _KERN_OPERATION_TIMED_OUT,
 		// but it does reliably, though at a very low rate, on OS X 10.8, 10.9, 10.10, and 10.11.
 		// See golang.org/issue/17161.
 		if r == _KERN_ABORTED || r == _KERN_OPERATION_TIMED_OUT { // interrupted
 			continue
 		}
 		macherror(r, "semaphore_wait")
 	}
 	return 0
 }

 //go:nosplit
 func semasleep(ns int64) int32 {
 	var r int32
 	systemstack(func() {
 		r = semasleep1(ns)
 	})
 	return r
 }

 //go:nosplit
 func mach_semrelease(sem uint32) {
 	for {
 		r := mach_semaphore_signal(sem)
 		if r == 0 {
 			break
 		}
 		if r == _KERN_ABORTED { // interrupted
 			continue
 		}

 		// mach_semrelease must be completely nosplit,
 		// because it is called from Go code.
 		// If we're going to die, start that process on the system stack
 		// to avoid a Go stack split.
 		systemstack(func() { macherror(r, "semaphore_signal") })
 	}
 }

 //go:nosplit
 func osyield() {
 	usleep(1)
 }

 func memlimit() uintptr {
 	// NOTE(rsc): Could use getrlimit here,
 	// like on FreeBSD or Linux, but Darwin doesn't enforce
 	// ulimit -v, so it's unclear why we'd try to stay within
 	// the limit.
 	return 0
 }

 const (
 	_NSIG        = 32
 	_SI_USER     = 0 /* empirically true, but not what headers say */
 	_SIG_BLOCK   = 1
 	_SIG_UNBLOCK = 2
 	_SIG_SETMASK = 3
 	_SS_DISABLE  = 4
 )

 //go:noescape
 func sigprocmask(how int32, new, old *sigset)

 //go:noescape
 func sigaction(mode uint32, new *sigactiont, old *usigactiont)

 //go:noescape
 func sigaltstack(new, old *stackt)

 // darwin/arm64 uses registers instead of stack-based arguments.
 // TODO: does this matter?
 func sigtramp(fn uintptr, infostyle, sig uint32, info *siginfo, ctx unsafe.Pointer)

 //go:noescape
 func setitimer(mode int32, new, old *itimerval)

 func raise(sig uint32)
 func raiseproc(sig uint32)

 //extern SigTabTT runtime·sigtab[];

 type sigset uint32

 var sigset_all = ^sigset(0)

 //go:nosplit
 //go:nowritebarrierrec
 func setsig(i uint32, fn uintptr) {
 	var sa sigactiont
 	sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK | _SA_RESTART
 	sa.sa_mask = ^uint32(0)
 	sa.sa_tramp = unsafe.Pointer(funcPC(sigtramp)) // runtime·sigtramp's job is to call into real handler
 	*(*uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = fn
 	sigaction(i, &sa, nil)
 }

 //go:nosplit
 //go:nowritebarrierrec
 func setsigstack(i uint32) {
 	var osa usigactiont
 	sigaction(i, nil, &osa)
 	handler := *(*uintptr)(unsafe.Pointer(&osa.__sigaction_u))
 	if osa.sa_flags&_SA_ONSTACK != 0 {
 		return
 	}
 	var sa sigactiont
 	*(*uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = handler
 	sa.sa_tramp = unsafe.Pointer(funcPC(sigtramp))
 	sa.sa_mask = osa.sa_mask
 	sa.sa_flags = osa.sa_flags | _SA_ONSTACK
 	sigaction(i, &sa, nil)
 }

 //go:nosplit
 //go:nowritebarrierrec
 func getsig(i uint32) uintptr {
 	var sa usigactiont
 	sigaction(i, nil, &sa)
 	return *(*uintptr)(unsafe.Pointer(&sa.__sigaction_u))
 }

 // setSignaltstackSP sets the ss_sp field of a stackt.
 //go:nosplit
 func setSignalstackSP(s *stackt, sp uintptr) {
 	*(*uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
 }

 //go:nosplit
 //go:nowritebarrierrec
 func sigaddset(mask *sigset, i int) {
 	*mask |= 1 << (uint32(i) - 1)
 }

 func sigdelset(mask *sigset, i int) {
 	*mask &^= 1 << (uint32(i) - 1)
 }

 //go:linkname executablePath os.executablePath
 var executablePath string

 func sysargs(argc int32, argv **byte) {
 	// skip over argv, envv and the first string will be the path
 	n := argc + 1
 	for argv_index(argv, n) != nil {
 		n++
 	}
 	executablePath = gostringnocopy(argv_index(argv, n+1))

 	// strip "executable_path=" prefix if available, it's added after OS X 10.11.
 	const prefix = "executable_path="
 	if len(executablePath) > len(prefix) && executablePath[:len(prefix)] == prefix {
 		executablePath = executablePath[len(prefix):]
 	}
 }
	// Copyright 2009 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 runtime

	import "unsafe"

	type mOS struct {
	machport uint32 // return address for mach ipc
	waitsema uint32 // semaphore for parking on locks
	}

	var darwinVersion int

	func bsdthread_create(stk, arg unsafe.Pointer, fn uintptr) int32
	func bsdthread_register() int32

	//go:noescape
	func mach_msg_trap(h unsafe.Pointer, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32

	func mach_reply_port() uint32
	func mach_task_self() uint32
	func mach_thread_self() uint32

	//go:noescape
	func sysctl(mib uint32, miblen uint32, out byte, size uintptr, dst byte, ndst uintptr) int32

	func unimplemented(name string) {
	println(name, "not implemented")
	(int)(unsafe.Pointer(uintptr(1231))) = 1231
	}

	//go:nosplit
	func semawakeup(mp *m) {
	mach_semrelease(mp.waitsema)
	}

	//go:nosplit
	func semacreate(mp *m) {
	if mp.waitsema != 0 {
	return
	}
	systemstack(func() {
	mp.waitsema = mach_semcreate()
	})
	}

	// BSD interface for threading.
	func osinit() {
	// bsdthread_register delayed until end of goenvs so that we
	// can look at the environment first.

	ncpu = getncpu()
	physPageSize = getPageSize()
	darwinVersion = getDarwinVersion()
	}

	const (
	_CTL_KERN = 1
	_CTL_HW = 6
	_KERN_OSRELEASE = 2
	_HW_NCPU = 3
	_HW_PAGESIZE = 7
	)

	func getDarwinVersion() int {
	// Use sysctl to fetch kern.osrelease
	mib := [2]uint32{_CTL_KERN, _KERN_OSRELEASE}
	var out [32]byte
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret >= 0 {
	ver := 0
	for i := 0; i < int(nout) && out[i] >= '0' && out[i] <= '9'; i++ {
	ver *= 10
	ver += int(out[i] - '0')
	}
	return ver
	}
	return 17 // should not happen: default to a newish version
	}

	func getncpu() int32 {
	// Use sysctl to fetch hw.ncpu.
	mib := [2]uint32{_CTL_HW, _HW_NCPU}
	out := uint32(0)
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret >= 0 && int32(out) > 0 {
	return int32(out)
	}
	return 1
	}

	func getPageSize() uintptr {
	// Use sysctl to fetch hw.pagesize.
	mib := [2]uint32{_CTL_HW, _HW_PAGESIZE}
	out := uint32(0)
	nout := unsafe.Sizeof(out)
	ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
	if ret >= 0 && int32(out) > 0 {
	return uintptr(out)
	}
	return 0
	}

	var urandom_dev = []byte("/dev/urandom\x00")

	//go:nosplit
	func getRandomData(r []byte) {
	fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
	n := read(fd, unsafe.Pointer(&r[0]), int32(len(r)))
	closefd(fd)
	extendRandom(r, int(n))
	}

	func goenvs() {
	goenvs_unix()

	// Register our thread-creation callback (see sys_darwin_{amd64,386}.s)
	// but only if we're not using cgo. If we are using cgo we need
	// to let the C pthread library install its own thread-creation callback.
	if !iscgo {
	if bsdthread_register() != 0 {
	if gogetenv("DYLD_INSERT_LIBRARIES") != "" {
	throw("runtime: bsdthread_register error (unset DYLD_INSERT_LIBRARIES)")
	}
	throw("runtime: bsdthread_register error")
	}
	}
	}

	// May run with m.p==nil, so write barriers are not allowed.
	//go:nowritebarrier
	func newosproc(mp *m, stk unsafe.Pointer) {
	if false {
	print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " id=", mp.id, " ostk=", &mp, "\n")
	}

	var oset sigset
	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
	errno := bsdthread_create(stk, unsafe.Pointer(mp), funcPC(mstart))
	sigprocmask(_SIG_SETMASK, &oset, nil)

	if errno < 0 {
	print("runtime: failed to create new OS thread (have ", mcount(), " already; errno=", -errno, ")\n")
	throw("runtime.newosproc")
	}
	}

	// newosproc0 is a version of newosproc that can be called before the runtime
	// is initialized.
	//
	// As Go uses bsdthread_register when running without cgo, this function is
	// not safe to use after initialization as it does not pass an M as fnarg.
	//
	//go:nosplit
	func newosproc0(stacksize uintptr, fn uintptr) {
	stack := sysAlloc(stacksize, &memstats.stacks_sys)
	if stack == nil {
	write(2, unsafe.Pointer(&failallocatestack[0]), int32(len(failallocatestack)))
	exit(1)
	}
	stk := unsafe.Pointer(uintptr(stack) + stacksize)

	var oset sigset
	sigprocmask(_SIG_SETMASK, &sigset_all, &oset)
	errno := bsdthread_create(stk, nil, fn)
	sigprocmask(_SIG_SETMASK, &oset, nil)

	if errno < 0 {
	write(2, unsafe.Pointer(&failthreadcreate[0]), int32(len(failthreadcreate)))
	exit(1)
	}
	}

	var failallocatestack = []byte("runtime: failed to allocate stack for the new OS thread\n")
	var failthreadcreate = []byte("runtime: failed to create new OS thread\n")

	// Called to do synchronous initialization of Go code built with
	// -buildmode=c-archive or -buildmode=c-shared.
	// None of the Go runtime is initialized.
	//go:nosplit
	//go:nowritebarrierrec
	func libpreinit() {
	initsig(true)
	}

	// Called to initialize a new m (including the bootstrap m).
	// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
	func mpreinit(mp *m) {
	mp.gsignal = malg(32 * 1024) // OS X wants >= 8K
	mp.gsignal.m = mp
	}

	// Called to initialize a new m (including the bootstrap m).
	// Called on the new thread, cannot allocate memory.
	func minit() {
	// The alternate signal stack is buggy on arm and arm64.
	// The signal handler handles it directly.
	// The sigaltstack assembly function does nothing.
	if GOARCH != "arm" && GOARCH != "arm64" {
	minitSignalStack()
	}
	minitSignalMask()
	}

	// Called from dropm to undo the effect of an minit.
	//go:nosplit
	func unminit() {
	// The alternate signal stack is buggy on arm and arm64.
	// See minit.
	if GOARCH != "arm" && GOARCH != "arm64" {
	unminitSignals()
	}
	}

	// Mach IPC, to get at semaphores
	// Definitions are in /usr/include/mach on a Mac.

	func macherror(r int32, fn string) {
	print("mach error ", fn, ": ", r, "\n")
	throw("mach error")
	}

	const _DebugMach = false

	var zerondr machndr

	func mach_msgh_bits(a, b uint32) uint32 {
	return a \| b<<8
	}

	func mach_msg(h *machheader, op int32, send_size, rcv_size, rcv_name, timeout, notify uint32) int32 {
	// TODO: Loop on interrupt.
	return mach_msg_trap(unsafe.Pointer(h), op, send_size, rcv_size, rcv_name, timeout, notify)
	}

	// Mach RPC (MIG)
	const (
	_MinMachMsg = 48
	_MachReply = 100
	)

	type codemsg struct {
	h machheader
	ndr machndr
	code int32
	}

	func machcall(h *machheader, maxsize int32, rxsize int32) int32 {
	_g_ := getg()
	port := _g_.m.machport
	if port == 0 {
	port = mach_reply_port()
	_g_.m.machport = port
	}

	h.msgh_bits \|= mach_msgh_bits(_MACH_MSG_TYPE_COPY_SEND, _MACH_MSG_TYPE_MAKE_SEND_ONCE)
	h.msgh_local_port = port
	h.msgh_reserved = 0
	id := h.msgh_id

	if _DebugMach {
	p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
	print("send:\t")
	var i uint32
	for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
	print(" ", p[i])
	if i%8 == 7 {
	print("\n\t")
	}
	}
	if i%8 != 0 {
	print("\n")
	}
	}
	ret := mach_msg(h, _MACH_SEND_MSG\|_MACH_RCV_MSG, h.msgh_size, uint32(maxsize), port, 0, 0)
	if ret != 0 {
	if _DebugMach {
	print("mach_msg error ", ret, "\n")
	}
	return ret
	}
	if _DebugMach {
	p := (*[10000]unsafe.Pointer)(unsafe.Pointer(h))
	var i uint32
	for i = 0; i < h.msgh_size/uint32(unsafe.Sizeof(p[0])); i++ {
	print(" ", p[i])
	if i%8 == 7 {
	print("\n\t")
	}
	}
	if i%8 != 0 {
	print("\n")
	}
	}
	if h.msgh_id != id+_MachReply {
	if _DebugMach {
	print("mach_msg _MachReply id mismatch ", h.msgh_id, " != ", id+_MachReply, "\n")
	}
	return -303 // MIG_REPLY_MISMATCH
	}
	// Look for a response giving the return value.
	// Any call can send this back with an error,
	// and some calls only have return values so they
	// send it back on success too. I don't quite see how
	// you know it's one of these and not the full response
	// format, so just look if the message is right.
	c := (*codemsg)(unsafe.Pointer(h))
	if uintptr(h.msgh_size) == unsafe.Sizeof(*c) && h.msgh_bits&_MACH_MSGH_BITS_COMPLEX == 0 {
	if _DebugMach {
	print("mig result ", c.code, "\n")
	}
	return c.code
	}
	if h.msgh_size != uint32(rxsize) {
	if _DebugMach {
	print("mach_msg _MachReply size mismatch ", h.msgh_size, " != ", rxsize, "\n")
	}
	return -307 // MIG_ARRAY_TOO_LARGE
	}
	return 0
	}

	// Semaphores!

	const (
	tmach_semcreate = 3418
	rmach_semcreate = tmach_semcreate + _MachReply

	tmach_semdestroy = 3419
	rmach_semdestroy = tmach_semdestroy + _MachReply

	_KERN_ABORTED = 14
	_KERN_OPERATION_TIMED_OUT = 49
	)

	type tmach_semcreatemsg struct {
	h machheader
	ndr machndr
	policy int32
	value int32
	}

	type rmach_semcreatemsg struct {
	h machheader
	body machbody
	semaphore machport
	}

	type tmach_semdestroymsg struct {
	h machheader
	body machbody
	semaphore machport
	}

	func mach_semcreate() uint32 {
	var m [256]uint8
	tx := (*tmach_semcreatemsg)(unsafe.Pointer(&m))
	rx := (*rmach_semcreatemsg)(unsafe.Pointer(&m))

	tx.h.msgh_bits = 0
	tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
	tx.h.msgh_remote_port = mach_task_self()
	tx.h.msgh_id = tmach_semcreate
	tx.ndr = zerondr

	tx.policy = 0 // 0 = SYNC_POLICY_FIFO
	tx.value = 0

	for {
	r := machcall(&tx.h, int32(unsafe.Sizeof(m)), int32(unsafe.Sizeof(*rx)))
	if r == 0 {
	break
	}
	if r == _KERN_ABORTED { // interrupted
	continue
	}
	macherror(r, "semaphore_create")
	}
	if rx.body.msgh_descriptor_count != 1 {
	unimplemented("mach_semcreate desc count")
	}
	return rx.semaphore.name
	}

	func mach_semdestroy(sem uint32) {
	var m [256]uint8
	tx := (*tmach_semdestroymsg)(unsafe.Pointer(&m))

	tx.h.msgh_bits = _MACH_MSGH_BITS_COMPLEX
	tx.h.msgh_size = uint32(unsafe.Sizeof(*tx))
	tx.h.msgh_remote_port = mach_task_self()
	tx.h.msgh_id = tmach_semdestroy
	tx.body.msgh_descriptor_count = 1
	tx.semaphore.name = sem
	tx.semaphore.disposition = _MACH_MSG_TYPE_MOVE_SEND
	tx.semaphore._type = 0

	for {
	r := machcall(&tx.h, int32(unsafe.Sizeof(m)), 0)
	if r == 0 {
	break
	}
	if r == _KERN_ABORTED { // interrupted
	continue
	}
	macherror(r, "semaphore_destroy")
	}
	}

	// The other calls have simple system call traps in sys_darwin_{amd64,386}.s

	func mach_semaphore_wait(sema uint32) int32
	func mach_semaphore_timedwait(sema, sec, nsec uint32) int32
	func mach_semaphore_signal(sema uint32) int32
	func mach_semaphore_signal_all(sema uint32) int32

	func semasleep1(ns int64) int32 {
	_g_ := getg()

	if ns >= 0 {
	var nsecs int32
	secs := timediv(ns, 1000000000, &nsecs)
	r := mach_semaphore_timedwait(_g_.m.waitsema, uint32(secs), uint32(nsecs))
	if r == _KERN_ABORTED \|\| r == _KERN_OPERATION_TIMED_OUT {
	return -1
	}
	if r != 0 {
	macherror(r, "semaphore_wait")
	}
	return 0
	}

	for {
	r := mach_semaphore_wait(_g_.m.waitsema)
	if r == 0 {
	break
	}
	// Note: We don't know how this call (with no timeout) can get _KERN_OPERATION_TIMED_OUT,
	// but it does reliably, though at a very low rate, on OS X 10.8, 10.9, 10.10, and 10.11.
	// See golang.org/issue/17161.
	if r == _KERN_ABORTED \|\| r == _KERN_OPERATION_TIMED_OUT { // interrupted
	continue
	}
	macherror(r, "semaphore_wait")
	}
	return 0
	}

	//go:nosplit
	func semasleep(ns int64) int32 {
	var r int32
	systemstack(func() {
	r = semasleep1(ns)
	})
	return r
	}

	//go:nosplit
	func mach_semrelease(sem uint32) {
	for {
	r := mach_semaphore_signal(sem)
	if r == 0 {
	break
	}
	if r == _KERN_ABORTED { // interrupted
	continue
	}

	// mach_semrelease must be completely nosplit,
	// because it is called from Go code.
	// If we're going to die, start that process on the system stack
	// to avoid a Go stack split.
	systemstack(func() { macherror(r, "semaphore_signal") })
	}
	}

	//go:nosplit
	func osyield() {
	usleep(1)
	}

	func memlimit() uintptr {
	// NOTE(rsc): Could use getrlimit here,
	// like on FreeBSD or Linux, but Darwin doesn't enforce
	// ulimit -v, so it's unclear why we'd try to stay within
	// the limit.
	return 0
	}

	const (
	_NSIG = 32
	_SI_USER = 0 /* empirically true, but not what headers say */
	_SIG_BLOCK = 1
	_SIG_UNBLOCK = 2
	_SIG_SETMASK = 3
	_SS_DISABLE = 4
	)

	//go:noescape
	func sigprocmask(how int32, new, old *sigset)

	//go:noescape
	func sigaction(mode uint32, new sigactiont, old usigactiont)

	//go:noescape
	func sigaltstack(new, old *stackt)

	// darwin/arm64 uses registers instead of stack-based arguments.
	// TODO: does this matter?
	func sigtramp(fn uintptr, infostyle, sig uint32, info *siginfo, ctx unsafe.Pointer)

	//go:noescape
	func setitimer(mode int32, new, old *itimerval)

	func raise(sig uint32)
	func raiseproc(sig uint32)

	//extern SigTabTT runtime·sigtab[];

	type sigset uint32

	var sigset_all = ^sigset(0)

	//go:nosplit
	//go:nowritebarrierrec
	func setsig(i uint32, fn uintptr) {
	var sa sigactiont
	sa.sa_flags = _SA_SIGINFO \| _SA_ONSTACK \| _SA_RESTART
	sa.sa_mask = ^uint32(0)
	sa.sa_tramp = unsafe.Pointer(funcPC(sigtramp)) // runtime·sigtramp's job is to call into real handler
	(uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = fn
	sigaction(i, &sa, nil)
	}

	//go:nosplit
	//go:nowritebarrierrec
	func setsigstack(i uint32) {
	var osa usigactiont
	sigaction(i, nil, &osa)
	handler := (uintptr)(unsafe.Pointer(&osa.__sigaction_u))
	if osa.sa_flags&_SA_ONSTACK != 0 {
	return
	}
	var sa sigactiont
	(uintptr)(unsafe.Pointer(&sa.__sigaction_u)) = handler
	sa.sa_tramp = unsafe.Pointer(funcPC(sigtramp))
	sa.sa_mask = osa.sa_mask
	sa.sa_flags = osa.sa_flags \| _SA_ONSTACK
	sigaction(i, &sa, nil)
	}

	//go:nosplit
	//go:nowritebarrierrec
	func getsig(i uint32) uintptr {
	var sa usigactiont
	sigaction(i, nil, &sa)
	return (uintptr)(unsafe.Pointer(&sa.__sigaction_u))
	}

	// setSignaltstackSP sets the ss_sp field of a stackt.
	//go:nosplit
	func setSignalstackSP(s *stackt, sp uintptr) {
	(uintptr)(unsafe.Pointer(&s.ss_sp)) = sp
	}

	//go:nosplit
	//go:nowritebarrierrec
	func sigaddset(mask *sigset, i int) {
	*mask \|= 1 << (uint32(i) - 1)
	}

	func sigdelset(mask *sigset, i int) {
	*mask &^= 1 << (uint32(i) - 1)
	}

	//go:linkname executablePath os.executablePath
	var executablePath string

	func sysargs(argc int32, argv **byte) {
	// skip over argv, envv and the first string will be the path
	n := argc + 1
	for argv_index(argv, n) != nil {
	n++
	}
	executablePath = gostringnocopy(argv_index(argv, n+1))

	// strip "executable_path=" prefix if available, it's added after OS X 10.11.
	const prefix = "executable_path="
	if len(executablePath) > len(prefix) && executablePath[:len(prefix)] == prefix {
	executablePath = executablePath[len(prefix):]
	}
	}