github.com/comwrg/go/src@v0.0.0-20220319063731-c238d0440370/runtime/sys_darwin.go (about) 1 // Copyright 2018 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package runtime 6 7 import ( 8 "github.com/comwrg/go/src/internal/abi" 9 "unsafe" 10 ) 11 12 // The X versions of syscall expect the libc call to return a 64-bit result. 13 // Otherwise (the non-X version) expects a 32-bit result. 14 // This distinction is required because an error is indicated by returning -1, 15 // and we need to know whether to check 32 or 64 bits of the result. 16 // (Some libc functions that return 32 bits put junk in the upper 32 bits of AX.) 17 18 //go:linkname syscall_syscall syscall.syscall 19 //go:nosplit 20 //go:cgo_unsafe_args 21 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 22 entersyscall() 23 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&fn)) 24 exitsyscall() 25 return 26 } 27 func syscall() 28 29 //go:linkname syscall_syscallX syscall.syscallX 30 //go:nosplit 31 //go:cgo_unsafe_args 32 func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 33 entersyscall() 34 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallX)), unsafe.Pointer(&fn)) 35 exitsyscall() 36 return 37 } 38 func syscallX() 39 40 //go:linkname syscall_syscall6 syscall.syscall6 41 //go:nosplit 42 //go:cgo_unsafe_args 43 func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 44 entersyscall() 45 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&fn)) 46 exitsyscall() 47 return 48 } 49 func syscall6() 50 51 //go:linkname syscall_syscall6X syscall.syscall6X 52 //go:nosplit 53 //go:cgo_unsafe_args 54 func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 55 entersyscall() 56 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6X)), unsafe.Pointer(&fn)) 57 exitsyscall() 58 return 59 } 60 func syscall6X() 61 62 //go:linkname syscall_syscallPtr syscall.syscallPtr 63 //go:nosplit 64 //go:cgo_unsafe_args 65 func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 66 entersyscall() 67 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallPtr)), unsafe.Pointer(&fn)) 68 exitsyscall() 69 return 70 } 71 func syscallPtr() 72 73 //go:linkname syscall_rawSyscall syscall.rawSyscall 74 //go:nosplit 75 //go:cgo_unsafe_args 76 func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) { 77 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&fn)) 78 return 79 } 80 81 //go:linkname syscall_rawSyscall6 syscall.rawSyscall6 82 //go:nosplit 83 //go:cgo_unsafe_args 84 func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) { 85 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&fn)) 86 return 87 } 88 89 // syscallNoErr is used in crypto/x509 to call into Security.framework and CF. 90 91 //go:linkname crypto_x509_syscall crypto/x509/internal/macos.syscall 92 //go:nosplit 93 //go:cgo_unsafe_args 94 func crypto_x509_syscall(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1 uintptr) { 95 entersyscall() 96 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallNoErr)), unsafe.Pointer(&fn)) 97 exitsyscall() 98 return 99 } 100 func syscallNoErr() 101 102 // The *_trampoline functions convert from the Go calling convention to the C calling convention 103 // and then call the underlying libc function. They are defined in sys_darwin_$ARCH.s. 104 105 //go:nosplit 106 //go:cgo_unsafe_args 107 func pthread_attr_init(attr *pthreadattr) int32 { 108 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr)) 109 KeepAlive(attr) 110 return ret 111 } 112 func pthread_attr_init_trampoline() 113 114 //go:nosplit 115 //go:cgo_unsafe_args 116 func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 { 117 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr)) 118 KeepAlive(attr) 119 KeepAlive(size) 120 return ret 121 } 122 func pthread_attr_getstacksize_trampoline() 123 124 //go:nosplit 125 //go:cgo_unsafe_args 126 func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 { 127 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr)) 128 KeepAlive(attr) 129 return ret 130 } 131 func pthread_attr_setdetachstate_trampoline() 132 133 //go:nosplit 134 //go:cgo_unsafe_args 135 func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 { 136 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr)) 137 KeepAlive(attr) 138 KeepAlive(arg) // Just for consistency. Arg of course needs to be kept alive for the start function. 139 return ret 140 } 141 func pthread_create_trampoline() 142 143 //go:nosplit 144 //go:cgo_unsafe_args 145 func raise(sig uint32) { 146 libcCall(unsafe.Pointer(abi.FuncPCABI0(raise_trampoline)), unsafe.Pointer(&sig)) 147 } 148 func raise_trampoline() 149 150 //go:nosplit 151 //go:cgo_unsafe_args 152 func pthread_self() (t pthread) { 153 libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_self_trampoline)), unsafe.Pointer(&t)) 154 return 155 } 156 func pthread_self_trampoline() 157 158 //go:nosplit 159 //go:cgo_unsafe_args 160 func pthread_kill(t pthread, sig uint32) { 161 libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_kill_trampoline)), unsafe.Pointer(&t)) 162 return 163 } 164 func pthread_kill_trampoline() 165 166 // mmap is used to do low-level memory allocation via mmap. Don't allow stack 167 // splits, since this function (used by sysAlloc) is called in a lot of low-level 168 // parts of the runtime and callers often assume it won't acquire any locks. 169 // go:nosplit 170 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) { 171 args := struct { 172 addr unsafe.Pointer 173 n uintptr 174 prot, flags, fd int32 175 off uint32 176 ret1 unsafe.Pointer 177 ret2 int 178 }{addr, n, prot, flags, fd, off, nil, 0} 179 libcCall(unsafe.Pointer(abi.FuncPCABI0(mmap_trampoline)), unsafe.Pointer(&args)) 180 return args.ret1, args.ret2 181 } 182 func mmap_trampoline() 183 184 //go:nosplit 185 //go:cgo_unsafe_args 186 func munmap(addr unsafe.Pointer, n uintptr) { 187 libcCall(unsafe.Pointer(abi.FuncPCABI0(munmap_trampoline)), unsafe.Pointer(&addr)) 188 KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address. 189 } 190 func munmap_trampoline() 191 192 //go:nosplit 193 //go:cgo_unsafe_args 194 func madvise(addr unsafe.Pointer, n uintptr, flags int32) { 195 libcCall(unsafe.Pointer(abi.FuncPCABI0(madvise_trampoline)), unsafe.Pointer(&addr)) 196 KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address. 197 } 198 func madvise_trampoline() 199 200 //go:nosplit 201 //go:cgo_unsafe_args 202 func mlock(addr unsafe.Pointer, n uintptr) { 203 libcCall(unsafe.Pointer(abi.FuncPCABI0(mlock_trampoline)), unsafe.Pointer(&addr)) 204 KeepAlive(addr) // Just for consistency. Hopefully addr is not a Go address. 205 } 206 func mlock_trampoline() 207 208 //go:nosplit 209 //go:cgo_unsafe_args 210 func read(fd int32, p unsafe.Pointer, n int32) int32 { 211 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd)) 212 KeepAlive(p) 213 return ret 214 } 215 func read_trampoline() 216 217 func pipe() (r, w int32, errno int32) { 218 var p [2]int32 219 errno = libcCall(unsafe.Pointer(abi.FuncPCABI0(pipe_trampoline)), noescape(unsafe.Pointer(&p))) 220 return p[0], p[1], errno 221 } 222 func pipe_trampoline() 223 224 //go:nosplit 225 //go:cgo_unsafe_args 226 func closefd(fd int32) int32 { 227 return libcCall(unsafe.Pointer(abi.FuncPCABI0(close_trampoline)), unsafe.Pointer(&fd)) 228 } 229 func close_trampoline() 230 231 //go:nosplit 232 //go:cgo_unsafe_args 233 // 234 // This is exported via linkname to assembly in runtime/cgo. 235 //go:linkname exit 236 func exit(code int32) { 237 libcCall(unsafe.Pointer(abi.FuncPCABI0(exit_trampoline)), unsafe.Pointer(&code)) 238 } 239 func exit_trampoline() 240 241 //go:nosplit 242 //go:cgo_unsafe_args 243 func usleep(usec uint32) { 244 libcCall(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec)) 245 } 246 func usleep_trampoline() 247 248 //go:nosplit 249 //go:cgo_unsafe_args 250 func usleep_no_g(usec uint32) { 251 asmcgocall_no_g(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec)) 252 } 253 254 //go:nosplit 255 //go:cgo_unsafe_args 256 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 { 257 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd)) 258 KeepAlive(p) 259 return ret 260 } 261 func write_trampoline() 262 263 //go:nosplit 264 //go:cgo_unsafe_args 265 func open(name *byte, mode, perm int32) (ret int32) { 266 ret = libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name)) 267 KeepAlive(name) 268 return 269 } 270 func open_trampoline() 271 272 //go:nosplit 273 //go:cgo_unsafe_args 274 func nanotime1() int64 { 275 var r struct { 276 t int64 // raw timer 277 numer, denom uint32 // conversion factors. nanoseconds = t * numer / denom. 278 } 279 libcCall(unsafe.Pointer(abi.FuncPCABI0(nanotime_trampoline)), unsafe.Pointer(&r)) 280 // Note: Apple seems unconcerned about overflow here. See 281 // https://developer.apple.com/library/content/qa/qa1398/_index.html 282 // Note also, numer == denom == 1 is common. 283 t := r.t 284 if r.numer != 1 { 285 t *= int64(r.numer) 286 } 287 if r.denom != 1 { 288 t /= int64(r.denom) 289 } 290 return t 291 } 292 func nanotime_trampoline() 293 294 //go:nosplit 295 //go:cgo_unsafe_args 296 func walltime() (int64, int32) { 297 var t timespec 298 libcCall(unsafe.Pointer(abi.FuncPCABI0(walltime_trampoline)), unsafe.Pointer(&t)) 299 return t.tv_sec, int32(t.tv_nsec) 300 } 301 func walltime_trampoline() 302 303 //go:nosplit 304 //go:cgo_unsafe_args 305 func sigaction(sig uint32, new *usigactiont, old *usigactiont) { 306 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaction_trampoline)), unsafe.Pointer(&sig)) 307 KeepAlive(new) 308 KeepAlive(old) 309 } 310 func sigaction_trampoline() 311 312 //go:nosplit 313 //go:cgo_unsafe_args 314 func sigprocmask(how uint32, new *sigset, old *sigset) { 315 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigprocmask_trampoline)), unsafe.Pointer(&how)) 316 KeepAlive(new) 317 KeepAlive(old) 318 } 319 func sigprocmask_trampoline() 320 321 //go:nosplit 322 //go:cgo_unsafe_args 323 func sigaltstack(new *stackt, old *stackt) { 324 if new != nil && new.ss_flags&_SS_DISABLE != 0 && new.ss_size == 0 { 325 // Despite the fact that Darwin's sigaltstack man page says it ignores the size 326 // when SS_DISABLE is set, it doesn't. sigaltstack returns ENOMEM 327 // if we don't give it a reasonable size. 328 // ref: http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20140421/214296.html 329 new.ss_size = 32768 330 } 331 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaltstack_trampoline)), unsafe.Pointer(&new)) 332 KeepAlive(new) 333 KeepAlive(old) 334 } 335 func sigaltstack_trampoline() 336 337 //go:nosplit 338 //go:cgo_unsafe_args 339 func raiseproc(sig uint32) { 340 libcCall(unsafe.Pointer(abi.FuncPCABI0(raiseproc_trampoline)), unsafe.Pointer(&sig)) 341 } 342 func raiseproc_trampoline() 343 344 //go:nosplit 345 //go:cgo_unsafe_args 346 func setitimer(mode int32, new, old *itimerval) { 347 libcCall(unsafe.Pointer(abi.FuncPCABI0(setitimer_trampoline)), unsafe.Pointer(&mode)) 348 KeepAlive(new) 349 KeepAlive(old) 350 } 351 func setitimer_trampoline() 352 353 //go:nosplit 354 //go:cgo_unsafe_args 355 func sysctl(mib *uint32, miblen uint32, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 { 356 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib)) 357 KeepAlive(mib) 358 KeepAlive(oldp) 359 KeepAlive(oldlenp) 360 KeepAlive(newp) 361 return ret 362 } 363 func sysctl_trampoline() 364 365 //go:nosplit 366 //go:cgo_unsafe_args 367 func sysctlbyname(name *byte, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 { 368 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctlbyname_trampoline)), unsafe.Pointer(&name)) 369 KeepAlive(name) 370 KeepAlive(oldp) 371 KeepAlive(oldlenp) 372 KeepAlive(newp) 373 return ret 374 } 375 func sysctlbyname_trampoline() 376 377 //go:nosplit 378 //go:cgo_unsafe_args 379 func fcntl(fd, cmd, arg int32) int32 { 380 return libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&fd)) 381 } 382 func fcntl_trampoline() 383 384 //go:nosplit 385 //go:cgo_unsafe_args 386 func kqueue() int32 { 387 v := libcCall(unsafe.Pointer(abi.FuncPCABI0(kqueue_trampoline)), nil) 388 return v 389 } 390 func kqueue_trampoline() 391 392 //go:nosplit 393 //go:cgo_unsafe_args 394 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 { 395 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq)) 396 KeepAlive(ch) 397 KeepAlive(ev) 398 KeepAlive(ts) 399 return ret 400 } 401 func kevent_trampoline() 402 403 //go:nosplit 404 //go:cgo_unsafe_args 405 func pthread_mutex_init(m *pthreadmutex, attr *pthreadmutexattr) int32 { 406 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_init_trampoline)), unsafe.Pointer(&m)) 407 KeepAlive(m) 408 KeepAlive(attr) 409 return ret 410 } 411 func pthread_mutex_init_trampoline() 412 413 //go:nosplit 414 //go:cgo_unsafe_args 415 func pthread_mutex_lock(m *pthreadmutex) int32 { 416 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m)) 417 KeepAlive(m) 418 return ret 419 } 420 func pthread_mutex_lock_trampoline() 421 422 //go:nosplit 423 //go:cgo_unsafe_args 424 func pthread_mutex_unlock(m *pthreadmutex) int32 { 425 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m)) 426 KeepAlive(m) 427 return ret 428 } 429 func pthread_mutex_unlock_trampoline() 430 431 //go:nosplit 432 //go:cgo_unsafe_args 433 func pthread_cond_init(c *pthreadcond, attr *pthreadcondattr) int32 { 434 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_init_trampoline)), unsafe.Pointer(&c)) 435 KeepAlive(c) 436 KeepAlive(attr) 437 return ret 438 } 439 func pthread_cond_init_trampoline() 440 441 //go:nosplit 442 //go:cgo_unsafe_args 443 func pthread_cond_wait(c *pthreadcond, m *pthreadmutex) int32 { 444 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_wait_trampoline)), unsafe.Pointer(&c)) 445 KeepAlive(c) 446 KeepAlive(m) 447 return ret 448 } 449 func pthread_cond_wait_trampoline() 450 451 //go:nosplit 452 //go:cgo_unsafe_args 453 func pthread_cond_timedwait_relative_np(c *pthreadcond, m *pthreadmutex, t *timespec) int32 { 454 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c)) 455 KeepAlive(c) 456 KeepAlive(m) 457 KeepAlive(t) 458 return ret 459 } 460 func pthread_cond_timedwait_relative_np_trampoline() 461 462 //go:nosplit 463 //go:cgo_unsafe_args 464 func pthread_cond_signal(c *pthreadcond) int32 { 465 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_signal_trampoline)), unsafe.Pointer(&c)) 466 KeepAlive(c) 467 return ret 468 } 469 func pthread_cond_signal_trampoline() 470 471 // Not used on Darwin, but must be defined. 472 func exitThread(wait *uint32) { 473 } 474 475 //go:nosplit 476 func closeonexec(fd int32) { 477 fcntl(fd, _F_SETFD, _FD_CLOEXEC) 478 } 479 480 //go:nosplit 481 func setNonblock(fd int32) { 482 flags := fcntl(fd, _F_GETFL, 0) 483 fcntl(fd, _F_SETFL, flags|_O_NONBLOCK) 484 } 485 486 // Tell the linker that the libc_* functions are to be found 487 // in a system library, with the libc_ prefix missing. 488 489 //go:cgo_import_dynamic libc_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib" 490 //go:cgo_import_dynamic libc_pthread_attr_getstacksize pthread_attr_getstacksize "/usr/lib/libSystem.B.dylib" 491 //go:cgo_import_dynamic libc_pthread_attr_setdetachstate pthread_attr_setdetachstate "/usr/lib/libSystem.B.dylib" 492 //go:cgo_import_dynamic libc_pthread_create pthread_create "/usr/lib/libSystem.B.dylib" 493 //go:cgo_import_dynamic libc_pthread_self pthread_self "/usr/lib/libSystem.B.dylib" 494 //go:cgo_import_dynamic libc_pthread_kill pthread_kill "/usr/lib/libSystem.B.dylib" 495 //go:cgo_import_dynamic libc_exit _exit "/usr/lib/libSystem.B.dylib" 496 //go:cgo_import_dynamic libc_raise raise "/usr/lib/libSystem.B.dylib" 497 498 //go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib" 499 //go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib" 500 //go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib" 501 //go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib" 502 //go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib" 503 504 //go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib" 505 //go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib" 506 //go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib" 507 //go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib" 508 //go:cgo_import_dynamic libc_error __error "/usr/lib/libSystem.B.dylib" 509 //go:cgo_import_dynamic libc_usleep usleep "/usr/lib/libSystem.B.dylib" 510 511 //go:cgo_import_dynamic libc_mach_timebase_info mach_timebase_info "/usr/lib/libSystem.B.dylib" 512 //go:cgo_import_dynamic libc_mach_absolute_time mach_absolute_time "/usr/lib/libSystem.B.dylib" 513 //go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib" 514 //go:cgo_import_dynamic libc_sigaction sigaction "/usr/lib/libSystem.B.dylib" 515 //go:cgo_import_dynamic libc_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib" 516 //go:cgo_import_dynamic libc_sigaltstack sigaltstack "/usr/lib/libSystem.B.dylib" 517 //go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib" 518 //go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib" 519 //go:cgo_import_dynamic libc_setitimer setitimer "/usr/lib/libSystem.B.dylib" 520 //go:cgo_import_dynamic libc_sysctl sysctl "/usr/lib/libSystem.B.dylib" 521 //go:cgo_import_dynamic libc_sysctlbyname sysctlbyname "/usr/lib/libSystem.B.dylib" 522 //go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib" 523 //go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib" 524 //go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib" 525 526 //go:cgo_import_dynamic libc_pthread_mutex_init pthread_mutex_init "/usr/lib/libSystem.B.dylib" 527 //go:cgo_import_dynamic libc_pthread_mutex_lock pthread_mutex_lock "/usr/lib/libSystem.B.dylib" 528 //go:cgo_import_dynamic libc_pthread_mutex_unlock pthread_mutex_unlock "/usr/lib/libSystem.B.dylib" 529 //go:cgo_import_dynamic libc_pthread_cond_init pthread_cond_init "/usr/lib/libSystem.B.dylib" 530 //go:cgo_import_dynamic libc_pthread_cond_wait pthread_cond_wait "/usr/lib/libSystem.B.dylib" 531 //go:cgo_import_dynamic libc_pthread_cond_timedwait_relative_np pthread_cond_timedwait_relative_np "/usr/lib/libSystem.B.dylib" 532 //go:cgo_import_dynamic libc_pthread_cond_signal pthread_cond_signal "/usr/lib/libSystem.B.dylib"