~vcs-imports/vendor/master

« back to all changes in this revision

Viewing changes to vendor/golang.org/x/sys/unix/zsyscall_darwin_amd64.go

  • Committer: Daniel Theophanes
  • Author(s): Clément Chigot
  • Date: 2019-04-30 20:27:03 UTC
  • Revision ID: git-v1:d0fd0db8a43d4b87c2ce416f60ae78407f3f3c62
Update vendor for AIX support (#428)

* vendor: update x/sys/unix

* vendor: update github.com/Bowery/prompt

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
// mksyscall.pl -tags darwin,amd64 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
 
1
// go run mksyscall.go -tags darwin,amd64,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
2
2
// Code generated by the command above; see README.md. DO NOT EDIT.
3
3
 
4
 
// +build darwin,amd64
 
4
// +build darwin,amd64,go1.12
5
5
 
6
6
package unix
7
7
 
15
15
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
16
16
 
17
17
func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
18
 
        r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 
18
        r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
19
19
        n = int(r0)
20
20
        if e1 != 0 {
21
21
                err = errnoErr(e1)
23
23
        return
24
24
}
25
25
 
 
26
func libc_getgroups_trampoline()
 
27
 
 
28
//go:linkname libc_getgroups libc_getgroups
 
29
//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
 
30
 
26
31
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
27
32
 
28
33
func setgroups(ngid int, gid *_Gid_t) (err error) {
29
 
        _, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
 
34
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
30
35
        if e1 != 0 {
31
36
                err = errnoErr(e1)
32
37
        }
33
38
        return
34
39
}
35
40
 
 
41
func libc_setgroups_trampoline()
 
42
 
 
43
//go:linkname libc_setgroups libc_setgroups
 
44
//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
 
45
 
36
46
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
37
47
 
38
48
func wait4(pid int, wstatus *_C_int, options int, rusage *Rusage) (wpid int, err error) {
39
 
        r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
 
49
        r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
40
50
        wpid = int(r0)
41
51
        if e1 != 0 {
42
52
                err = errnoErr(e1)
44
54
        return
45
55
}
46
56
 
 
57
func libc_wait4_trampoline()
 
58
 
 
59
//go:linkname libc_wait4 libc_wait4
 
60
//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
 
61
 
47
62
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
48
63
 
49
64
func accept(s int, rsa *RawSockaddrAny, addrlen *_Socklen) (fd int, err error) {
50
 
        r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
65
        r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
51
66
        fd = int(r0)
52
67
        if e1 != 0 {
53
68
                err = errnoErr(e1)
55
70
        return
56
71
}
57
72
 
 
73
func libc_accept_trampoline()
 
74
 
 
75
//go:linkname libc_accept libc_accept
 
76
//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
 
77
 
58
78
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
59
79
 
60
80
func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
61
 
        _, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
 
81
        _, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
62
82
        if e1 != 0 {
63
83
                err = errnoErr(e1)
64
84
        }
65
85
        return
66
86
}
67
87
 
 
88
func libc_bind_trampoline()
 
89
 
 
90
//go:linkname libc_bind libc_bind
 
91
//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
 
92
 
68
93
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
69
94
 
70
95
func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
71
 
        _, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
 
96
        _, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
72
97
        if e1 != 0 {
73
98
                err = errnoErr(e1)
74
99
        }
75
100
        return
76
101
}
77
102
 
 
103
func libc_connect_trampoline()
 
104
 
 
105
//go:linkname libc_connect libc_connect
 
106
//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
 
107
 
78
108
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
79
109
 
80
110
func socket(domain int, typ int, proto int) (fd int, err error) {
81
 
        r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
 
111
        r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
82
112
        fd = int(r0)
83
113
        if e1 != 0 {
84
114
                err = errnoErr(e1)
86
116
        return
87
117
}
88
118
 
 
119
func libc_socket_trampoline()
 
120
 
 
121
//go:linkname libc_socket libc_socket
 
122
//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
 
123
 
89
124
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
90
125
 
91
126
func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
92
 
        _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
 
127
        _, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
93
128
        if e1 != 0 {
94
129
                err = errnoErr(e1)
95
130
        }
96
131
        return
97
132
}
98
133
 
 
134
func libc_getsockopt_trampoline()
 
135
 
 
136
//go:linkname libc_getsockopt libc_getsockopt
 
137
//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
 
138
 
99
139
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
100
140
 
101
141
func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
102
 
        _, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
 
142
        _, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
103
143
        if e1 != 0 {
104
144
                err = errnoErr(e1)
105
145
        }
106
146
        return
107
147
}
108
148
 
 
149
func libc_setsockopt_trampoline()
 
150
 
 
151
//go:linkname libc_setsockopt libc_setsockopt
 
152
//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
 
153
 
109
154
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
110
155
 
111
156
func getpeername(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
112
 
        _, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
157
        _, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
113
158
        if e1 != 0 {
114
159
                err = errnoErr(e1)
115
160
        }
116
161
        return
117
162
}
118
163
 
 
164
func libc_getpeername_trampoline()
 
165
 
 
166
//go:linkname libc_getpeername libc_getpeername
 
167
//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
 
168
 
119
169
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
120
170
 
121
171
func getsockname(fd int, rsa *RawSockaddrAny, addrlen *_Socklen) (err error) {
122
 
        _, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
 
172
        _, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
123
173
        if e1 != 0 {
124
174
                err = errnoErr(e1)
125
175
        }
126
176
        return
127
177
}
128
178
 
 
179
func libc_getsockname_trampoline()
 
180
 
 
181
//go:linkname libc_getsockname libc_getsockname
 
182
//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
 
183
 
129
184
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
130
185
 
131
186
func Shutdown(s int, how int) (err error) {
132
 
        _, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
 
187
        _, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
133
188
        if e1 != 0 {
134
189
                err = errnoErr(e1)
135
190
        }
136
191
        return
137
192
}
138
193
 
 
194
func libc_shutdown_trampoline()
 
195
 
 
196
//go:linkname libc_shutdown libc_shutdown
 
197
//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
 
198
 
139
199
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
140
200
 
141
201
func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
142
 
        _, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
 
202
        _, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
143
203
        if e1 != 0 {
144
204
                err = errnoErr(e1)
145
205
        }
146
206
        return
147
207
}
148
208
 
 
209
func libc_socketpair_trampoline()
 
210
 
 
211
//go:linkname libc_socketpair libc_socketpair
 
212
//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
 
213
 
149
214
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
150
215
 
151
216
func recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) {
155
220
        } else {
156
221
                _p0 = unsafe.Pointer(&_zero)
157
222
        }
158
 
        r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
 
223
        r0, _, e1 := syscall_syscall6(funcPC(libc_recvfrom_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
159
224
        n = int(r0)
160
225
        if e1 != 0 {
161
226
                err = errnoErr(e1)
163
228
        return
164
229
}
165
230
 
 
231
func libc_recvfrom_trampoline()
 
232
 
 
233
//go:linkname libc_recvfrom libc_recvfrom
 
234
//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
 
235
 
166
236
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
167
237
 
168
238
func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
172
242
        } else {
173
243
                _p0 = unsafe.Pointer(&_zero)
174
244
        }
175
 
        _, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
 
245
        _, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
176
246
        if e1 != 0 {
177
247
                err = errnoErr(e1)
178
248
        }
179
249
        return
180
250
}
181
251
 
 
252
func libc_sendto_trampoline()
 
253
 
 
254
//go:linkname libc_sendto libc_sendto
 
255
//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
 
256
 
182
257
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
183
258
 
184
259
func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
185
 
        r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 
260
        r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
186
261
        n = int(r0)
187
262
        if e1 != 0 {
188
263
                err = errnoErr(e1)
190
265
        return
191
266
}
192
267
 
 
268
func libc_recvmsg_trampoline()
 
269
 
 
270
//go:linkname libc_recvmsg libc_recvmsg
 
271
//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
 
272
 
193
273
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
194
274
 
195
275
func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
196
 
        r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
 
276
        r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
197
277
        n = int(r0)
198
278
        if e1 != 0 {
199
279
                err = errnoErr(e1)
201
281
        return
202
282
}
203
283
 
 
284
func libc_sendmsg_trampoline()
 
285
 
 
286
//go:linkname libc_sendmsg libc_sendmsg
 
287
//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
 
288
 
204
289
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
205
290
 
206
291
func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
207
 
        r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
 
292
        r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
208
293
        n = int(r0)
209
294
        if e1 != 0 {
210
295
                err = errnoErr(e1)
212
297
        return
213
298
}
214
299
 
 
300
func libc_kevent_trampoline()
 
301
 
 
302
//go:linkname libc_kevent libc_kevent
 
303
//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
 
304
 
215
305
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
216
306
 
217
307
func sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
221
311
        } else {
222
312
                _p0 = unsafe.Pointer(&_zero)
223
313
        }
224
 
        _, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
 
314
        _, _, e1 := syscall_syscall6(funcPC(libc___sysctl_trampoline), uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
225
315
        if e1 != 0 {
226
316
                err = errnoErr(e1)
227
317
        }
228
318
        return
229
319
}
230
320
 
 
321
func libc___sysctl_trampoline()
 
322
 
 
323
//go:linkname libc___sysctl libc___sysctl
 
324
//go:cgo_import_dynamic libc___sysctl __sysctl "/usr/lib/libSystem.B.dylib"
 
325
 
231
326
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
232
327
 
233
328
func utimes(path string, timeval *[2]Timeval) (err error) {
236
331
        if err != nil {
237
332
                return
238
333
        }
239
 
        _, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
 
334
        _, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
240
335
        if e1 != 0 {
241
336
                err = errnoErr(e1)
242
337
        }
243
338
        return
244
339
}
245
340
 
 
341
func libc_utimes_trampoline()
 
342
 
 
343
//go:linkname libc_utimes libc_utimes
 
344
//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
 
345
 
246
346
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
247
347
 
248
348
func futimes(fd int, timeval *[2]Timeval) (err error) {
249
 
        _, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
 
349
        _, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
250
350
        if e1 != 0 {
251
351
                err = errnoErr(e1)
252
352
        }
253
353
        return
254
354
}
255
355
 
 
356
func libc_futimes_trampoline()
 
357
 
 
358
//go:linkname libc_futimes libc_futimes
 
359
//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
 
360
 
256
361
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
257
362
 
258
363
func fcntl(fd int, cmd int, arg int) (val int, err error) {
259
 
        r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
 
364
        r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
260
365
        val = int(r0)
261
366
        if e1 != 0 {
262
367
                err = errnoErr(e1)
264
369
        return
265
370
}
266
371
 
 
372
func libc_fcntl_trampoline()
 
373
 
 
374
//go:linkname libc_fcntl libc_fcntl
 
375
//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
 
376
 
267
377
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
268
378
 
269
379
func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
270
 
        r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
 
380
        r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
271
381
        n = int(r0)
272
382
        if e1 != 0 {
273
383
                err = errnoErr(e1)
275
385
        return
276
386
}
277
387
 
 
388
func libc_poll_trampoline()
 
389
 
 
390
//go:linkname libc_poll libc_poll
 
391
//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
 
392
 
278
393
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
279
394
 
280
395
func Madvise(b []byte, behav int) (err error) {
284
399
        } else {
285
400
                _p0 = unsafe.Pointer(&_zero)
286
401
        }
287
 
        _, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
 
402
        _, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
288
403
        if e1 != 0 {
289
404
                err = errnoErr(e1)
290
405
        }
291
406
        return
292
407
}
293
408
 
 
409
func libc_madvise_trampoline()
 
410
 
 
411
//go:linkname libc_madvise libc_madvise
 
412
//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
 
413
 
294
414
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
295
415
 
296
416
func Mlock(b []byte) (err error) {
300
420
        } else {
301
421
                _p0 = unsafe.Pointer(&_zero)
302
422
        }
303
 
        _, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
 
423
        _, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
304
424
        if e1 != 0 {
305
425
                err = errnoErr(e1)
306
426
        }
307
427
        return
308
428
}
309
429
 
 
430
func libc_mlock_trampoline()
 
431
 
 
432
//go:linkname libc_mlock libc_mlock
 
433
//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
 
434
 
310
435
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
311
436
 
312
437
func Mlockall(flags int) (err error) {
313
 
        _, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
 
438
        _, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
314
439
        if e1 != 0 {
315
440
                err = errnoErr(e1)
316
441
        }
317
442
        return
318
443
}
319
444
 
 
445
func libc_mlockall_trampoline()
 
446
 
 
447
//go:linkname libc_mlockall libc_mlockall
 
448
//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
 
449
 
320
450
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
321
451
 
322
452
func Mprotect(b []byte, prot int) (err error) {
326
456
        } else {
327
457
                _p0 = unsafe.Pointer(&_zero)
328
458
        }
329
 
        _, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
 
459
        _, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
330
460
        if e1 != 0 {
331
461
                err = errnoErr(e1)
332
462
        }
333
463
        return
334
464
}
335
465
 
 
466
func libc_mprotect_trampoline()
 
467
 
 
468
//go:linkname libc_mprotect libc_mprotect
 
469
//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
 
470
 
336
471
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
337
472
 
338
473
func Msync(b []byte, flags int) (err error) {
342
477
        } else {
343
478
                _p0 = unsafe.Pointer(&_zero)
344
479
        }
345
 
        _, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
 
480
        _, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
346
481
        if e1 != 0 {
347
482
                err = errnoErr(e1)
348
483
        }
349
484
        return
350
485
}
351
486
 
 
487
func libc_msync_trampoline()
 
488
 
 
489
//go:linkname libc_msync libc_msync
 
490
//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
 
491
 
352
492
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
353
493
 
354
494
func Munlock(b []byte) (err error) {
358
498
        } else {
359
499
                _p0 = unsafe.Pointer(&_zero)
360
500
        }
361
 
        _, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
 
501
        _, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
362
502
        if e1 != 0 {
363
503
                err = errnoErr(e1)
364
504
        }
365
505
        return
366
506
}
367
507
 
 
508
func libc_munlock_trampoline()
 
509
 
 
510
//go:linkname libc_munlock libc_munlock
 
511
//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
 
512
 
368
513
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
369
514
 
370
515
func Munlockall() (err error) {
371
 
        _, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
 
516
        _, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
372
517
        if e1 != 0 {
373
518
                err = errnoErr(e1)
374
519
        }
375
520
        return
376
521
}
377
522
 
 
523
func libc_munlockall_trampoline()
 
524
 
 
525
//go:linkname libc_munlockall libc_munlockall
 
526
//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
 
527
 
378
528
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
379
529
 
380
530
func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
381
 
        _, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
382
 
        if e1 != 0 {
383
 
                err = errnoErr(e1)
384
 
        }
385
 
        return
386
 
}
 
531
        _, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
 
532
        if e1 != 0 {
 
533
                err = errnoErr(e1)
 
534
        }
 
535
        return
 
536
}
 
537
 
 
538
func libc_ptrace_trampoline()
 
539
 
 
540
//go:linkname libc_ptrace libc_ptrace
 
541
//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
 
542
 
 
543
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
544
 
 
545
func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
 
546
        _, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
 
547
        if e1 != 0 {
 
548
                err = errnoErr(e1)
 
549
        }
 
550
        return
 
551
}
 
552
 
 
553
func libc_getattrlist_trampoline()
 
554
 
 
555
//go:linkname libc_getattrlist libc_getattrlist
 
556
//go:cgo_import_dynamic libc_getattrlist getattrlist "/usr/lib/libSystem.B.dylib"
387
557
 
388
558
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
389
559
 
390
560
func pipe() (r int, w int, err error) {
391
 
        r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
 
561
        r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
392
562
        r = int(r0)
393
563
        w = int(r1)
394
564
        if e1 != 0 {
397
567
        return
398
568
}
399
569
 
 
570
func libc_pipe_trampoline()
 
571
 
 
572
//go:linkname libc_pipe libc_pipe
 
573
//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
 
574
 
 
575
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
576
 
 
577
func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
 
578
        var _p0 *byte
 
579
        _p0, err = BytePtrFromString(path)
 
580
        if err != nil {
 
581
                return
 
582
        }
 
583
        var _p1 *byte
 
584
        _p1, err = BytePtrFromString(attr)
 
585
        if err != nil {
 
586
                return
 
587
        }
 
588
        r0, _, e1 := syscall_syscall6(funcPC(libc_getxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 
589
        sz = int(r0)
 
590
        if e1 != 0 {
 
591
                err = errnoErr(e1)
 
592
        }
 
593
        return
 
594
}
 
595
 
 
596
func libc_getxattr_trampoline()
 
597
 
 
598
//go:linkname libc_getxattr libc_getxattr
 
599
//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
 
600
 
 
601
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
602
 
 
603
func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
 
604
        var _p0 *byte
 
605
        _p0, err = BytePtrFromString(attr)
 
606
        if err != nil {
 
607
                return
 
608
        }
 
609
        r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
 
610
        sz = int(r0)
 
611
        if e1 != 0 {
 
612
                err = errnoErr(e1)
 
613
        }
 
614
        return
 
615
}
 
616
 
 
617
func libc_fgetxattr_trampoline()
 
618
 
 
619
//go:linkname libc_fgetxattr libc_fgetxattr
 
620
//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
 
621
 
 
622
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
623
 
 
624
func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
 
625
        var _p0 *byte
 
626
        _p0, err = BytePtrFromString(path)
 
627
        if err != nil {
 
628
                return
 
629
        }
 
630
        var _p1 *byte
 
631
        _p1, err = BytePtrFromString(attr)
 
632
        if err != nil {
 
633
                return
 
634
        }
 
635
        _, _, e1 := syscall_syscall6(funcPC(libc_setxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 
636
        if e1 != 0 {
 
637
                err = errnoErr(e1)
 
638
        }
 
639
        return
 
640
}
 
641
 
 
642
func libc_setxattr_trampoline()
 
643
 
 
644
//go:linkname libc_setxattr libc_setxattr
 
645
//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
 
646
 
 
647
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
648
 
 
649
func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
 
650
        var _p0 *byte
 
651
        _p0, err = BytePtrFromString(attr)
 
652
        if err != nil {
 
653
                return
 
654
        }
 
655
        _, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
 
656
        if e1 != 0 {
 
657
                err = errnoErr(e1)
 
658
        }
 
659
        return
 
660
}
 
661
 
 
662
func libc_fsetxattr_trampoline()
 
663
 
 
664
//go:linkname libc_fsetxattr libc_fsetxattr
 
665
//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
 
666
 
 
667
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
668
 
 
669
func removexattr(path string, attr string, options int) (err error) {
 
670
        var _p0 *byte
 
671
        _p0, err = BytePtrFromString(path)
 
672
        if err != nil {
 
673
                return
 
674
        }
 
675
        var _p1 *byte
 
676
        _p1, err = BytePtrFromString(attr)
 
677
        if err != nil {
 
678
                return
 
679
        }
 
680
        _, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 
681
        if e1 != 0 {
 
682
                err = errnoErr(e1)
 
683
        }
 
684
        return
 
685
}
 
686
 
 
687
func libc_removexattr_trampoline()
 
688
 
 
689
//go:linkname libc_removexattr libc_removexattr
 
690
//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
 
691
 
 
692
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
693
 
 
694
func fremovexattr(fd int, attr string, options int) (err error) {
 
695
        var _p0 *byte
 
696
        _p0, err = BytePtrFromString(attr)
 
697
        if err != nil {
 
698
                return
 
699
        }
 
700
        _, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
 
701
        if e1 != 0 {
 
702
                err = errnoErr(e1)
 
703
        }
 
704
        return
 
705
}
 
706
 
 
707
func libc_fremovexattr_trampoline()
 
708
 
 
709
//go:linkname libc_fremovexattr libc_fremovexattr
 
710
//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
 
711
 
 
712
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
713
 
 
714
func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
 
715
        var _p0 *byte
 
716
        _p0, err = BytePtrFromString(path)
 
717
        if err != nil {
 
718
                return
 
719
        }
 
720
        r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 
721
        sz = int(r0)
 
722
        if e1 != 0 {
 
723
                err = errnoErr(e1)
 
724
        }
 
725
        return
 
726
}
 
727
 
 
728
func libc_listxattr_trampoline()
 
729
 
 
730
//go:linkname libc_listxattr libc_listxattr
 
731
//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
 
732
 
 
733
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
734
 
 
735
func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
 
736
        r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
 
737
        sz = int(r0)
 
738
        if e1 != 0 {
 
739
                err = errnoErr(e1)
 
740
        }
 
741
        return
 
742
}
 
743
 
 
744
func libc_flistxattr_trampoline()
 
745
 
 
746
//go:linkname libc_flistxattr libc_flistxattr
 
747
//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
 
748
 
 
749
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
750
 
 
751
func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
 
752
        _, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
 
753
        if e1 != 0 {
 
754
                err = errnoErr(e1)
 
755
        }
 
756
        return
 
757
}
 
758
 
 
759
func libc_setattrlist_trampoline()
 
760
 
 
761
//go:linkname libc_setattrlist libc_setattrlist
 
762
//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
 
763
 
400
764
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
401
765
 
402
766
func kill(pid int, signum int, posix int) (err error) {
403
 
        _, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
 
767
        _, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
404
768
        if e1 != 0 {
405
769
                err = errnoErr(e1)
406
770
        }
407
771
        return
408
772
}
409
773
 
 
774
func libc_kill_trampoline()
 
775
 
 
776
//go:linkname libc_kill libc_kill
 
777
//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
 
778
 
410
779
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
411
780
 
412
781
func ioctl(fd int, req uint, arg uintptr) (err error) {
413
 
        _, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
414
 
        if e1 != 0 {
415
 
                err = errnoErr(e1)
416
 
        }
417
 
        return
418
 
}
 
782
        _, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
 
783
        if e1 != 0 {
 
784
                err = errnoErr(e1)
 
785
        }
 
786
        return
 
787
}
 
788
 
 
789
func libc_ioctl_trampoline()
 
790
 
 
791
//go:linkname libc_ioctl libc_ioctl
 
792
//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
 
793
 
 
794
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
795
 
 
796
func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
 
797
        _, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
 
798
        if e1 != 0 {
 
799
                err = errnoErr(e1)
 
800
        }
 
801
        return
 
802
}
 
803
 
 
804
func libc_sendfile_trampoline()
 
805
 
 
806
//go:linkname libc_sendfile libc_sendfile
 
807
//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
419
808
 
420
809
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
421
810
 
425
814
        if err != nil {
426
815
                return
427
816
        }
428
 
        _, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
817
        _, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
429
818
        if e1 != 0 {
430
819
                err = errnoErr(e1)
431
820
        }
432
821
        return
433
822
}
434
823
 
 
824
func libc_access_trampoline()
 
825
 
 
826
//go:linkname libc_access libc_access
 
827
//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
 
828
 
435
829
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
436
830
 
437
831
func Adjtime(delta *Timeval, olddelta *Timeval) (err error) {
438
 
        _, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
 
832
        _, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
439
833
        if e1 != 0 {
440
834
                err = errnoErr(e1)
441
835
        }
442
836
        return
443
837
}
444
838
 
 
839
func libc_adjtime_trampoline()
 
840
 
 
841
//go:linkname libc_adjtime libc_adjtime
 
842
//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
 
843
 
445
844
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
446
845
 
447
846
func Chdir(path string) (err error) {
450
849
        if err != nil {
451
850
                return
452
851
        }
453
 
        _, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
852
        _, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
454
853
        if e1 != 0 {
455
854
                err = errnoErr(e1)
456
855
        }
457
856
        return
458
857
}
459
858
 
 
859
func libc_chdir_trampoline()
 
860
 
 
861
//go:linkname libc_chdir libc_chdir
 
862
//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
 
863
 
460
864
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
461
865
 
462
866
func Chflags(path string, flags int) (err error) {
465
869
        if err != nil {
466
870
                return
467
871
        }
468
 
        _, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 
872
        _, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
469
873
        if e1 != 0 {
470
874
                err = errnoErr(e1)
471
875
        }
472
876
        return
473
877
}
474
878
 
 
879
func libc_chflags_trampoline()
 
880
 
 
881
//go:linkname libc_chflags libc_chflags
 
882
//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
 
883
 
475
884
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
476
885
 
477
886
func Chmod(path string, mode uint32) (err error) {
480
889
        if err != nil {
481
890
                return
482
891
        }
483
 
        _, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
892
        _, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
484
893
        if e1 != 0 {
485
894
                err = errnoErr(e1)
486
895
        }
487
896
        return
488
897
}
489
898
 
 
899
func libc_chmod_trampoline()
 
900
 
 
901
//go:linkname libc_chmod libc_chmod
 
902
//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
 
903
 
490
904
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
491
905
 
492
906
func Chown(path string, uid int, gid int) (err error) {
495
909
        if err != nil {
496
910
                return
497
911
        }
498
 
        _, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 
912
        _, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
499
913
        if e1 != 0 {
500
914
                err = errnoErr(e1)
501
915
        }
502
916
        return
503
917
}
504
918
 
 
919
func libc_chown_trampoline()
 
920
 
 
921
//go:linkname libc_chown libc_chown
 
922
//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
 
923
 
505
924
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
506
925
 
507
926
func Chroot(path string) (err error) {
510
929
        if err != nil {
511
930
                return
512
931
        }
513
 
        _, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
514
 
        if e1 != 0 {
515
 
                err = errnoErr(e1)
516
 
        }
517
 
        return
518
 
}
 
932
        _, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
 
933
        if e1 != 0 {
 
934
                err = errnoErr(e1)
 
935
        }
 
936
        return
 
937
}
 
938
 
 
939
func libc_chroot_trampoline()
 
940
 
 
941
//go:linkname libc_chroot libc_chroot
 
942
//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
 
943
 
 
944
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
945
 
 
946
func ClockGettime(clockid int32, time *Timespec) (err error) {
 
947
        _, _, e1 := syscall_syscall(funcPC(libc_clock_gettime_trampoline), uintptr(clockid), uintptr(unsafe.Pointer(time)), 0)
 
948
        if e1 != 0 {
 
949
                err = errnoErr(e1)
 
950
        }
 
951
        return
 
952
}
 
953
 
 
954
func libc_clock_gettime_trampoline()
 
955
 
 
956
//go:linkname libc_clock_gettime libc_clock_gettime
 
957
//go:cgo_import_dynamic libc_clock_gettime clock_gettime "/usr/lib/libSystem.B.dylib"
519
958
 
520
959
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
521
960
 
522
961
func Close(fd int) (err error) {
523
 
        _, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
 
962
        _, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
524
963
        if e1 != 0 {
525
964
                err = errnoErr(e1)
526
965
        }
527
966
        return
528
967
}
529
968
 
 
969
func libc_close_trampoline()
 
970
 
 
971
//go:linkname libc_close libc_close
 
972
//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
 
973
 
530
974
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
531
975
 
532
976
func Dup(fd int) (nfd int, err error) {
533
 
        r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
 
977
        r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
534
978
        nfd = int(r0)
535
979
        if e1 != 0 {
536
980
                err = errnoErr(e1)
538
982
        return
539
983
}
540
984
 
 
985
func libc_dup_trampoline()
 
986
 
 
987
//go:linkname libc_dup libc_dup
 
988
//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
 
989
 
541
990
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
542
991
 
543
992
func Dup2(from int, to int) (err error) {
544
 
        _, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
 
993
        _, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
545
994
        if e1 != 0 {
546
995
                err = errnoErr(e1)
547
996
        }
548
997
        return
549
998
}
550
999
 
 
1000
func libc_dup2_trampoline()
 
1001
 
 
1002
//go:linkname libc_dup2 libc_dup2
 
1003
//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
 
1004
 
551
1005
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
552
1006
 
553
1007
func Exchangedata(path1 string, path2 string, options int) (err error) {
561
1015
        if err != nil {
562
1016
                return
563
1017
        }
564
 
        _, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
 
1018
        _, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
565
1019
        if e1 != 0 {
566
1020
                err = errnoErr(e1)
567
1021
        }
568
1022
        return
569
1023
}
570
1024
 
 
1025
func libc_exchangedata_trampoline()
 
1026
 
 
1027
//go:linkname libc_exchangedata libc_exchangedata
 
1028
//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
 
1029
 
571
1030
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
572
1031
 
573
1032
func Exit(code int) {
574
 
        Syscall(SYS_EXIT, uintptr(code), 0, 0)
 
1033
        syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
575
1034
        return
576
1035
}
577
1036
 
 
1037
func libc_exit_trampoline()
 
1038
 
 
1039
//go:linkname libc_exit libc_exit
 
1040
//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
 
1041
 
578
1042
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
579
1043
 
580
1044
func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
583
1047
        if err != nil {
584
1048
                return
585
1049
        }
586
 
        _, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 
1050
        _, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
587
1051
        if e1 != 0 {
588
1052
                err = errnoErr(e1)
589
1053
        }
590
1054
        return
591
1055
}
592
1056
 
 
1057
func libc_faccessat_trampoline()
 
1058
 
 
1059
//go:linkname libc_faccessat libc_faccessat
 
1060
//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
 
1061
 
593
1062
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
594
1063
 
595
1064
func Fchdir(fd int) (err error) {
596
 
        _, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
 
1065
        _, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
597
1066
        if e1 != 0 {
598
1067
                err = errnoErr(e1)
599
1068
        }
600
1069
        return
601
1070
}
602
1071
 
 
1072
func libc_fchdir_trampoline()
 
1073
 
 
1074
//go:linkname libc_fchdir libc_fchdir
 
1075
//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
 
1076
 
603
1077
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
604
1078
 
605
1079
func Fchflags(fd int, flags int) (err error) {
606
 
        _, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
 
1080
        _, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
607
1081
        if e1 != 0 {
608
1082
                err = errnoErr(e1)
609
1083
        }
610
1084
        return
611
1085
}
612
1086
 
 
1087
func libc_fchflags_trampoline()
 
1088
 
 
1089
//go:linkname libc_fchflags libc_fchflags
 
1090
//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
 
1091
 
613
1092
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
614
1093
 
615
1094
func Fchmod(fd int, mode uint32) (err error) {
616
 
        _, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
 
1095
        _, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
617
1096
        if e1 != 0 {
618
1097
                err = errnoErr(e1)
619
1098
        }
620
1099
        return
621
1100
}
622
1101
 
 
1102
func libc_fchmod_trampoline()
 
1103
 
 
1104
//go:linkname libc_fchmod libc_fchmod
 
1105
//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
 
1106
 
623
1107
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
624
1108
 
625
1109
func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
628
1112
        if err != nil {
629
1113
                return
630
1114
        }
631
 
        _, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
 
1115
        _, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
632
1116
        if e1 != 0 {
633
1117
                err = errnoErr(e1)
634
1118
        }
635
1119
        return
636
1120
}
637
1121
 
 
1122
func libc_fchmodat_trampoline()
 
1123
 
 
1124
//go:linkname libc_fchmodat libc_fchmodat
 
1125
//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
 
1126
 
638
1127
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
639
1128
 
640
1129
func Fchown(fd int, uid int, gid int) (err error) {
641
 
        _, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
 
1130
        _, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
642
1131
        if e1 != 0 {
643
1132
                err = errnoErr(e1)
644
1133
        }
645
1134
        return
646
1135
}
647
1136
 
 
1137
func libc_fchown_trampoline()
 
1138
 
 
1139
//go:linkname libc_fchown libc_fchown
 
1140
//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
 
1141
 
648
1142
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
649
1143
 
650
1144
func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
653
1147
        if err != nil {
654
1148
                return
655
1149
        }
656
 
        _, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
 
1150
        _, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
657
1151
        if e1 != 0 {
658
1152
                err = errnoErr(e1)
659
1153
        }
660
1154
        return
661
1155
}
662
1156
 
 
1157
func libc_fchownat_trampoline()
 
1158
 
 
1159
//go:linkname libc_fchownat libc_fchownat
 
1160
//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
 
1161
 
663
1162
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664
1163
 
665
1164
func Flock(fd int, how int) (err error) {
666
 
        _, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
 
1165
        _, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
667
1166
        if e1 != 0 {
668
1167
                err = errnoErr(e1)
669
1168
        }
670
1169
        return
671
1170
}
672
1171
 
 
1172
func libc_flock_trampoline()
 
1173
 
 
1174
//go:linkname libc_flock libc_flock
 
1175
//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
 
1176
 
673
1177
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
674
1178
 
675
1179
func Fpathconf(fd int, name int) (val int, err error) {
676
 
        r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
 
1180
        r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
677
1181
        val = int(r0)
678
1182
        if e1 != 0 {
679
1183
                err = errnoErr(e1)
681
1185
        return
682
1186
}
683
1187
 
684
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
685
 
 
686
 
func Fstat(fd int, stat *Stat_t) (err error) {
687
 
        _, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
688
 
        if e1 != 0 {
689
 
                err = errnoErr(e1)
690
 
        }
691
 
        return
692
 
}
693
 
 
694
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
695
 
 
696
 
func Fstatfs(fd int, stat *Statfs_t) (err error) {
697
 
        _, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
698
 
        if e1 != 0 {
699
 
                err = errnoErr(e1)
700
 
        }
701
 
        return
702
 
}
 
1188
func libc_fpathconf_trampoline()
 
1189
 
 
1190
//go:linkname libc_fpathconf libc_fpathconf
 
1191
//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
703
1192
 
704
1193
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
705
1194
 
706
1195
func Fsync(fd int) (err error) {
707
 
        _, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
 
1196
        _, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
708
1197
        if e1 != 0 {
709
1198
                err = errnoErr(e1)
710
1199
        }
711
1200
        return
712
1201
}
713
1202
 
 
1203
func libc_fsync_trampoline()
 
1204
 
 
1205
//go:linkname libc_fsync libc_fsync
 
1206
//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
 
1207
 
714
1208
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
715
1209
 
716
1210
func Ftruncate(fd int, length int64) (err error) {
717
 
        _, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
718
 
        if e1 != 0 {
719
 
                err = errnoErr(e1)
720
 
        }
721
 
        return
722
 
}
723
 
 
724
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
725
 
 
726
 
func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
727
 
        var _p0 unsafe.Pointer
728
 
        if len(buf) > 0 {
729
 
                _p0 = unsafe.Pointer(&buf[0])
730
 
        } else {
731
 
                _p0 = unsafe.Pointer(&_zero)
732
 
        }
733
 
        r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
734
 
        n = int(r0)
735
 
        if e1 != 0 {
736
 
                err = errnoErr(e1)
737
 
        }
738
 
        return
739
 
}
 
1211
        _, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
 
1212
        if e1 != 0 {
 
1213
                err = errnoErr(e1)
 
1214
        }
 
1215
        return
 
1216
}
 
1217
 
 
1218
func libc_ftruncate_trampoline()
 
1219
 
 
1220
//go:linkname libc_ftruncate libc_ftruncate
 
1221
//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
740
1222
 
741
1223
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
742
1224
 
743
1225
func Getdtablesize() (size int) {
744
 
        r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
 
1226
        r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
745
1227
        size = int(r0)
746
1228
        return
747
1229
}
748
1230
 
 
1231
func libc_getdtablesize_trampoline()
 
1232
 
 
1233
//go:linkname libc_getdtablesize libc_getdtablesize
 
1234
//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
 
1235
 
749
1236
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
750
1237
 
751
1238
func Getegid() (egid int) {
752
 
        r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
 
1239
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
753
1240
        egid = int(r0)
754
1241
        return
755
1242
}
756
1243
 
 
1244
func libc_getegid_trampoline()
 
1245
 
 
1246
//go:linkname libc_getegid libc_getegid
 
1247
//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
 
1248
 
757
1249
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
758
1250
 
759
1251
func Geteuid() (uid int) {
760
 
        r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
 
1252
        r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
761
1253
        uid = int(r0)
762
1254
        return
763
1255
}
764
1256
 
 
1257
func libc_geteuid_trampoline()
 
1258
 
 
1259
//go:linkname libc_geteuid libc_geteuid
 
1260
//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
 
1261
 
765
1262
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
766
1263
 
767
1264
func Getgid() (gid int) {
768
 
        r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
 
1265
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
769
1266
        gid = int(r0)
770
1267
        return
771
1268
}
772
1269
 
 
1270
func libc_getgid_trampoline()
 
1271
 
 
1272
//go:linkname libc_getgid libc_getgid
 
1273
//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
 
1274
 
773
1275
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
774
1276
 
775
1277
func Getpgid(pid int) (pgid int, err error) {
776
 
        r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
 
1278
        r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
777
1279
        pgid = int(r0)
778
1280
        if e1 != 0 {
779
1281
                err = errnoErr(e1)
781
1283
        return
782
1284
}
783
1285
 
 
1286
func libc_getpgid_trampoline()
 
1287
 
 
1288
//go:linkname libc_getpgid libc_getpgid
 
1289
//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
 
1290
 
784
1291
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
785
1292
 
786
1293
func Getpgrp() (pgrp int) {
787
 
        r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
 
1294
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
788
1295
        pgrp = int(r0)
789
1296
        return
790
1297
}
791
1298
 
 
1299
func libc_getpgrp_trampoline()
 
1300
 
 
1301
//go:linkname libc_getpgrp libc_getpgrp
 
1302
//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
 
1303
 
792
1304
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
793
1305
 
794
1306
func Getpid() (pid int) {
795
 
        r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
 
1307
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
796
1308
        pid = int(r0)
797
1309
        return
798
1310
}
799
1311
 
 
1312
func libc_getpid_trampoline()
 
1313
 
 
1314
//go:linkname libc_getpid libc_getpid
 
1315
//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
 
1316
 
800
1317
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
801
1318
 
802
1319
func Getppid() (ppid int) {
803
 
        r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
 
1320
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
804
1321
        ppid = int(r0)
805
1322
        return
806
1323
}
807
1324
 
 
1325
func libc_getppid_trampoline()
 
1326
 
 
1327
//go:linkname libc_getppid libc_getppid
 
1328
//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
 
1329
 
808
1330
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
809
1331
 
810
1332
func Getpriority(which int, who int) (prio int, err error) {
811
 
        r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
 
1333
        r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
812
1334
        prio = int(r0)
813
1335
        if e1 != 0 {
814
1336
                err = errnoErr(e1)
816
1338
        return
817
1339
}
818
1340
 
 
1341
func libc_getpriority_trampoline()
 
1342
 
 
1343
//go:linkname libc_getpriority libc_getpriority
 
1344
//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
 
1345
 
819
1346
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
820
1347
 
821
1348
func Getrlimit(which int, lim *Rlimit) (err error) {
822
 
        _, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 
1349
        _, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
823
1350
        if e1 != 0 {
824
1351
                err = errnoErr(e1)
825
1352
        }
826
1353
        return
827
1354
}
828
1355
 
 
1356
func libc_getrlimit_trampoline()
 
1357
 
 
1358
//go:linkname libc_getrlimit libc_getrlimit
 
1359
//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
 
1360
 
829
1361
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
830
1362
 
831
1363
func Getrusage(who int, rusage *Rusage) (err error) {
832
 
        _, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
 
1364
        _, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
833
1365
        if e1 != 0 {
834
1366
                err = errnoErr(e1)
835
1367
        }
836
1368
        return
837
1369
}
838
1370
 
 
1371
func libc_getrusage_trampoline()
 
1372
 
 
1373
//go:linkname libc_getrusage libc_getrusage
 
1374
//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
 
1375
 
839
1376
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
840
1377
 
841
1378
func Getsid(pid int) (sid int, err error) {
842
 
        r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
 
1379
        r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
843
1380
        sid = int(r0)
844
1381
        if e1 != 0 {
845
1382
                err = errnoErr(e1)
847
1384
        return
848
1385
}
849
1386
 
 
1387
func libc_getsid_trampoline()
 
1388
 
 
1389
//go:linkname libc_getsid libc_getsid
 
1390
//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
 
1391
 
850
1392
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
851
1393
 
852
1394
func Getuid() (uid int) {
853
 
        r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
 
1395
        r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
854
1396
        uid = int(r0)
855
1397
        return
856
1398
}
857
1399
 
 
1400
func libc_getuid_trampoline()
 
1401
 
 
1402
//go:linkname libc_getuid libc_getuid
 
1403
//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
 
1404
 
858
1405
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
859
1406
 
860
1407
func Issetugid() (tainted bool) {
861
 
        r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
 
1408
        r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
862
1409
        tainted = bool(r0 != 0)
863
1410
        return
864
1411
}
865
1412
 
 
1413
func libc_issetugid_trampoline()
 
1414
 
 
1415
//go:linkname libc_issetugid libc_issetugid
 
1416
//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
 
1417
 
866
1418
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
867
1419
 
868
1420
func Kqueue() (fd int, err error) {
869
 
        r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
 
1421
        r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
870
1422
        fd = int(r0)
871
1423
        if e1 != 0 {
872
1424
                err = errnoErr(e1)
874
1426
        return
875
1427
}
876
1428
 
 
1429
func libc_kqueue_trampoline()
 
1430
 
 
1431
//go:linkname libc_kqueue libc_kqueue
 
1432
//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
 
1433
 
877
1434
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
878
1435
 
879
1436
func Lchown(path string, uid int, gid int) (err error) {
882
1439
        if err != nil {
883
1440
                return
884
1441
        }
885
 
        _, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
 
1442
        _, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
886
1443
        if e1 != 0 {
887
1444
                err = errnoErr(e1)
888
1445
        }
889
1446
        return
890
1447
}
891
1448
 
 
1449
func libc_lchown_trampoline()
 
1450
 
 
1451
//go:linkname libc_lchown libc_lchown
 
1452
//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
 
1453
 
892
1454
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
893
1455
 
894
1456
func Link(path string, link string) (err error) {
902
1464
        if err != nil {
903
1465
                return
904
1466
        }
905
 
        _, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
1467
        _, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
906
1468
        if e1 != 0 {
907
1469
                err = errnoErr(e1)
908
1470
        }
909
1471
        return
910
1472
}
911
1473
 
 
1474
func libc_link_trampoline()
 
1475
 
 
1476
//go:linkname libc_link libc_link
 
1477
//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
 
1478
 
912
1479
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
913
1480
 
914
1481
func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
922
1489
        if err != nil {
923
1490
                return
924
1491
        }
925
 
        _, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
 
1492
        _, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
926
1493
        if e1 != 0 {
927
1494
                err = errnoErr(e1)
928
1495
        }
929
1496
        return
930
1497
}
931
1498
 
 
1499
func libc_linkat_trampoline()
 
1500
 
 
1501
//go:linkname libc_linkat libc_linkat
 
1502
//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
 
1503
 
932
1504
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
933
1505
 
934
1506
func Listen(s int, backlog int) (err error) {
935
 
        _, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
936
 
        if e1 != 0 {
937
 
                err = errnoErr(e1)
938
 
        }
939
 
        return
940
 
}
941
 
 
942
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
943
 
 
944
 
func Lstat(path string, stat *Stat_t) (err error) {
945
 
        var _p0 *byte
946
 
        _p0, err = BytePtrFromString(path)
947
 
        if err != nil {
948
 
                return
949
 
        }
950
 
        _, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
951
 
        if e1 != 0 {
952
 
                err = errnoErr(e1)
953
 
        }
954
 
        return
955
 
}
 
1507
        _, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
 
1508
        if e1 != 0 {
 
1509
                err = errnoErr(e1)
 
1510
        }
 
1511
        return
 
1512
}
 
1513
 
 
1514
func libc_listen_trampoline()
 
1515
 
 
1516
//go:linkname libc_listen libc_listen
 
1517
//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
956
1518
 
957
1519
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
958
1520
 
962
1524
        if err != nil {
963
1525
                return
964
1526
        }
965
 
        _, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
1527
        _, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
966
1528
        if e1 != 0 {
967
1529
                err = errnoErr(e1)
968
1530
        }
969
1531
        return
970
1532
}
971
1533
 
 
1534
func libc_mkdir_trampoline()
 
1535
 
 
1536
//go:linkname libc_mkdir libc_mkdir
 
1537
//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
 
1538
 
972
1539
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
973
1540
 
974
1541
func Mkdirat(dirfd int, path string, mode uint32) (err error) {
977
1544
        if err != nil {
978
1545
                return
979
1546
        }
980
 
        _, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
 
1547
        _, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
981
1548
        if e1 != 0 {
982
1549
                err = errnoErr(e1)
983
1550
        }
984
1551
        return
985
1552
}
986
1553
 
 
1554
func libc_mkdirat_trampoline()
 
1555
 
 
1556
//go:linkname libc_mkdirat libc_mkdirat
 
1557
//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
 
1558
 
987
1559
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
988
1560
 
989
1561
func Mkfifo(path string, mode uint32) (err error) {
992
1564
        if err != nil {
993
1565
                return
994
1566
        }
995
 
        _, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
 
1567
        _, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
996
1568
        if e1 != 0 {
997
1569
                err = errnoErr(e1)
998
1570
        }
999
1571
        return
1000
1572
}
1001
1573
 
 
1574
func libc_mkfifo_trampoline()
 
1575
 
 
1576
//go:linkname libc_mkfifo libc_mkfifo
 
1577
//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
 
1578
 
1002
1579
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1003
1580
 
1004
1581
func Mknod(path string, mode uint32, dev int) (err error) {
1007
1584
        if err != nil {
1008
1585
                return
1009
1586
        }
1010
 
        _, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
 
1587
        _, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1011
1588
        if e1 != 0 {
1012
1589
                err = errnoErr(e1)
1013
1590
        }
1014
1591
        return
1015
1592
}
1016
1593
 
 
1594
func libc_mknod_trampoline()
 
1595
 
 
1596
//go:linkname libc_mknod libc_mknod
 
1597
//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
 
1598
 
1017
1599
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1018
1600
 
1019
1601
func Open(path string, mode int, perm uint32) (fd int, err error) {
1022
1604
        if err != nil {
1023
1605
                return
1024
1606
        }
1025
 
        r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
 
1607
        r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1026
1608
        fd = int(r0)
1027
1609
        if e1 != 0 {
1028
1610
                err = errnoErr(e1)
1030
1612
        return
1031
1613
}
1032
1614
 
 
1615
func libc_open_trampoline()
 
1616
 
 
1617
//go:linkname libc_open libc_open
 
1618
//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
 
1619
 
1033
1620
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1034
1621
 
1035
1622
func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
1038
1625
        if err != nil {
1039
1626
                return
1040
1627
        }
1041
 
        r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
 
1628
        r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1042
1629
        fd = int(r0)
1043
1630
        if e1 != 0 {
1044
1631
                err = errnoErr(e1)
1046
1633
        return
1047
1634
}
1048
1635
 
 
1636
func libc_openat_trampoline()
 
1637
 
 
1638
//go:linkname libc_openat libc_openat
 
1639
//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
 
1640
 
1049
1641
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1050
1642
 
1051
1643
func Pathconf(path string, name int) (val int, err error) {
1054
1646
        if err != nil {
1055
1647
                return
1056
1648
        }
1057
 
        r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
 
1649
        r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1058
1650
        val = int(r0)
1059
1651
        if e1 != 0 {
1060
1652
                err = errnoErr(e1)
1062
1654
        return
1063
1655
}
1064
1656
 
 
1657
func libc_pathconf_trampoline()
 
1658
 
 
1659
//go:linkname libc_pathconf libc_pathconf
 
1660
//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
 
1661
 
1065
1662
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1066
1663
 
1067
1664
func Pread(fd int, p []byte, offset int64) (n int, err error) {
1071
1668
        } else {
1072
1669
                _p0 = unsafe.Pointer(&_zero)
1073
1670
        }
1074
 
        r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 
1671
        r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1075
1672
        n = int(r0)
1076
1673
        if e1 != 0 {
1077
1674
                err = errnoErr(e1)
1079
1676
        return
1080
1677
}
1081
1678
 
 
1679
func libc_pread_trampoline()
 
1680
 
 
1681
//go:linkname libc_pread libc_pread
 
1682
//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
 
1683
 
1082
1684
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1083
1685
 
1084
1686
func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
1088
1690
        } else {
1089
1691
                _p0 = unsafe.Pointer(&_zero)
1090
1692
        }
1091
 
        r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
 
1693
        r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1092
1694
        n = int(r0)
1093
1695
        if e1 != 0 {
1094
1696
                err = errnoErr(e1)
1096
1698
        return
1097
1699
}
1098
1700
 
 
1701
func libc_pwrite_trampoline()
 
1702
 
 
1703
//go:linkname libc_pwrite libc_pwrite
 
1704
//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
 
1705
 
1099
1706
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1100
1707
 
1101
1708
func read(fd int, p []byte) (n int, err error) {
1105
1712
        } else {
1106
1713
                _p0 = unsafe.Pointer(&_zero)
1107
1714
        }
1108
 
        r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 
1715
        r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1109
1716
        n = int(r0)
1110
1717
        if e1 != 0 {
1111
1718
                err = errnoErr(e1)
1113
1720
        return
1114
1721
}
1115
1722
 
 
1723
func libc_read_trampoline()
 
1724
 
 
1725
//go:linkname libc_read libc_read
 
1726
//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
 
1727
 
1116
1728
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1117
1729
 
1118
1730
func Readlink(path string, buf []byte) (n int, err error) {
1127
1739
        } else {
1128
1740
                _p1 = unsafe.Pointer(&_zero)
1129
1741
        }
1130
 
        r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
 
1742
        r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1131
1743
        n = int(r0)
1132
1744
        if e1 != 0 {
1133
1745
                err = errnoErr(e1)
1135
1747
        return
1136
1748
}
1137
1749
 
 
1750
func libc_readlink_trampoline()
 
1751
 
 
1752
//go:linkname libc_readlink libc_readlink
 
1753
//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
 
1754
 
1138
1755
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1139
1756
 
1140
1757
func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
1149
1766
        } else {
1150
1767
                _p1 = unsafe.Pointer(&_zero)
1151
1768
        }
1152
 
        r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
 
1769
        r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1153
1770
        n = int(r0)
1154
1771
        if e1 != 0 {
1155
1772
                err = errnoErr(e1)
1157
1774
        return
1158
1775
}
1159
1776
 
 
1777
func libc_readlinkat_trampoline()
 
1778
 
 
1779
//go:linkname libc_readlinkat libc_readlinkat
 
1780
//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
 
1781
 
1160
1782
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1161
1783
 
1162
1784
func Rename(from string, to string) (err error) {
1170
1792
        if err != nil {
1171
1793
                return
1172
1794
        }
1173
 
        _, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
1795
        _, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1174
1796
        if e1 != 0 {
1175
1797
                err = errnoErr(e1)
1176
1798
        }
1177
1799
        return
1178
1800
}
1179
1801
 
 
1802
func libc_rename_trampoline()
 
1803
 
 
1804
//go:linkname libc_rename libc_rename
 
1805
//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
 
1806
 
1180
1807
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1181
1808
 
1182
1809
func Renameat(fromfd int, from string, tofd int, to string) (err error) {
1190
1817
        if err != nil {
1191
1818
                return
1192
1819
        }
1193
 
        _, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
 
1820
        _, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1194
1821
        if e1 != 0 {
1195
1822
                err = errnoErr(e1)
1196
1823
        }
1197
1824
        return
1198
1825
}
1199
1826
 
 
1827
func libc_renameat_trampoline()
 
1828
 
 
1829
//go:linkname libc_renameat libc_renameat
 
1830
//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
 
1831
 
1200
1832
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1201
1833
 
1202
1834
func Revoke(path string) (err error) {
1205
1837
        if err != nil {
1206
1838
                return
1207
1839
        }
1208
 
        _, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1840
        _, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1209
1841
        if e1 != 0 {
1210
1842
                err = errnoErr(e1)
1211
1843
        }
1212
1844
        return
1213
1845
}
1214
1846
 
 
1847
func libc_revoke_trampoline()
 
1848
 
 
1849
//go:linkname libc_revoke libc_revoke
 
1850
//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
 
1851
 
1215
1852
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1216
1853
 
1217
1854
func Rmdir(path string) (err error) {
1220
1857
        if err != nil {
1221
1858
                return
1222
1859
        }
1223
 
        _, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1860
        _, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1224
1861
        if e1 != 0 {
1225
1862
                err = errnoErr(e1)
1226
1863
        }
1227
1864
        return
1228
1865
}
1229
1866
 
 
1867
func libc_rmdir_trampoline()
 
1868
 
 
1869
//go:linkname libc_rmdir libc_rmdir
 
1870
//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
 
1871
 
1230
1872
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1231
1873
 
1232
1874
func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1233
 
        r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
 
1875
        r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
1234
1876
        newoffset = int64(r0)
1235
1877
        if e1 != 0 {
1236
1878
                err = errnoErr(e1)
1238
1880
        return
1239
1881
}
1240
1882
 
 
1883
func libc_lseek_trampoline()
 
1884
 
 
1885
//go:linkname libc_lseek libc_lseek
 
1886
//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
 
1887
 
1241
1888
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1242
1889
 
1243
1890
func Select(n int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (err error) {
1244
 
        _, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
 
1891
        _, _, e1 := syscall_syscall6(funcPC(libc_select_trampoline), uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1245
1892
        if e1 != 0 {
1246
1893
                err = errnoErr(e1)
1247
1894
        }
1248
1895
        return
1249
1896
}
1250
1897
 
 
1898
func libc_select_trampoline()
 
1899
 
 
1900
//go:linkname libc_select libc_select
 
1901
//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
 
1902
 
1251
1903
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1252
1904
 
1253
1905
func Setegid(egid int) (err error) {
1254
 
        _, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
 
1906
        _, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
1255
1907
        if e1 != 0 {
1256
1908
                err = errnoErr(e1)
1257
1909
        }
1258
1910
        return
1259
1911
}
1260
1912
 
 
1913
func libc_setegid_trampoline()
 
1914
 
 
1915
//go:linkname libc_setegid libc_setegid
 
1916
//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
 
1917
 
1261
1918
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1262
1919
 
1263
1920
func Seteuid(euid int) (err error) {
1264
 
        _, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
 
1921
        _, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
1265
1922
        if e1 != 0 {
1266
1923
                err = errnoErr(e1)
1267
1924
        }
1268
1925
        return
1269
1926
}
1270
1927
 
 
1928
func libc_seteuid_trampoline()
 
1929
 
 
1930
//go:linkname libc_seteuid libc_seteuid
 
1931
//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
 
1932
 
1271
1933
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1272
1934
 
1273
1935
func Setgid(gid int) (err error) {
1274
 
        _, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
 
1936
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
1275
1937
        if e1 != 0 {
1276
1938
                err = errnoErr(e1)
1277
1939
        }
1278
1940
        return
1279
1941
}
1280
1942
 
 
1943
func libc_setgid_trampoline()
 
1944
 
 
1945
//go:linkname libc_setgid libc_setgid
 
1946
//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
 
1947
 
1281
1948
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1282
1949
 
1283
1950
func Setlogin(name string) (err error) {
1286
1953
        if err != nil {
1287
1954
                return
1288
1955
        }
1289
 
        _, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
1956
        _, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1290
1957
        if e1 != 0 {
1291
1958
                err = errnoErr(e1)
1292
1959
        }
1293
1960
        return
1294
1961
}
1295
1962
 
 
1963
func libc_setlogin_trampoline()
 
1964
 
 
1965
//go:linkname libc_setlogin libc_setlogin
 
1966
//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
 
1967
 
1296
1968
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1297
1969
 
1298
1970
func Setpgid(pid int, pgid int) (err error) {
1299
 
        _, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
 
1971
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
1300
1972
        if e1 != 0 {
1301
1973
                err = errnoErr(e1)
1302
1974
        }
1303
1975
        return
1304
1976
}
1305
1977
 
 
1978
func libc_setpgid_trampoline()
 
1979
 
 
1980
//go:linkname libc_setpgid libc_setpgid
 
1981
//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
 
1982
 
1306
1983
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1307
1984
 
1308
1985
func Setpriority(which int, who int, prio int) (err error) {
1309
 
        _, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
 
1986
        _, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
1310
1987
        if e1 != 0 {
1311
1988
                err = errnoErr(e1)
1312
1989
        }
1313
1990
        return
1314
1991
}
1315
1992
 
 
1993
func libc_setpriority_trampoline()
 
1994
 
 
1995
//go:linkname libc_setpriority libc_setpriority
 
1996
//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
 
1997
 
1316
1998
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1317
1999
 
1318
2000
func Setprivexec(flag int) (err error) {
1319
 
        _, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
 
2001
        _, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
1320
2002
        if e1 != 0 {
1321
2003
                err = errnoErr(e1)
1322
2004
        }
1323
2005
        return
1324
2006
}
1325
2007
 
 
2008
func libc_setprivexec_trampoline()
 
2009
 
 
2010
//go:linkname libc_setprivexec libc_setprivexec
 
2011
//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
 
2012
 
1326
2013
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1327
2014
 
1328
2015
func Setregid(rgid int, egid int) (err error) {
1329
 
        _, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
 
2016
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
1330
2017
        if e1 != 0 {
1331
2018
                err = errnoErr(e1)
1332
2019
        }
1333
2020
        return
1334
2021
}
1335
2022
 
 
2023
func libc_setregid_trampoline()
 
2024
 
 
2025
//go:linkname libc_setregid libc_setregid
 
2026
//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
 
2027
 
1336
2028
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1337
2029
 
1338
2030
func Setreuid(ruid int, euid int) (err error) {
1339
 
        _, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
 
2031
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
1340
2032
        if e1 != 0 {
1341
2033
                err = errnoErr(e1)
1342
2034
        }
1343
2035
        return
1344
2036
}
1345
2037
 
 
2038
func libc_setreuid_trampoline()
 
2039
 
 
2040
//go:linkname libc_setreuid libc_setreuid
 
2041
//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
 
2042
 
1346
2043
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1347
2044
 
1348
2045
func Setrlimit(which int, lim *Rlimit) (err error) {
1349
 
        _, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
 
2046
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1350
2047
        if e1 != 0 {
1351
2048
                err = errnoErr(e1)
1352
2049
        }
1353
2050
        return
1354
2051
}
1355
2052
 
 
2053
func libc_setrlimit_trampoline()
 
2054
 
 
2055
//go:linkname libc_setrlimit libc_setrlimit
 
2056
//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
 
2057
 
1356
2058
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1357
2059
 
1358
2060
func Setsid() (pid int, err error) {
1359
 
        r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
 
2061
        r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
1360
2062
        pid = int(r0)
1361
2063
        if e1 != 0 {
1362
2064
                err = errnoErr(e1)
1364
2066
        return
1365
2067
}
1366
2068
 
 
2069
func libc_setsid_trampoline()
 
2070
 
 
2071
//go:linkname libc_setsid libc_setsid
 
2072
//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
 
2073
 
1367
2074
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1368
2075
 
1369
2076
func Settimeofday(tp *Timeval) (err error) {
1370
 
        _, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
 
2077
        _, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
1371
2078
        if e1 != 0 {
1372
2079
                err = errnoErr(e1)
1373
2080
        }
1374
2081
        return
1375
2082
}
1376
2083
 
 
2084
func libc_settimeofday_trampoline()
 
2085
 
 
2086
//go:linkname libc_settimeofday libc_settimeofday
 
2087
//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
 
2088
 
1377
2089
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1378
2090
 
1379
2091
func Setuid(uid int) (err error) {
1380
 
        _, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1381
 
        if e1 != 0 {
1382
 
                err = errnoErr(e1)
1383
 
        }
1384
 
        return
1385
 
}
1386
 
 
1387
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1388
 
 
1389
 
func Stat(path string, stat *Stat_t) (err error) {
1390
 
        var _p0 *byte
1391
 
        _p0, err = BytePtrFromString(path)
1392
 
        if err != nil {
1393
 
                return
1394
 
        }
1395
 
        _, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1396
 
        if e1 != 0 {
1397
 
                err = errnoErr(e1)
1398
 
        }
1399
 
        return
1400
 
}
1401
 
 
1402
 
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1403
 
 
1404
 
func Statfs(path string, stat *Statfs_t) (err error) {
1405
 
        var _p0 *byte
1406
 
        _p0, err = BytePtrFromString(path)
1407
 
        if err != nil {
1408
 
                return
1409
 
        }
1410
 
        _, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1411
 
        if e1 != 0 {
1412
 
                err = errnoErr(e1)
1413
 
        }
1414
 
        return
1415
 
}
 
2092
        _, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
 
2093
        if e1 != 0 {
 
2094
                err = errnoErr(e1)
 
2095
        }
 
2096
        return
 
2097
}
 
2098
 
 
2099
func libc_setuid_trampoline()
 
2100
 
 
2101
//go:linkname libc_setuid libc_setuid
 
2102
//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
1416
2103
 
1417
2104
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1418
2105
 
1427
2114
        if err != nil {
1428
2115
                return
1429
2116
        }
1430
 
        _, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
 
2117
        _, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1431
2118
        if e1 != 0 {
1432
2119
                err = errnoErr(e1)
1433
2120
        }
1434
2121
        return
1435
2122
}
1436
2123
 
 
2124
func libc_symlink_trampoline()
 
2125
 
 
2126
//go:linkname libc_symlink libc_symlink
 
2127
//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
 
2128
 
1437
2129
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1438
2130
 
1439
2131
func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
1447
2139
        if err != nil {
1448
2140
                return
1449
2141
        }
1450
 
        _, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
 
2142
        _, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
1451
2143
        if e1 != 0 {
1452
2144
                err = errnoErr(e1)
1453
2145
        }
1454
2146
        return
1455
2147
}
1456
2148
 
 
2149
func libc_symlinkat_trampoline()
 
2150
 
 
2151
//go:linkname libc_symlinkat libc_symlinkat
 
2152
//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
 
2153
 
1457
2154
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1458
2155
 
1459
2156
func Sync() (err error) {
1460
 
        _, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
 
2157
        _, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
1461
2158
        if e1 != 0 {
1462
2159
                err = errnoErr(e1)
1463
2160
        }
1464
2161
        return
1465
2162
}
1466
2163
 
 
2164
func libc_sync_trampoline()
 
2165
 
 
2166
//go:linkname libc_sync libc_sync
 
2167
//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
 
2168
 
1467
2169
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1468
2170
 
1469
2171
func Truncate(path string, length int64) (err error) {
1472
2174
        if err != nil {
1473
2175
                return
1474
2176
        }
1475
 
        _, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
 
2177
        _, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
1476
2178
        if e1 != 0 {
1477
2179
                err = errnoErr(e1)
1478
2180
        }
1479
2181
        return
1480
2182
}
1481
2183
 
 
2184
func libc_truncate_trampoline()
 
2185
 
 
2186
//go:linkname libc_truncate libc_truncate
 
2187
//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
 
2188
 
1482
2189
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1483
2190
 
1484
2191
func Umask(newmask int) (oldmask int) {
1485
 
        r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
 
2192
        r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
1486
2193
        oldmask = int(r0)
1487
2194
        return
1488
2195
}
1489
2196
 
 
2197
func libc_umask_trampoline()
 
2198
 
 
2199
//go:linkname libc_umask libc_umask
 
2200
//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
 
2201
 
1490
2202
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1491
2203
 
1492
2204
func Undelete(path string) (err error) {
1495
2207
        if err != nil {
1496
2208
                return
1497
2209
        }
1498
 
        _, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
2210
        _, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1499
2211
        if e1 != 0 {
1500
2212
                err = errnoErr(e1)
1501
2213
        }
1502
2214
        return
1503
2215
}
1504
2216
 
 
2217
func libc_undelete_trampoline()
 
2218
 
 
2219
//go:linkname libc_undelete libc_undelete
 
2220
//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
 
2221
 
1505
2222
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1506
2223
 
1507
2224
func Unlink(path string) (err error) {
1510
2227
        if err != nil {
1511
2228
                return
1512
2229
        }
1513
 
        _, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
 
2230
        _, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
1514
2231
        if e1 != 0 {
1515
2232
                err = errnoErr(e1)
1516
2233
        }
1517
2234
        return
1518
2235
}
1519
2236
 
 
2237
func libc_unlink_trampoline()
 
2238
 
 
2239
//go:linkname libc_unlink libc_unlink
 
2240
//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
 
2241
 
1520
2242
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1521
2243
 
1522
2244
func Unlinkat(dirfd int, path string, flags int) (err error) {
1525
2247
        if err != nil {
1526
2248
                return
1527
2249
        }
1528
 
        _, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
 
2250
        _, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
1529
2251
        if e1 != 0 {
1530
2252
                err = errnoErr(e1)
1531
2253
        }
1532
2254
        return
1533
2255
}
1534
2256
 
 
2257
func libc_unlinkat_trampoline()
 
2258
 
 
2259
//go:linkname libc_unlinkat libc_unlinkat
 
2260
//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
 
2261
 
1535
2262
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1536
2263
 
1537
2264
func Unmount(path string, flags int) (err error) {
1540
2267
        if err != nil {
1541
2268
                return
1542
2269
        }
1543
 
        _, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
 
2270
        _, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1544
2271
        if e1 != 0 {
1545
2272
                err = errnoErr(e1)
1546
2273
        }
1547
2274
        return
1548
2275
}
1549
2276
 
 
2277
func libc_unmount_trampoline()
 
2278
 
 
2279
//go:linkname libc_unmount libc_unmount
 
2280
//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
 
2281
 
1550
2282
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1551
2283
 
1552
2284
func write(fd int, p []byte) (n int, err error) {
1556
2288
        } else {
1557
2289
                _p0 = unsafe.Pointer(&_zero)
1558
2290
        }
1559
 
        r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
 
2291
        r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1560
2292
        n = int(r0)
1561
2293
        if e1 != 0 {
1562
2294
                err = errnoErr(e1)
1564
2296
        return
1565
2297
}
1566
2298
 
 
2299
func libc_write_trampoline()
 
2300
 
 
2301
//go:linkname libc_write libc_write
 
2302
//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
 
2303
 
1567
2304
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1568
2305
 
1569
2306
func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1570
 
        r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
 
2307
        r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
1571
2308
        ret = uintptr(r0)
1572
2309
        if e1 != 0 {
1573
2310
                err = errnoErr(e1)
1575
2312
        return
1576
2313
}
1577
2314
 
 
2315
func libc_mmap_trampoline()
 
2316
 
 
2317
//go:linkname libc_mmap libc_mmap
 
2318
//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
 
2319
 
1578
2320
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1579
2321
 
1580
2322
func munmap(addr uintptr, length uintptr) (err error) {
1581
 
        _, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
 
2323
        _, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
1582
2324
        if e1 != 0 {
1583
2325
                err = errnoErr(e1)
1584
2326
        }
1585
2327
        return
1586
2328
}
1587
2329
 
 
2330
func libc_munmap_trampoline()
 
2331
 
 
2332
//go:linkname libc_munmap libc_munmap
 
2333
//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
 
2334
 
1588
2335
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1589
2336
 
1590
2337
func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1591
 
        r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 
2338
        r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1592
2339
        n = int(r0)
1593
2340
        if e1 != 0 {
1594
2341
                err = errnoErr(e1)
1599
2346
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1600
2347
 
1601
2348
func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1602
 
        r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
 
2349
        r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1603
2350
        n = int(r0)
1604
2351
        if e1 != 0 {
1605
2352
                err = errnoErr(e1)
1610
2357
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1611
2358
 
1612
2359
func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
1613
 
        r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
 
2360
        r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
1614
2361
        sec = int64(r0)
1615
2362
        usec = int32(r1)
1616
2363
        if e1 != 0 {
1618
2365
        }
1619
2366
        return
1620
2367
}
 
2368
 
 
2369
func libc_gettimeofday_trampoline()
 
2370
 
 
2371
//go:linkname libc_gettimeofday libc_gettimeofday
 
2372
//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
 
2373
 
 
2374
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2375
 
 
2376
func Fstat(fd int, stat *Stat_t) (err error) {
 
2377
        _, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 
2378
        if e1 != 0 {
 
2379
                err = errnoErr(e1)
 
2380
        }
 
2381
        return
 
2382
}
 
2383
 
 
2384
func libc_fstat64_trampoline()
 
2385
 
 
2386
//go:linkname libc_fstat64 libc_fstat64
 
2387
//go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
 
2388
 
 
2389
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2390
 
 
2391
func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
 
2392
        var _p0 *byte
 
2393
        _p0, err = BytePtrFromString(path)
 
2394
        if err != nil {
 
2395
                return
 
2396
        }
 
2397
        _, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
 
2398
        if e1 != 0 {
 
2399
                err = errnoErr(e1)
 
2400
        }
 
2401
        return
 
2402
}
 
2403
 
 
2404
func libc_fstatat64_trampoline()
 
2405
 
 
2406
//go:linkname libc_fstatat64 libc_fstatat64
 
2407
//go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
 
2408
 
 
2409
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2410
 
 
2411
func Fstatfs(fd int, stat *Statfs_t) (err error) {
 
2412
        _, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
 
2413
        if e1 != 0 {
 
2414
                err = errnoErr(e1)
 
2415
        }
 
2416
        return
 
2417
}
 
2418
 
 
2419
func libc_fstatfs64_trampoline()
 
2420
 
 
2421
//go:linkname libc_fstatfs64 libc_fstatfs64
 
2422
//go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
 
2423
 
 
2424
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2425
 
 
2426
func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
 
2427
        var _p0 unsafe.Pointer
 
2428
        if len(buf) > 0 {
 
2429
                _p0 = unsafe.Pointer(&buf[0])
 
2430
        } else {
 
2431
                _p0 = unsafe.Pointer(&_zero)
 
2432
        }
 
2433
        r0, _, e1 := syscall_syscall6(funcPC(libc___getdirentries64_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
 
2434
        n = int(r0)
 
2435
        if e1 != 0 {
 
2436
                err = errnoErr(e1)
 
2437
        }
 
2438
        return
 
2439
}
 
2440
 
 
2441
func libc___getdirentries64_trampoline()
 
2442
 
 
2443
//go:linkname libc___getdirentries64 libc___getdirentries64
 
2444
//go:cgo_import_dynamic libc___getdirentries64 __getdirentries64 "/usr/lib/libSystem.B.dylib"
 
2445
 
 
2446
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2447
 
 
2448
func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
 
2449
        r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
 
2450
        n = int(r0)
 
2451
        if e1 != 0 {
 
2452
                err = errnoErr(e1)
 
2453
        }
 
2454
        return
 
2455
}
 
2456
 
 
2457
func libc_getfsstat64_trampoline()
 
2458
 
 
2459
//go:linkname libc_getfsstat64 libc_getfsstat64
 
2460
//go:cgo_import_dynamic libc_getfsstat64 getfsstat64 "/usr/lib/libSystem.B.dylib"
 
2461
 
 
2462
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2463
 
 
2464
func Lstat(path string, stat *Stat_t) (err error) {
 
2465
        var _p0 *byte
 
2466
        _p0, err = BytePtrFromString(path)
 
2467
        if err != nil {
 
2468
                return
 
2469
        }
 
2470
        _, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
2471
        if e1 != 0 {
 
2472
                err = errnoErr(e1)
 
2473
        }
 
2474
        return
 
2475
}
 
2476
 
 
2477
func libc_lstat64_trampoline()
 
2478
 
 
2479
//go:linkname libc_lstat64 libc_lstat64
 
2480
//go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
 
2481
 
 
2482
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2483
 
 
2484
func Stat(path string, stat *Stat_t) (err error) {
 
2485
        var _p0 *byte
 
2486
        _p0, err = BytePtrFromString(path)
 
2487
        if err != nil {
 
2488
                return
 
2489
        }
 
2490
        _, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
2491
        if e1 != 0 {
 
2492
                err = errnoErr(e1)
 
2493
        }
 
2494
        return
 
2495
}
 
2496
 
 
2497
func libc_stat64_trampoline()
 
2498
 
 
2499
//go:linkname libc_stat64 libc_stat64
 
2500
//go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
 
2501
 
 
2502
// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
 
2503
 
 
2504
func Statfs(path string, stat *Statfs_t) (err error) {
 
2505
        var _p0 *byte
 
2506
        _p0, err = BytePtrFromString(path)
 
2507
        if err != nil {
 
2508
                return
 
2509
        }
 
2510
        _, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
 
2511
        if e1 != 0 {
 
2512
                err = errnoErr(e1)
 
2513
        }
 
2514
        return
 
2515
}
 
2516
 
 
2517
func libc_statfs64_trampoline()
 
2518
 
 
2519
//go:linkname libc_statfs64 libc_statfs64
 
2520
//go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"