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