Source file
src/runtime/sys_darwin.go
1
2
3
4
5 package runtime
6
7 import (
8 "internal/abi"
9 "runtime/internal/atomic"
10 "unsafe"
11 )
12
13
14
15
16
17
18
19
20
21 func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
22 args := struct{ fn, a1, a2, a3, r1, r2, err uintptr }{fn, a1, a2, a3, r1, r2, err}
23 entersyscall()
24 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&args))
25 exitsyscall()
26 return args.r1, args.r2, args.err
27 }
28 func syscall()
29
30
31
32 func syscall_syscallX(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
33 args := struct{ fn, a1, a2, a3, r1, r2, err uintptr }{fn, a1, a2, a3, r1, r2, err}
34 entersyscall()
35 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallX)), unsafe.Pointer(&args))
36 exitsyscall()
37 return args.r1, args.r2, args.err
38 }
39 func syscallX()
40
41
42
43 func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
44 args := struct{ fn, a1, a2, a3, a4, a5, a6, r1, r2, err uintptr }{fn, a1, a2, a3, a4, a5, a6, r1, r2, err}
45 entersyscall()
46 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&args))
47 exitsyscall()
48 return args.r1, args.r2, args.err
49 }
50 func syscall6()
51
52
53
54 func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
55 args := struct{ fn, a1, a2, a3, a4, a5, a6, r1, r2, err uintptr }{fn, a1, a2, a3, a4, a5, a6, r1, r2, err}
56 entersyscall()
57 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6X)), unsafe.Pointer(&args))
58 exitsyscall()
59 return args.r1, args.r2, args.err
60 }
61 func syscall6X()
62
63
64
65 func syscall_syscallPtr(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
66 args := struct{ fn, a1, a2, a3, r1, r2, err uintptr }{fn, a1, a2, a3, r1, r2, err}
67 entersyscall()
68 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscallPtr)), unsafe.Pointer(&args))
69 exitsyscall()
70 return args.r1, args.r2, args.err
71 }
72 func syscallPtr()
73
74
75
76 func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) {
77 args := struct{ fn, a1, a2, a3, r1, r2, err uintptr }{fn, a1, a2, a3, r1, r2, err}
78 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall)), unsafe.Pointer(&args))
79 return args.r1, args.r2, args.err
80 }
81
82
83
84 func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) {
85 args := struct{ fn, a1, a2, a3, a4, a5, a6, r1, r2, err uintptr }{fn, a1, a2, a3, a4, a5, a6, r1, r2, err}
86 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall6)), unsafe.Pointer(&args))
87 return args.r1, args.r2, args.err
88 }
89
90
91
92
93
94 func crypto_x509_syscall(fn, a1, a2, a3, a4, a5 uintptr, f1 float64) (r1 uintptr) {
95 args := struct {
96 fn, a1, a2, a3, a4, a5 uintptr
97 f1 float64
98 r1 uintptr
99 }{fn, a1, a2, a3, a4, a5, f1, r1}
100 entersyscall()
101 libcCall(unsafe.Pointer(abi.FuncPCABI0(syscall_x509)), unsafe.Pointer(&args))
102 exitsyscall()
103 return args.r1
104 }
105 func syscall_x509()
106
107
108
109
110
111
112 func pthread_attr_init(attr *pthreadattr) int32 {
113 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_init_trampoline)), unsafe.Pointer(&attr))
114 KeepAlive(attr)
115 return ret
116 }
117 func pthread_attr_init_trampoline()
118
119
120
121 func pthread_attr_getstacksize(attr *pthreadattr, size *uintptr) int32 {
122 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_getstacksize_trampoline)), unsafe.Pointer(&attr))
123 KeepAlive(attr)
124 KeepAlive(size)
125 return ret
126 }
127 func pthread_attr_getstacksize_trampoline()
128
129
130
131 func pthread_attr_setdetachstate(attr *pthreadattr, state int) int32 {
132 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_attr_setdetachstate_trampoline)), unsafe.Pointer(&attr))
133 KeepAlive(attr)
134 return ret
135 }
136 func pthread_attr_setdetachstate_trampoline()
137
138
139
140 func pthread_create(attr *pthreadattr, start uintptr, arg unsafe.Pointer) int32 {
141 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_create_trampoline)), unsafe.Pointer(&attr))
142 KeepAlive(attr)
143 KeepAlive(arg)
144 return ret
145 }
146 func pthread_create_trampoline()
147
148
149
150 func raise(sig uint32) {
151 libcCall(unsafe.Pointer(abi.FuncPCABI0(raise_trampoline)), unsafe.Pointer(&sig))
152 }
153 func raise_trampoline()
154
155
156
157 func pthread_self() (t pthread) {
158 libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_self_trampoline)), unsafe.Pointer(&t))
159 return
160 }
161 func pthread_self_trampoline()
162
163
164
165 func pthread_kill(t pthread, sig uint32) {
166 libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_kill_trampoline)), unsafe.Pointer(&t))
167 return
168 }
169 func pthread_kill_trampoline()
170
171
172
173
174
175
176 func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (unsafe.Pointer, int) {
177 args := struct {
178 addr unsafe.Pointer
179 n uintptr
180 prot, flags, fd int32
181 off uint32
182 ret1 unsafe.Pointer
183 ret2 int
184 }{addr, n, prot, flags, fd, off, nil, 0}
185 libcCall(unsafe.Pointer(abi.FuncPCABI0(mmap_trampoline)), unsafe.Pointer(&args))
186 return args.ret1, args.ret2
187 }
188 func mmap_trampoline()
189
190
191
192 func munmap(addr unsafe.Pointer, n uintptr) {
193 libcCall(unsafe.Pointer(abi.FuncPCABI0(munmap_trampoline)), unsafe.Pointer(&addr))
194 KeepAlive(addr)
195 }
196 func munmap_trampoline()
197
198
199
200 func madvise(addr unsafe.Pointer, n uintptr, flags int32) {
201 libcCall(unsafe.Pointer(abi.FuncPCABI0(madvise_trampoline)), unsafe.Pointer(&addr))
202 KeepAlive(addr)
203 }
204 func madvise_trampoline()
205
206
207
208 func mlock(addr unsafe.Pointer, n uintptr) {
209 libcCall(unsafe.Pointer(abi.FuncPCABI0(mlock_trampoline)), unsafe.Pointer(&addr))
210 KeepAlive(addr)
211 }
212 func mlock_trampoline()
213
214
215
216 func read(fd int32, p unsafe.Pointer, n int32) int32 {
217 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(read_trampoline)), unsafe.Pointer(&fd))
218 KeepAlive(p)
219 return ret
220 }
221 func read_trampoline()
222
223 func pipe() (r, w int32, errno int32) {
224 var p [2]int32
225 errno = libcCall(unsafe.Pointer(abi.FuncPCABI0(pipe_trampoline)), noescape(unsafe.Pointer(&p)))
226 return p[0], p[1], errno
227 }
228 func pipe_trampoline()
229
230
231
232 func closefd(fd int32) int32 {
233 return libcCall(unsafe.Pointer(abi.FuncPCABI0(close_trampoline)), unsafe.Pointer(&fd))
234 }
235 func close_trampoline()
236
237
238
239
240
241
242 func exit(code int32) {
243 libcCall(unsafe.Pointer(abi.FuncPCABI0(exit_trampoline)), unsafe.Pointer(&code))
244 }
245 func exit_trampoline()
246
247
248
249 func usleep(usec uint32) {
250 libcCall(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec))
251 }
252 func usleep_trampoline()
253
254
255
256 func usleep_no_g(usec uint32) {
257 asmcgocall_no_g(unsafe.Pointer(abi.FuncPCABI0(usleep_trampoline)), unsafe.Pointer(&usec))
258 }
259
260
261
262 func write1(fd uintptr, p unsafe.Pointer, n int32) int32 {
263 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(write_trampoline)), unsafe.Pointer(&fd))
264 KeepAlive(p)
265 return ret
266 }
267 func write_trampoline()
268
269
270
271 func open(name *byte, mode, perm int32) (ret int32) {
272 ret = libcCall(unsafe.Pointer(abi.FuncPCABI0(open_trampoline)), unsafe.Pointer(&name))
273 KeepAlive(name)
274 return
275 }
276 func open_trampoline()
277
278
279
280 func nanotime1() int64 {
281 var r struct {
282 t int64
283 numer, denom uint32
284 }
285 libcCall(unsafe.Pointer(abi.FuncPCABI0(nanotime_trampoline)), unsafe.Pointer(&r))
286
287
288
289 t := r.t
290 if r.numer != 1 {
291 t *= int64(r.numer)
292 }
293 if r.denom != 1 {
294 t /= int64(r.denom)
295 }
296 return t
297 }
298 func nanotime_trampoline()
299
300
301
302 func walltime() (int64, int32) {
303 var t timespec
304 libcCall(unsafe.Pointer(abi.FuncPCABI0(walltime_trampoline)), unsafe.Pointer(&t))
305 return t.tv_sec, int32(t.tv_nsec)
306 }
307 func walltime_trampoline()
308
309
310
311 func sigaction(sig uint32, new *usigactiont, old *usigactiont) {
312 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaction_trampoline)), unsafe.Pointer(&sig))
313 KeepAlive(new)
314 KeepAlive(old)
315 }
316 func sigaction_trampoline()
317
318
319
320 func sigprocmask(how uint32, new *sigset, old *sigset) {
321 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigprocmask_trampoline)), unsafe.Pointer(&how))
322 KeepAlive(new)
323 KeepAlive(old)
324 }
325 func sigprocmask_trampoline()
326
327
328
329 func sigaltstack(new *stackt, old *stackt) {
330 if new != nil && new.ss_flags&_SS_DISABLE != 0 && new.ss_size == 0 {
331
332
333
334
335 new.ss_size = 32768
336 }
337 libcCall(unsafe.Pointer(abi.FuncPCABI0(sigaltstack_trampoline)), unsafe.Pointer(&new))
338 KeepAlive(new)
339 KeepAlive(old)
340 }
341 func sigaltstack_trampoline()
342
343
344
345 func raiseproc(sig uint32) {
346 libcCall(unsafe.Pointer(abi.FuncPCABI0(raiseproc_trampoline)), unsafe.Pointer(&sig))
347 }
348 func raiseproc_trampoline()
349
350
351
352 func setitimer(mode int32, new, old *itimerval) {
353 libcCall(unsafe.Pointer(abi.FuncPCABI0(setitimer_trampoline)), unsafe.Pointer(&mode))
354 KeepAlive(new)
355 KeepAlive(old)
356 }
357 func setitimer_trampoline()
358
359
360
361 func sysctl(mib *uint32, miblen uint32, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
362 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctl_trampoline)), unsafe.Pointer(&mib))
363 KeepAlive(mib)
364 KeepAlive(oldp)
365 KeepAlive(oldlenp)
366 KeepAlive(newp)
367 return ret
368 }
369 func sysctl_trampoline()
370
371
372
373 func sysctlbyname(name *byte, oldp *byte, oldlenp *uintptr, newp *byte, newlen uintptr) int32 {
374 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(sysctlbyname_trampoline)), unsafe.Pointer(&name))
375 KeepAlive(name)
376 KeepAlive(oldp)
377 KeepAlive(oldlenp)
378 KeepAlive(newp)
379 return ret
380 }
381 func sysctlbyname_trampoline()
382
383
384
385 func fcntl(fd, cmd, arg int32) int32 {
386 return libcCall(unsafe.Pointer(abi.FuncPCABI0(fcntl_trampoline)), unsafe.Pointer(&fd))
387 }
388 func fcntl_trampoline()
389
390
391
392 func kqueue() int32 {
393 v := libcCall(unsafe.Pointer(abi.FuncPCABI0(kqueue_trampoline)), nil)
394 return v
395 }
396 func kqueue_trampoline()
397
398
399
400 func kevent(kq int32, ch *keventt, nch int32, ev *keventt, nev int32, ts *timespec) int32 {
401 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(kevent_trampoline)), unsafe.Pointer(&kq))
402 KeepAlive(ch)
403 KeepAlive(ev)
404 KeepAlive(ts)
405 return ret
406 }
407 func kevent_trampoline()
408
409
410
411 func pthread_mutex_init(m *pthreadmutex, attr *pthreadmutexattr) int32 {
412 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_init_trampoline)), unsafe.Pointer(&m))
413 KeepAlive(m)
414 KeepAlive(attr)
415 return ret
416 }
417 func pthread_mutex_init_trampoline()
418
419
420
421 func pthread_mutex_lock(m *pthreadmutex) int32 {
422 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_lock_trampoline)), unsafe.Pointer(&m))
423 KeepAlive(m)
424 return ret
425 }
426 func pthread_mutex_lock_trampoline()
427
428
429
430 func pthread_mutex_unlock(m *pthreadmutex) int32 {
431 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_mutex_unlock_trampoline)), unsafe.Pointer(&m))
432 KeepAlive(m)
433 return ret
434 }
435 func pthread_mutex_unlock_trampoline()
436
437
438
439 func pthread_cond_init(c *pthreadcond, attr *pthreadcondattr) int32 {
440 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_init_trampoline)), unsafe.Pointer(&c))
441 KeepAlive(c)
442 KeepAlive(attr)
443 return ret
444 }
445 func pthread_cond_init_trampoline()
446
447
448
449 func pthread_cond_wait(c *pthreadcond, m *pthreadmutex) int32 {
450 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_wait_trampoline)), unsafe.Pointer(&c))
451 KeepAlive(c)
452 KeepAlive(m)
453 return ret
454 }
455 func pthread_cond_wait_trampoline()
456
457
458
459 func pthread_cond_timedwait_relative_np(c *pthreadcond, m *pthreadmutex, t *timespec) int32 {
460 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_timedwait_relative_np_trampoline)), unsafe.Pointer(&c))
461 KeepAlive(c)
462 KeepAlive(m)
463 KeepAlive(t)
464 return ret
465 }
466 func pthread_cond_timedwait_relative_np_trampoline()
467
468
469
470 func pthread_cond_signal(c *pthreadcond) int32 {
471 ret := libcCall(unsafe.Pointer(abi.FuncPCABI0(pthread_cond_signal_trampoline)), unsafe.Pointer(&c))
472 KeepAlive(c)
473 return ret
474 }
475 func pthread_cond_signal_trampoline()
476
477
478 func exitThread(wait *atomic.Uint32) {
479 }
480
481
482 func closeonexec(fd int32) {
483 fcntl(fd, _F_SETFD, _FD_CLOEXEC)
484 }
485
486
487 func setNonblock(fd int32) {
488 flags := fcntl(fd, _F_GETFL, 0)
489 fcntl(fd, _F_SETFL, flags|_O_NONBLOCK)
490 }
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
View as plain text