Commit upstream/0.0_git20181228.9a3f9b0 - golang-golang-x-sys

New upstream version 0.0~git20181228.9a3f9b0 Anthony Fok 5 years ago

64 changed file(s) with 20681 addition(s) and 7070 deletion(s). Raw diff Collapse all Expand all

-2

unix/README.md less more

13	13	This is being done on an OS-by-OS basis. Please update this documentation as
14	14	components of the build system change.
15	15
16		### Old Build System (currently for `GOOS != "Linux" \|\| GOARCH == "sparc64"`)
	16	### Old Build System (currently for `GOOS != "linux"`)
17	17
18	18	The old build system generates the Go files based on the C header files
19	19	present on your system. This means that files

33	33
34	34	Requirements: bash, perl, go
35	35
36		### New Build System (currently for `GOOS == "Linux" && GOARCH != "sparc64"`)
	36	### New Build System (currently for `GOOS == "linux"`)
37	37
38	38	The new build system uses a Docker container to generate the go files directly
39	39	from source checkouts of the kernel and various system libraries. This means

+210

-0

unix/darwin_test.go less more

	0	// Copyright 2018 The Go Authors. All rights reserved.
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// +build darwin,go1.12,amd64 darwin,go1.12,386
	5
	6	package unix
	7
	8	import (
	9	"os"
	10	"os/exec"
	11	"strings"
	12	"testing"
	13	)
	14
	15	type darwinTest struct {
	16	name string
	17	f func()
	18	}
	19
	20	// TODO(khr): decide whether to keep this test enabled permanently or
	21	// only temporarily.
	22	func TestDarwinLoader(t *testing.T) {
	23	// Make sure the Darwin dynamic loader can actually resolve
	24	// all the system calls into libSystem.dylib. Unfortunately
	25	// there is no easy way to test this at compile time. So we
	26	// implement a crazy hack here, calling into the syscall
	27	// function with all its arguments set to junk, and see what
	28	// error we get. We are happy with any error (or none) except
	29	// an error from the dynamic loader.
	30	//
	31	// We have to run each test in a separate subprocess for fault isolation.
	32	//
	33	// Hopefully the junk args won't accidentally ask the system to do "rm -fr /".
	34	//
	35	// In an ideal world each syscall would have its own test, so this test
	36	// would be unnecessary. Unfortunately, we do not live in that world.
	37	for _, test := range darwinTests {
	38	// Call the test binary recursively, giving it a magic argument
	39	// (see init below) and the name of the test to run.
	40	cmd := exec.Command(os.Args[0], "testDarwinLoader", test.name)
	41
	42	// Run subprocess, collect results. Note that we expect the subprocess
	43	// to fail somehow, so the error is irrelevant.
	44	out, _ := cmd.CombinedOutput()
	45
	46	if strings.Contains(string(out), "dyld: Symbol not found:") {
	47	t.Errorf("can't resolve %s in libSystem.dylib", test.name)
	48	}
	49	if !strings.Contains(string(out), "success") {
	50	// Not really an error. Might be a syscall that never returns,
	51	// like exit, or one that segfaults, like gettimeofday.
	52	t.Logf("test never finished: %s: %s", test.name, string(out))
	53	}
	54	}
	55	}
	56
	57	func init() {
	58	// The test binary execs itself with the "testDarwinLoader" argument.
	59	// Run the test specified by os.Args[2], then panic.
	60	if len(os.Args) >= 3 && os.Args[1] == "testDarwinLoader" {
	61	for _, test := range darwinTests {
	62	if test.name == os.Args[2] {
	63	test.f()
	64	}
	65	}
	66	// Panic with a "success" label, so the parent process can check it.
	67	panic("success")
	68	}
	69	}
	70
	71	// All the _trampoline functions in zsyscall_darwin_$ARCH.s
	72	var darwinTests = [...]darwinTest{
	73	{"getgroups", libc_getgroups_trampoline},
	74	{"setgroups", libc_setgroups_trampoline},
	75	{"wait4", libc_wait4_trampoline},
	76	{"accept", libc_accept_trampoline},
	77	{"bind", libc_bind_trampoline},
	78	{"connect", libc_connect_trampoline},
	79	{"socket", libc_socket_trampoline},
	80	{"getsockopt", libc_getsockopt_trampoline},
	81	{"setsockopt", libc_setsockopt_trampoline},
	82	{"getpeername", libc_getpeername_trampoline},
	83	{"getsockname", libc_getsockname_trampoline},
	84	{"shutdown", libc_shutdown_trampoline},
	85	{"socketpair", libc_socketpair_trampoline},
	86	{"recvfrom", libc_recvfrom_trampoline},
	87	{"sendto", libc_sendto_trampoline},
	88	{"recvmsg", libc_recvmsg_trampoline},
	89	{"sendmsg", libc_sendmsg_trampoline},
	90	{"kevent", libc_kevent_trampoline},
	91	{"__sysctl", libc___sysctl_trampoline},
	92	{"utimes", libc_utimes_trampoline},
	93	{"futimes", libc_futimes_trampoline},
	94	{"fcntl", libc_fcntl_trampoline},
	95	{"poll", libc_poll_trampoline},
	96	{"madvise", libc_madvise_trampoline},
	97	{"mlock", libc_mlock_trampoline},
	98	{"mlockall", libc_mlockall_trampoline},
	99	{"mprotect", libc_mprotect_trampoline},
	100	{"msync", libc_msync_trampoline},
	101	{"munlock", libc_munlock_trampoline},
	102	{"munlockall", libc_munlockall_trampoline},
	103	{"ptrace", libc_ptrace_trampoline},
	104	{"pipe", libc_pipe_trampoline},
	105	{"getxattr", libc_getxattr_trampoline},
	106	{"fgetxattr", libc_fgetxattr_trampoline},
	107	{"setxattr", libc_setxattr_trampoline},
	108	{"fsetxattr", libc_fsetxattr_trampoline},
	109	{"removexattr", libc_removexattr_trampoline},
	110	{"fremovexattr", libc_fremovexattr_trampoline},
	111	{"listxattr", libc_listxattr_trampoline},
	112	{"flistxattr", libc_flistxattr_trampoline},
	113	{"kill", libc_kill_trampoline},
	114	{"ioctl", libc_ioctl_trampoline},
	115	{"access", libc_access_trampoline},
	116	{"adjtime", libc_adjtime_trampoline},
	117	{"chdir", libc_chdir_trampoline},
	118	{"chflags", libc_chflags_trampoline},
	119	{"chmod", libc_chmod_trampoline},
	120	{"chown", libc_chown_trampoline},
	121	{"chroot", libc_chroot_trampoline},
	122	{"close", libc_close_trampoline},
	123	{"dup", libc_dup_trampoline},
	124	{"dup2", libc_dup2_trampoline},
	125	{"exchangedata", libc_exchangedata_trampoline},
	126	{"exit", libc_exit_trampoline},
	127	{"faccessat", libc_faccessat_trampoline},
	128	{"fchdir", libc_fchdir_trampoline},
	129	{"fchflags", libc_fchflags_trampoline},
	130	{"fchmod", libc_fchmod_trampoline},
	131	{"fchmodat", libc_fchmodat_trampoline},
	132	{"fchown", libc_fchown_trampoline},
	133	{"fchownat", libc_fchownat_trampoline},
	134	{"flock", libc_flock_trampoline},
	135	{"fpathconf", libc_fpathconf_trampoline},
	136	{"fstat64", libc_fstat64_trampoline},
	137	{"fstatat64", libc_fstatat64_trampoline},
	138	{"fstatfs64", libc_fstatfs64_trampoline},
	139	{"fsync", libc_fsync_trampoline},
	140	{"ftruncate", libc_ftruncate_trampoline},
	141	{"__getdirentries64", libc___getdirentries64_trampoline},
	142	{"getdtablesize", libc_getdtablesize_trampoline},
	143	{"getegid", libc_getegid_trampoline},
	144	{"geteuid", libc_geteuid_trampoline},
	145	{"getgid", libc_getgid_trampoline},
	146	{"getpgid", libc_getpgid_trampoline},
	147	{"getpgrp", libc_getpgrp_trampoline},
	148	{"getpid", libc_getpid_trampoline},
	149	{"getppid", libc_getppid_trampoline},
	150	{"getpriority", libc_getpriority_trampoline},
	151	{"getrlimit", libc_getrlimit_trampoline},
	152	{"getrusage", libc_getrusage_trampoline},
	153	{"getsid", libc_getsid_trampoline},
	154	{"getuid", libc_getuid_trampoline},
	155	{"issetugid", libc_issetugid_trampoline},
	156	{"kqueue", libc_kqueue_trampoline},
	157	{"lchown", libc_lchown_trampoline},
	158	{"link", libc_link_trampoline},
	159	{"linkat", libc_linkat_trampoline},
	160	{"listen", libc_listen_trampoline},
	161	{"lstat64", libc_lstat64_trampoline},
	162	{"mkdir", libc_mkdir_trampoline},
	163	{"mkdirat", libc_mkdirat_trampoline},
	164	{"mkfifo", libc_mkfifo_trampoline},
	165	{"mknod", libc_mknod_trampoline},
	166	{"open", libc_open_trampoline},
	167	{"openat", libc_openat_trampoline},
	168	{"pathconf", libc_pathconf_trampoline},
	169	{"pread", libc_pread_trampoline},
	170	{"pwrite", libc_pwrite_trampoline},
	171	{"read", libc_read_trampoline},
	172	{"readlink", libc_readlink_trampoline},
	173	{"readlinkat", libc_readlinkat_trampoline},
	174	{"rename", libc_rename_trampoline},
	175	{"renameat", libc_renameat_trampoline},
	176	{"revoke", libc_revoke_trampoline},
	177	{"rmdir", libc_rmdir_trampoline},
	178	{"lseek", libc_lseek_trampoline},
	179	{"select", libc_select_trampoline},
	180	{"setegid", libc_setegid_trampoline},
	181	{"seteuid", libc_seteuid_trampoline},
	182	{"setgid", libc_setgid_trampoline},
	183	{"setlogin", libc_setlogin_trampoline},
	184	{"setpgid", libc_setpgid_trampoline},
	185	{"setpriority", libc_setpriority_trampoline},
	186	{"setprivexec", libc_setprivexec_trampoline},
	187	{"setregid", libc_setregid_trampoline},
	188	{"setreuid", libc_setreuid_trampoline},
	189	{"setrlimit", libc_setrlimit_trampoline},
	190	{"setsid", libc_setsid_trampoline},
	191	{"settimeofday", libc_settimeofday_trampoline},
	192	{"setuid", libc_setuid_trampoline},
	193	{"stat64", libc_stat64_trampoline},
	194	{"statfs64", libc_statfs64_trampoline},
	195	{"symlink", libc_symlink_trampoline},
	196	{"symlinkat", libc_symlinkat_trampoline},
	197	{"sync", libc_sync_trampoline},
	198	{"truncate", libc_truncate_trampoline},
	199	{"umask", libc_umask_trampoline},
	200	{"undelete", libc_undelete_trampoline},
	201	{"unlink", libc_unlink_trampoline},
	202	{"unlinkat", libc_unlinkat_trampoline},
	203	{"unmount", libc_unmount_trampoline},
	204	{"write", libc_write_trampoline},
	205	{"mmap", libc_mmap_trampoline},
	206	{"munmap", libc_munmap_trampoline},
	207	{"gettimeofday", libc_gettimeofday_trampoline},
	208	{"getfsstat64", libc_getfsstat64_trampoline},
	209	}

+11

-10

unix/linux/mkall.go less more

51	51	Bits int
52	52	}
53	53
54		// List of all Linux targets supported by the go compiler. sparc64 is not
55		// currently supported, though a port is in progress.
	54	// List of all Linux targets supported by the go compiler. Currently, riscv64
	55	// and sparc64 are not fully supported, but there is enough support already to
	56	// generate Go type and error definitions.
56	57	var targets = []target{
57	58	{
58	59	GoArch: "386",

132	133	SignedChar: true,
133	134	Bits: 64,
134	135	},
135		// {
136		// GoArch: "sparc64",
137		// LinuxArch: "sparc",
138		// GNUArch: "sparc64-linux-gnu",
139		// BigEndian: true,
140		// Bits: 64,
141		// },
	136	{
	137	GoArch: "sparc64",
	138	LinuxArch: "sparc",
	139	GNUArch: "sparc64-linux-gnu",
	140	BigEndian: true,
	141	Bits: 64,
	142	},
142	143	}
143	144
144	145	// ptracePairs is a list of pairs of targets that can, in some cases,

531	532	}
532	533	}
533	534
534		// This flag menas a 64-bit value should use (even, odd)-pair.
	535	// This flag means a 64-bit value should use (even, odd)-pair.
535	536	if t.GoArch == "arm" \|\| (t.LinuxArch == "mips" && t.Bits == 32) {
536	537	flags = append(flags, "-arm")
537	538	}

-0

unix/linux/mksysnum.go less more

(No changes)

+21

-0

unix/linux/types.go less more

56	56	#include <linux/perf_event.h>
57	57	#include <linux/rtnetlink.h>
58	58	#include <linux/stat.h>
	59	#if defined(__sparc__)
	60	// On sparc{,64}, the kernel defines struct termios2 itself which clashes with the
	61	// definition in glibc. Duplicate the kernel version here.
	62	#if defined(__arch64__)
	63	typedef unsigned int tcflag_t;
	64	#else
	65	typedef unsigned long tcflag_t;
	66	#endif
	67
	68	struct termios2 {
	69	tcflag_t c_iflag;
	70	tcflag_t c_oflag;
	71	tcflag_t c_cflag;
	72	tcflag_t c_lflag;
	73	unsigned char c_line;
	74	unsigned char c_cc[19];
	75	unsigned int c_ispeed;
	76	unsigned int c_ospeed;
	77	};
	78	#else
59	79	#include <asm/termbits.h>
	80	#endif
60	81	#include <asm/ptrace.h>
61	82	#include <time.h>
62	83	#include <unistd.h>

+32

-27

unix/mkall.sh less more

16	16	zsysctl="zsysctl_$GOOSARCH.go"
17	17	mksysnum=
18	18	mktypes=
	19	mkasm=
19	20	run="sh"
20	21	cmd=""
21	22

44	45	exit 2
45	46	esac
46	47
47		if [[ "$GOOS" = "linux" ]] && [[ "$GOARCH" != "sparc64" ]]; then
48		# Use then new build system
	48	if [[ "$GOOS" = "linux" ]]; then
	49	# Use the Docker-based build system
49	50	# Files generated through docker (use $cmd so you can Ctl-C the build or run)
50	51	$cmd docker build --tag generate:$GOOS $GOOS
51	52	$cmd docker run --interactive --tty --volume $(dirname "$(readlink -f "$0")"):/build generate:$GOOS

71	72	darwin_386)
72	73	mkerrors="$mkerrors -m32"
73	74	mksyscall="go run mksyscall.go -l32"
74		mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
75		mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	75	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
	76	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	77	mkasm="go run mkasm_darwin.go"
76	78	;;
77	79	darwin_amd64)
78	80	mkerrors="$mkerrors -m64"
79		mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
80		mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	81	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk macosx)/usr/include/sys/syscall.h"
	82	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	83	mkasm="go run mkasm_darwin.go"
81	84	;;
82	85	darwin_arm)
83	86	mkerrors="$mkerrors"
84		mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
85		mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	87	mksyscall="go run mksyscall.go -l32"
	88	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
	89	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	90	mkasm="go run mkasm_darwin.go"
86	91	;;
87	92	darwin_arm64)
88	93	mkerrors="$mkerrors -m64"
89		mksysnum="./mksysnum_darwin.pl $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
90		mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	94	mksysnum="go run mksysnum.go $(xcrun --show-sdk-path --sdk iphoneos)/usr/include/sys/syscall.h"
	95	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
	96	mkasm="go run mkasm_darwin.go"
91	97	;;
92	98	dragonfly_amd64)
93	99	mkerrors="$mkerrors -m64"
94	100	mksyscall="go run mksyscall.go -dragonfly"
95		mksysnum="curl -s 'http://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master' \| ./mksysnum_dragonfly.pl"
	101	mksysnum="go run mksysnum.go 'http://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master'"
96	102	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
97	103	;;
98	104	freebsd_386)
99	105	mkerrors="$mkerrors -m32"
100	106	mksyscall="go run mksyscall.go -l32"
101		mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' \| ./mksysnum_freebsd.pl"
	107	mksysnum="go run mksysnum.go 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master'"
102	108	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
103	109	;;
104	110	freebsd_amd64)
105	111	mkerrors="$mkerrors -m64"
106		mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' \| ./mksysnum_freebsd.pl"
	112	mksysnum="go run mksysnum.go 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master'"
107	113	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
108	114	;;
109	115	freebsd_arm)
110	116	mkerrors="$mkerrors"
111	117	mksyscall="go run mksyscall.go -l32 -arm"
112		mksysnum="curl -s 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master' \| ./mksysnum_freebsd.pl"
	118	mksysnum="go run mksysnum.go 'http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master'"
113	119	# Let the type of C char be signed for making the bare syscall
114	120	# API consistent across platforms.
115	121	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"
116	122	;;
117		linux_sparc64)
118		GOOSARCH_in=syscall_linux_sparc64.go
119		unistd_h=/usr/include/sparc64-linux-gnu/asm/unistd.h
120		mkerrors="$mkerrors -m64"
121		mksysnum="./mksysnum_linux.pl $unistd_h"
122		mktypes="GOARCH=$GOARCH go tool cgo -godefs"
123		;;
124	123	netbsd_386)
125	124	mkerrors="$mkerrors -m32"
126	125	mksyscall="go run mksyscall.go -l32 -netbsd"
127		mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_netbsd.pl"
	126	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
128	127	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
129	128	;;
130	129	netbsd_amd64)
131	130	mkerrors="$mkerrors -m64"
132	131	mksyscall="go run mksyscall.go -netbsd"
133		mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_netbsd.pl"
	132	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
134	133	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
135	134	;;
136	135	netbsd_arm)
137	136	mkerrors="$mkerrors"
138	137	mksyscall="go run mksyscall.go -l32 -netbsd -arm"
139		mksysnum="curl -s 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_netbsd.pl"
	138	mksysnum="go run mksysnum.go 'http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master'"
140	139	# Let the type of C char be signed for making the bare syscall
141	140	# API consistent across platforms.
142	141	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"

145	144	mkerrors="$mkerrors -m32"
146	145	mksyscall="go run mksyscall.go -l32 -openbsd"
147	146	mksysctl="./mksysctl_openbsd.pl"
148		mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_openbsd.pl"
	147	mksysnum="go run mksysnum.go 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
149	148	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
150	149	;;
151	150	openbsd_amd64)
152	151	mkerrors="$mkerrors -m64"
153	152	mksyscall="go run mksyscall.go -openbsd"
154	153	mksysctl="./mksysctl_openbsd.pl"
155		mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_openbsd.pl"
	154	mksysnum="go run mksysnum.go 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
156	155	mktypes="GOARCH=$GOARCH go tool cgo -godefs"
157	156	;;
158	157	openbsd_arm)
159	158	mkerrors="$mkerrors"
160	159	mksyscall="go run mksyscall.go -l32 -openbsd -arm"
161	160	mksysctl="./mksysctl_openbsd.pl"
162		mksysnum="curl -s 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master' \| ./mksysnum_openbsd.pl"
	161	mksysnum="go run mksysnum.go 'http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master'"
163	162	# Let the type of C char be signed for making the bare syscall
164	163	# API consistent across platforms.
165	164	mktypes="GOARCH=$GOARCH go tool cgo -godefs -- -fsigned-char"

190	189	if [ "$GOOSARCH" == "aix_ppc64" ]; then
191	190	# aix/ppc64 script generates files instead of writing to stdin.
192	191	echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in && gofmt -w zsyscall_$GOOSARCH.go && gofmt -w zsyscall_"$GOOSARCH"_gccgo.go && gofmt -w zsyscall_"$GOOSARCH"_gc.go " ;
	192	elif [ "$GOOS" == "darwin" ]; then
	193	# pre-1.12, direct syscalls
	194	echo "$mksyscall -tags $GOOS,$GOARCH,!go1.12 $syscall_goos $GOOSARCH_in \|gofmt >zsyscall_$GOOSARCH.1_11.go";
	195	# 1.12 and later, syscalls via libSystem
	196	echo "$mksyscall -tags $GOOS,$GOARCH,go1.12 $syscall_goos $GOOSARCH_in \|gofmt >zsyscall_$GOOSARCH.go";
193	197	else
194	198	echo "$mksyscall -tags $GOOS,$GOARCH $syscall_goos $GOOSARCH_in \|gofmt >zsyscall_$GOOSARCH.go";
195	199	fi

199	203	if [ -n "$mksysnum" ]; then echo "$mksysnum \|gofmt >zsysnum_$GOOSARCH.go"; fi
200	204	if [ -n "$mktypes" ]; then
201	205	echo "$mktypes types_$GOOS.go \| go run mkpost.go > ztypes_$GOOSARCH.go";
	206	if [ -n "$mkasm" ]; then echo "$mkasm $GOARCH"; fi
202	207	fi
203	208	) \| $run

+61

-0

unix/mkasm_darwin.go less more

	0	// Copyright 2018 The Go Authors. All rights reserved.
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// +build ignore
	5
	6	// mkasm_darwin.go generates assembly trampolines to call libSystem routines from Go.
	7	//This program must be run after mksyscall.go.
	8	package main
	9
	10	import (
	11	"bytes"
	12	"fmt"
	13	"io/ioutil"
	14	"log"
	15	"os"
	16	"strings"
	17	)
	18
	19	func main() {
	20	in1, err := ioutil.ReadFile("syscall_darwin.go")
	21	if err != nil {
	22	log.Fatalf("can't open syscall_darwin.go: %s", err)
	23	}
	24	arch := os.Args[1]
	25	in2, err := ioutil.ReadFile(fmt.Sprintf("syscall_darwin_%s.go", arch))
	26	if err != nil {
	27	log.Fatalf("can't open syscall_darwin_%s.go: %s", arch, err)
	28	}
	29	in3, err := ioutil.ReadFile(fmt.Sprintf("zsyscall_darwin_%s.go", arch))
	30	if err != nil {
	31	log.Fatalf("can't open zsyscall_darwin_%s.go: %s", arch, err)
	32	}
	33	in := string(in1) + string(in2) + string(in3)
	34
	35	trampolines := map[string]bool{}
	36
	37	var out bytes.Buffer
	38
	39	fmt.Fprintf(&out, "// go run mkasm_darwin.go %s\n", strings.Join(os.Args[1:], " "))
	40	fmt.Fprintf(&out, "// Code generated by the command above; DO NOT EDIT.\n")
	41	fmt.Fprintf(&out, "\n")
	42	fmt.Fprintf(&out, "// +build go1.12\n")
	43	fmt.Fprintf(&out, "\n")
	44	fmt.Fprintf(&out, "#include \"textflag.h\"\n")
	45	for _, line := range strings.Split(in, "\n") {
	46	if !strings.HasPrefix(line, "func ") \|\| !strings.HasSuffix(line, "_trampoline()") {
	47	continue
	48	}
	49	fn := line[5 : len(line)-13]
	50	if !trampolines[fn] {
	51	trampolines[fn] = true
	52	fmt.Fprintf(&out, "TEXT ·%s_trampoline(SB),NOSPLIT,$0-0\n", fn)
	53	fmt.Fprintf(&out, "\tJMP\t%s(SB)\n", fn)
	54	}
	55	}
	56	err = ioutil.WriteFile(fmt.Sprintf("zsyscall_darwin_%s.s", arch), out.Bytes(), 0644)
	57	if err != nil {
	58	log.Fatalf("can't write zsyscall_darwin_%s.s: %s", arch, err)
	59	}
	60	}

+12

-6

unix/mkerrors.sh less more

16	16	fi
17	17
18	18	# Check that we are using the new build system if we should
19		if [[ "$GOOS" = "linux" ]] && [[ "$GOARCH" != "sparc64" ]]; then
20		if [[ "$GOLANG_SYS_BUILD" != "docker" ]]; then
21		echo 1>&2 "In the new build system, mkerrors should not be called directly."
22		echo 1>&2 "See README.md"
23		exit 1
24		fi
	19	if [[ "$GOOS" = "linux" ]] && [[ "$GOLANG_SYS_BUILD" != "docker" ]]; then
	20	echo 1>&2 "In the Docker based build system, mkerrors should not be called directly."
	21	echo 1>&2 "See README.md"
	22	exit 1
25	23	fi
26	24
27	25	if [[ "$GOOS" = "aix" ]]; then

222	220	#include <linux/if_xdp.h>
223	221	#include <mtd/ubi-user.h>
224	222	#include <net/route.h>
	223
	224	#if defined(__sparc__)
	225	// On sparc{,64}, the kernel defines struct termios2 itself which clashes with the
	226	// definition in glibc. As only the error constants are needed here, include the
	227	// generic termibits.h (which is included by termbits.h on sparc).
	228	#include <asm-generic/termbits.h>
	229	#else
225	230	#include <asm/termbits.h>
	231	#endif
226	232
227	233	#ifndef MSG_FASTOPEN
228	234	#define MSG_FASTOPEN 0x20000000

-3

unix/mkpost.go less more

27	27	if goarch == "" {
28	28	goarch = os.Getenv("GOARCH")
29	29	}
30		// Check that we are using the new build system if we should be.
31		if goos == "linux" && goarch != "sparc64" {
	30	// Check that we are using the Docker-based build system if we should be.
	31	if goos == "linux" {
32	32	if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
33		os.Stderr.WriteString("In the new build system, mkpost should not be called directly.\n")
	33	os.Stderr.WriteString("In the Docker-based build system, mkpost should not be called directly.\n")
34	34	os.Stderr.WriteString("See README.md\n")
35	35	os.Exit(1)
36	36	}

+34

-3

unix/mksyscall.go less more

92	92	goarch = os.Getenv("GOARCH")
93	93	}
94	94
95		// Check that we are using the new build system if we should
96		if goos == "linux" && goarch != "sparc64" {
	95	// Check that we are using the Docker-based build system if we should
	96	if goos == "linux" {
97	97	if os.Getenv("GOLANG_SYS_BUILD") != "docker" {
98		fmt.Fprintf(os.Stderr, "In the new build system, mksyscall should not be called directly.\n")
	98	fmt.Fprintf(os.Stderr, "In the Docker-based build system, mksyscall should not be called directly.\n")
99	99	fmt.Fprintf(os.Stderr, "See README.md\n")
100	100	os.Exit(1)
101	101	}

114	114	} else if *l32 {
115	115	endianness = "little-endian"
116	116	}
	117
	118	libc := false
	119	if goos == "darwin" && strings.Contains(buildTags(), ",go1.12") {
	120	libc = true
	121	}
	122	trampolines := map[string]bool{}
117	123
118	124	text := ""
119	125	for _, path := range flag.Args() {

271	277	sysname = strings.ToUpper(sysname)
272	278	}
273	279
	280	var libcFn string
	281	if libc {
	282	asm = "syscall_" + strings.ToLower(asm[:1]) + asm[1:] // internal syscall call
	283	sysname = strings.TrimPrefix(sysname, "SYS_") // remove SYS_
	284	sysname = strings.ToLower(sysname) // lowercase
	285	if sysname == "getdirentries64" {
	286	// Special case - libSystem name and
	287	// raw syscall name don't match.
	288	sysname = "__getdirentries64"
	289	}
	290	libcFn = sysname
	291	sysname = "funcPC(libc_" + sysname + "_trampoline)"
	292	}
	293
274	294	// Actual call.
275	295	arglist := strings.Join(args, ", ")
276	296	call := fmt.Sprintf("%s(%s, %s)", asm, sysname, arglist)

338	358	text += "\treturn\n"
339	359	text += "}\n\n"
340	360
	361	if libc && !trampolines[libcFn] {
	362	// some system calls share a trampoline, like read and readlen.
	363	trampolines[libcFn] = true
	364	// Declare assembly trampoline.
	365	text += fmt.Sprintf("func libc_%s_trampoline()\n", libcFn)
	366	// Assembly trampoline calls the libc_* function, which this magic
	367	// redirects to use the function from libSystem.
	368	text += fmt.Sprintf("//go:linkname libc_%s libc_%s\n", libcFn, libcFn)
	369	text += fmt.Sprintf("//go:cgo_import_dynamic libc_%s %s \"/usr/lib/libSystem.B.dylib\"\n", libcFn, libcFn)
	370	text += "\n"
	371	}
341	372	}
342	373	if err := s.Err(); err != nil {
343	374	fmt.Fprintf(os.Stderr, err.Error())

+190

-0

unix/mksysnum.go less more

	0	// Copyright 2018 The Go Authors. All rights reserved.
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// +build ignore
	5
	6	// Generate system call table for DragonFly, NetBSD,
	7	// FreeBSD, OpenBSD or Darwin from master list
	8	// (for example, /usr/src/sys/kern/syscalls.master or
	9	// sys/syscall.h).
	10	package main
	11
	12	import (
	13	"bufio"
	14	"fmt"
	15	"io"
	16	"io/ioutil"
	17	"net/http"
	18	"os"
	19	"regexp"
	20	"strings"
	21	)
	22
	23	var (
	24	goos, goarch string
	25	)
	26
	27	// cmdLine returns this programs's commandline arguments
	28	func cmdLine() string {
	29	return "go run mksysnum.go " + strings.Join(os.Args[1:], " ")
	30	}
	31
	32	// buildTags returns build tags
	33	func buildTags() string {
	34	return fmt.Sprintf("%s,%s", goarch, goos)
	35	}
	36
	37	func checkErr(err error) {
	38	if err != nil {
	39	fmt.Fprintf(os.Stderr, "%v\n", err)
	40	os.Exit(1)
	41	}
	42	}
	43
	44	// source string and substring slice for regexp
	45	type re struct {
	46	str string // source string
	47	sub []string // matched sub-string
	48	}
	49
	50	// Match performs regular expression match
	51	func (r *re) Match(exp string) bool {
	52	r.sub = regexp.MustCompile(exp).FindStringSubmatch(r.str)
	53	if r.sub != nil {
	54	return true
	55	}
	56	return false
	57	}
	58
	59	// fetchFile fetches a text file from URL
	60	func fetchFile(URL string) io.Reader {
	61	resp, err := http.Get(URL)
	62	checkErr(err)
	63	defer resp.Body.Close()
	64	body, err := ioutil.ReadAll(resp.Body)
	65	checkErr(err)
	66	return strings.NewReader(string(body))
	67	}
	68
	69	// readFile reads a text file from path
	70	func readFile(path string) io.Reader {
	71	file, err := os.Open(os.Args[1])
	72	checkErr(err)
	73	return file
	74	}
	75
	76	func format(name, num, proto string) string {
	77	name = strings.ToUpper(name)
	78	// There are multiple entries for enosys and nosys, so comment them out.
	79	nm := re{str: name}
	80	if nm.Match(`^SYS_E?NOSYS$`) {
	81	name = fmt.Sprintf("// %s", name)
	82	}
	83	if name == `SYS_SYS_EXIT` {
	84	name = `SYS_EXIT`
	85	}
	86	return fmt.Sprintf(" %s = %s; // %s\n", name, num, proto)
	87	}
	88
	89	func main() {
	90	// Get the OS (using GOOS_TARGET if it exist)
	91	goos = os.Getenv("GOOS_TARGET")
	92	if goos == "" {
	93	goos = os.Getenv("GOOS")
	94	}
	95	// Get the architecture (using GOARCH_TARGET if it exists)
	96	goarch = os.Getenv("GOARCH_TARGET")
	97	if goarch == "" {
	98	goarch = os.Getenv("GOARCH")
	99	}
	100	// Check if GOOS and GOARCH environment variables are defined
	101	if goarch == "" \|\| goos == "" {
	102	fmt.Fprintf(os.Stderr, "GOARCH or GOOS not defined in environment\n")
	103	os.Exit(1)
	104	}
	105
	106	file := strings.TrimSpace(os.Args[1])
	107	var syscalls io.Reader
	108	if strings.HasPrefix(file, "http://") {
	109	// Download syscalls.master file
	110	syscalls = fetchFile(file)
	111	} else {
	112	syscalls = readFile(file)
	113	}
	114
	115	var text, line string
	116	s := bufio.NewScanner(syscalls)
	117	for s.Scan() {
	118	t := re{str: line}
	119	if t.Match(`^(.*)\\$`) {
	120	// Handle continuation
	121	line = t.sub[1]
	122	line += strings.TrimLeft(s.Text(), " \t")
	123	} else {
	124	// New line
	125	line = s.Text()
	126	}
	127	t = re{str: line}
	128	if t.Match(`\\$`) {
	129	continue
	130	}
	131	t = re{str: line}
	132
	133	switch goos {
	134	case "dragonfly":
	135	if t.Match(`^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$`) {
	136	num, proto := t.sub[1], t.sub[2]
	137	name := fmt.Sprintf("SYS_%s", t.sub[3])
	138	text += format(name, num, proto)
	139	}
	140	case "freebsd":
	141	if t.Match(`^([0-9]+)\s+\S+\s+(?:NO)?STD\s+({ \S+\s+(\w+).*)$`) {
	142	num, proto := t.sub[1], t.sub[2]
	143	name := fmt.Sprintf("SYS_%s", t.sub[3])
	144	text += format(name, num, proto)
	145	}
	146	case "openbsd":
	147	if t.Match(`^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\?(\w+).)$`) {
	148	num, proto, name := t.sub[1], t.sub[3], t.sub[4]
	149	text += format(name, num, proto)
	150	}
	151	case "netbsd":
	152	if t.Match(`^([0-9]+)\s+((STD)\|(NOERR))\s+(RUMP\s+)?({\s+\S+\s\?\s\\|(\S+)\\|(\S)\\|(\w+).*\s+})(\s+(\S+))?$`) {
	153	num, proto, compat := t.sub[1], t.sub[6], t.sub[8]
	154	name := t.sub[7] + "_" + t.sub[9]
	155	if t.sub[11] != "" {
	156	name = t.sub[7] + "_" + t.sub[11]
	157	}
	158	name = strings.ToUpper(name)
	159	if compat == "" \|\| compat == "13" \|\| compat == "30" \|\| compat == "50" {
	160	text += fmt.Sprintf(" %s = %s; // %s\n", name, num, proto)
	161	}
	162	}
	163	case "darwin":
	164	if t.Match(`^#define\s+SYS_(\w+)\s+([0-9]+)`) {
	165	name, num := t.sub[1], t.sub[2]
	166	name = strings.ToUpper(name)
	167	text += fmt.Sprintf(" SYS_%s = %s;\n", name, num)
	168	}
	169	default:
	170	fmt.Fprintf(os.Stderr, "unrecognized GOOS=%s\n", goos)
	171	os.Exit(1)
	172
	173	}
	174	}
	175	err := s.Err()
	176	checkErr(err)
	177
	178	fmt.Printf(template, cmdLine(), buildTags(), text)
	179	}
	180
	181	const template = `// %s
	182	// Code generated by the command above; see README.md. DO NOT EDIT.
	183
	184	// +build %s
	185
	186	package unix
	187
	188	const(
	189	%s)`

-39

~~unix/mksysnum_darwin.pl~~ less more

0		#!/usr/bin/env perl
1		# Copyright 2009 The Go Authors. All rights reserved.
2		# Use of this source code is governed by a BSD-style
3		# license that can be found in the LICENSE file.
4		#
5		# Generate system call table for Darwin from sys/syscall.h
6
7		use strict;
8
9		if($ENV{'GOARCH'} eq "" \|\| $ENV{'GOOS'} eq "") {
10		print STDERR "GOARCH or GOOS not defined in environment\n";
11		exit 1;
12		}
13
14		my $command = "mksysnum_darwin.pl " . join(' ', @ARGV);
15
16		print <<EOF;
17		// $command
18		// Code generated by the command above; see README.md. DO NOT EDIT.
19
20		// +build $ENV{'GOARCH'},$ENV{'GOOS'}
21
22		package unix
23
24		const (
25		EOF
26
27		while(<>){
28		if(/^#define\s+SYS_(\w+)\s+([0-9]+)/){
29		my $name = $1;
30		my $num = $2;
31		$name =~ y/a-z/A-Z/;
32		print " SYS_$name = $num;"
33		}
34		}
35
36		print <<EOF;
37		)
38		EOF

-50

~~unix/mksysnum_dragonfly.pl~~ less more

0		#!/usr/bin/env perl
1		# Copyright 2009 The Go Authors. All rights reserved.
2		# Use of this source code is governed by a BSD-style
3		# license that can be found in the LICENSE file.
4		#
5		# Generate system call table for DragonFly from master list
6		# (for example, /usr/src/sys/kern/syscalls.master).
7
8		use strict;
9
10		if($ENV{'GOARCH'} eq "" \|\| $ENV{'GOOS'} eq "") {
11		print STDERR "GOARCH or GOOS not defined in environment\n";
12		exit 1;
13		}
14
15		my $command = "mksysnum_dragonfly.pl " . join(' ', @ARGV);
16
17		print <<EOF;
18		// $command
19		// Code generated by the command above; see README.md. DO NOT EDIT.
20
21		// +build $ENV{'GOARCH'},$ENV{'GOOS'}
22
23		package unix
24
25		const (
26		EOF
27
28		while(<>){
29		if(/^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$/){
30		my $num = $1;
31		my $proto = $2;
32		my $name = "SYS_$3";
33		$name =~ y/a-z/A-Z/;
34
35		# There are multiple entries for enosys and nosys, so comment them out.
36		if($name =~ /^SYS_E?NOSYS$/){
37		$name = "// $name";
38		}
39		if($name eq 'SYS_SYS_EXIT'){
40		$name = 'SYS_EXIT';
41		}
42
43		print " $name = $num; // $proto\n";
44		}
45		}
46
47		print <<EOF;
48		)
49		EOF

-50

~~unix/mksysnum_freebsd.pl~~ less more

0		#!/usr/bin/env perl
1		# Copyright 2009 The Go Authors. All rights reserved.
2		# Use of this source code is governed by a BSD-style
3		# license that can be found in the LICENSE file.
4		#
5		# Generate system call table for FreeBSD from master list
6		# (for example, /usr/src/sys/kern/syscalls.master).
7
8		use strict;
9
10		if($ENV{'GOARCH'} eq "" \|\| $ENV{'GOOS'} eq "") {
11		print STDERR "GOARCH or GOOS not defined in environment\n";
12		exit 1;
13		}
14
15		my $command = "mksysnum_freebsd.pl " . join(' ', @ARGV);
16
17		print <<EOF;
18		// $command
19		// Code generated by the command above; see README.md. DO NOT EDIT.
20
21		// +build $ENV{'GOARCH'},$ENV{'GOOS'}
22
23		package unix
24
25		const (
26		EOF
27
28		while(<>){
29		if(/^([0-9]+)\s+\S+\s+(?:NO)?STD\s+({ \S+\s+(\w+).*)$/){
30		my $num = $1;
31		my $proto = $2;
32		my $name = "SYS_$3";
33		$name =~ y/a-z/A-Z/;
34
35		# There are multiple entries for enosys and nosys, so comment them out.
36		if($name =~ /^SYS_E?NOSYS$/){
37		$name = "// $name";
38		}
39		if($name eq 'SYS_SYS_EXIT'){
40		$name = 'SYS_EXIT';
41		}
42
43		print " $name = $num; // $proto\n";
44		}
45		}
46
47		print <<EOF;
48		)
49		EOF

-58

~~unix/mksysnum_netbsd.pl~~ less more

0		#!/usr/bin/env perl
1		# Copyright 2009 The Go Authors. All rights reserved.
2		# Use of this source code is governed by a BSD-style
3		# license that can be found in the LICENSE file.
4		#
5		# Generate system call table for OpenBSD from master list
6		# (for example, /usr/src/sys/kern/syscalls.master).
7
8		use strict;
9
10		if($ENV{'GOARCH'} eq "" \|\| $ENV{'GOOS'} eq "") {
11		print STDERR "GOARCH or GOOS not defined in environment\n";
12		exit 1;
13		}
14
15		my $command = "mksysnum_netbsd.pl " . join(' ', @ARGV);
16
17		print <<EOF;
18		// $command
19		// Code generated by the command above; see README.md. DO NOT EDIT.
20
21		// +build $ENV{'GOARCH'},$ENV{'GOOS'}
22
23		package unix
24
25		const (
26		EOF
27
28		my $line = '';
29		while(<>){
30		if($line =~ /^(.*)\\$/) {
31		# Handle continuation
32		$line = $1;
33		$_ =~ s/^\s+//;
34		$line .= $_;
35		} else {
36		# New line
37		$line = $_;
38		}
39		next if $line =~ /\\$/;
40		if($line =~ /^([0-9]+)\s+((STD)\|(NOERR))\s+(RUMP\s+)?({\s+\S+\s\?\s\\|(\S+)\\|(\S)\\|(\w+).*\s+})(\s+(\S+))?$/) {
41		my $num = $1;
42		my $proto = $6;
43		my $compat = $8;
44		my $name = "$7_$9";
45
46		$name = "$7_$11" if $11 ne '';
47		$name =~ y/a-z/A-Z/;
48
49		if($compat eq '' \|\| $compat eq '13' \|\| $compat eq '30' \|\| $compat eq '50') {
50		print " $name = $num; // $proto\n";
51		}
52		}
53		}
54
55		print <<EOF;
56		)
57		EOF

-50

~~unix/mksysnum_openbsd.pl~~ less more

0		#!/usr/bin/env perl
1		# Copyright 2009 The Go Authors. All rights reserved.
2		# Use of this source code is governed by a BSD-style
3		# license that can be found in the LICENSE file.
4		#
5		# Generate system call table for OpenBSD from master list
6		# (for example, /usr/src/sys/kern/syscalls.master).
7
8		use strict;
9
10		if($ENV{'GOARCH'} eq "" \|\| $ENV{'GOOS'} eq "") {
11		print STDERR "GOARCH or GOOS not defined in environment\n";
12		exit 1;
13		}
14
15		my $command = "mksysnum_openbsd.pl " . join(' ', @ARGV);
16
17		print <<EOF;
18		// $command
19		// Code generated by the command above; see README.md. DO NOT EDIT.
20
21		// +build $ENV{'GOARCH'},$ENV{'GOOS'}
22
23		package unix
24
25		const (
26		EOF
27
28		while(<>){
29		if(/^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\?(\w+).)$/){
30		my $num = $1;
31		my $proto = $3;
32		my $name = $4;
33		$name =~ y/a-z/A-Z/;
34
35		# There are multiple entries for enosys and nosys, so comment them out.
36		if($name =~ /^SYS_E?NOSYS$/){
37		$name = "// $name";
38		}
39		if($name eq 'SYS_SYS_EXIT'){
40		$name = 'SYS_EXIT';
41		}
42
43		print " $name = $num; // $proto\n";
44		}
45		}
46
47		print <<EOF;
48		)
49		EOF

+98

-0

unix/sendfile_test.go less more

	0	// Copyright 2018 The Go Authors. All rights reserved.
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// +build darwin,amd64 darwin,386 dragonfly freebsd linux solaris
	5
	6	package unix_test
	7
	8	import (
	9	"io/ioutil"
	10	"net"
	11	"os"
	12	"path/filepath"
	13	"testing"
	14
	15	"golang.org/x/sys/unix"
	16	)
	17
	18	func TestSendfile(t *testing.T) {
	19	// Set up source data file.
	20	tempDir, err := ioutil.TempDir("", "TestSendfile")
	21	if err != nil {
	22	t.Fatal(err)
	23	}
	24	defer os.RemoveAll(tempDir)
	25	name := filepath.Join(tempDir, "source")
	26	const contents = "contents"
	27	err = ioutil.WriteFile(name, []byte(contents), 0666)
	28	if err != nil {
	29	t.Fatal(err)
	30	}
	31
	32	done := make(chan bool)
	33
	34	// Start server listening on a socket.
	35	ln, err := net.Listen("tcp", "127.0.0.1:0")
	36	if err != nil {
	37	t.Skipf("listen failed: %s\n", err)
	38	}
	39	defer ln.Close()
	40	go func() {
	41	conn, err := ln.Accept()
	42	if err != nil {
	43	t.Fatal(err)
	44	}
	45	defer conn.Close()
	46	b, err := ioutil.ReadAll(conn)
	47	if string(b) != contents {
	48	t.Errorf("contents not transmitted: got %s (len=%d), want %s", string(b), len(b), contents)
	49	}
	50	done <- true
	51	}()
	52
	53	// Open source file.
	54	src, err := os.Open(name)
	55	if err != nil {
	56	t.Fatal(err)
	57	}
	58
	59	// Send source file to server.
	60	conn, err := net.Dial("tcp", ln.Addr().String())
	61	if err != nil {
	62	t.Fatal(err)
	63	}
	64	file, err := conn.(*net.TCPConn).File()
	65	if err != nil {
	66	t.Fatal(err)
	67	}
	68	var off int64
	69	n, err := unix.Sendfile(int(file.Fd()), int(src.Fd()), &off, len(contents))
	70	if err != nil {
	71	t.Errorf("Sendfile failed %s\n", err)
	72	}
	73	if n != len(contents) {
	74	t.Errorf("written count wrong: want %d, got %d", len(contents), n)
	75	}
	76	// Note: off is updated on some systems and not others. Oh well.
	77	// Linux: increments off by the amount sent.
	78	// Darwin: leaves off unchanged.
	79	// It would be nice to fix Darwin if we can.
	80	if off != 0 && off != int64(len(contents)) {
	81	t.Errorf("offset wrong: god %d, want %d or %d", off, 0, len(contents))
	82	}
	83	// The cursor position should be unchanged.
	84	pos, err := src.Seek(0, 1)
	85	if err != nil {
	86	t.Errorf("can't get cursor position %s\n", err)
	87	}
	88	if pos != 0 {
	89	t.Errorf("cursor position wrong: got %d, want 0", pos)
	90	}
	91
	92	file.Close() // Note: required to have the close below really send EOF to the server.
	93	conn.Close()
	94
	95	// Wait for server to close.
	96	<-done
	97	}

-0

unix/syscall_aix.go less more

265	265	func Gettimeofday(tv *Timeval) (err error) {
266	266	err = gettimeofday(tv, nil)
267	267	return
	268	}
	269
	270	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	271	if raceenabled {
	272	raceReleaseMerge(unsafe.Pointer(&ioSync))
	273	}
	274	return sendfile(outfd, infd, offset, count)
268	275	}
269	276
270	277	// TODO

+26

-38

unix/syscall_darwin.go less more

107	107	return nil, err
108	108	}
109	109
110		_, _, e1 := Syscall6(
111		SYS_GETATTRLIST,
112		uintptr(unsafe.Pointer(_p0)),
113		uintptr(unsafe.Pointer(&attrList)),
114		uintptr(unsafe.Pointer(&attrBuf[0])),
115		uintptr(len(attrBuf)),
116		uintptr(options),
117		0,
118		)
119		if e1 != 0 {
120		return nil, e1
	110	if err := getattrlist(_p0, unsafe.Pointer(&attrList), unsafe.Pointer(&attrBuf[0]), uintptr(len(attrBuf)), int(options)); err != nil {
	111	return nil, err
121	112	}
122	113	size := (uint32)(unsafe.Pointer(&attrBuf[0]))
123	114

150	141	return
151	142	}
152	143
	144	//sys getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
	145
153	146	//sysnb pipe() (r int, w int, err error)
154	147
155	148	func Pipe(p []int) (err error) {

167	160	_p0 = unsafe.Pointer(&buf[0])
168	161	bufsize = unsafe.Sizeof(Statfs_t{}) * uintptr(len(buf))
169	162	}
170		r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(_p0), bufsize, uintptr(flags))
171		n = int(r0)
172		if e1 != 0 {
173		err = e1
174		}
175		return
	163	return getfsstat(_p0, bufsize, flags)
176	164	}
177	165
178	166	func xattrPointer(dest []byte) *byte {

297	285	if flags&AT_SYMLINK_NOFOLLOW != 0 {
298	286	options \|= FSOPT_NOFOLLOW
299	287	}
300		_, _, e1 := Syscall6(
301		SYS_SETATTRLIST,
302		uintptr(unsafe.Pointer(_p0)),
303		uintptr(unsafe.Pointer(&attrList)),
304		uintptr(unsafe.Pointer(&attributes)),
305		uintptr(unsafe.Sizeof(attributes)),
306		uintptr(options),
307		0,
308		)
309		if e1 != 0 {
310		return e1
311		}
312		return nil
313		}
	288	return setattrlist(
	289	_p0,
	290	unsafe.Pointer(&attrList),
	291	unsafe.Pointer(&attributes),
	292	unsafe.Sizeof(attributes),
	293	options)
	294	}
	295
	296	//sys setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error)
314	297
315	298	func utimensat(dirfd int, path string, times *[2]Timespec, flags int) error {
316	299	// Darwin doesn't support SYS_UTIMENSAT

409	392
410	393	return nil
411	394	}
	395
	396	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	397	if raceenabled {
	398	raceReleaseMerge(unsafe.Pointer(&ioSync))
	399	}
	400	var length = int64(count)
	401	err = sendfile(infd, outfd, *offset, &length, nil, 0)
	402	written = int(length)
	403	return
	404	}
	405
	406	//sys sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error)
412	407
413	408	/*
414	409	* Exposed directly

434	429	//sys Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error)
435	430	//sys Flock(fd int, how int) (err error)
436	431	//sys Fpathconf(fd int, name int) (val int, err error)
437		//sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
438		//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
439		//sys Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
440	432	//sys Fsync(fd int) (err error)
441	433	//sys Ftruncate(fd int, length int64) (err error)
442		//sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) = SYS_GETDIRENTRIES64
443	434	//sys Getdtablesize() (size int)
444	435	//sysnb Getegid() (egid int)
445	436	//sysnb Geteuid() (uid int)

459	450	//sys Link(path string, link string) (err error)
460	451	//sys Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error)
461	452	//sys Listen(s int, backlog int) (err error)
462		//sys Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
463	453	//sys Mkdir(path string, mode uint32) (err error)
464	454	//sys Mkdirat(dirfd int, path string, mode uint32) (err error)
465	455	//sys Mkfifo(path string, mode uint32) (err error)

491	481	//sysnb Setsid() (pid int, err error)
492	482	//sysnb Settimeofday(tp *Timeval) (err error)
493	483	//sysnb Setuid(uid int) (err error)
494		//sys Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
495		//sys Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64
496	484	//sys Symlink(path string, link string) (err error)
497	485	//sys Symlinkat(oldpath string, newdirfd int, newpath string) (err error)
498	486	//sys Sync() (err error)

-14

unix/syscall_darwin_386.go less more

7	7
8	8	import (
9	9	"syscall"
10		"unsafe"
11	10	)
12	11
13	12	func setTimespec(sec, nsec int64) Timespec {

47	46	cmsg.Len = uint32(length)
48	47	}
49	48
50		func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
51		var length = uint64(count)
52
53		_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
54
55		written = int(length)
56
57		if e1 != 0 {
58		err = e1
59		}
60		return
61		}
62
63	49	func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
64	50
65	51	// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
66	52	// of darwin/386 the syscall is called sysctl instead of __sysctl.
67	53	const SYS___SYSCTL = SYS_SYSCTL
	54
	55	//sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
	56	//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
	57	//sys Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
	58	//sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) = SYS_GETDIRENTRIES64
	59	//sys getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
	60	//sys Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
	61	//sys Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
	62	//sys Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64

-14

unix/syscall_darwin_amd64.go less more

7	7
8	8	import (
9	9	"syscall"
10		"unsafe"
11	10	)
12	11
13	12	func setTimespec(sec, nsec int64) Timespec {

47	46	cmsg.Len = uint32(length)
48	47	}
49	48
50		func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
51		var length = uint64(count)
52
53		_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
54
55		written = int(length)
56
57		if e1 != 0 {
58		err = e1
59		}
60		return
61		}
62
63	49	func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
64	50
65	51	// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
66	52	// of darwin/amd64 the syscall is called sysctl instead of __sysctl.
67	53	const SYS___SYSCTL = SYS_SYSCTL
	54
	55	//sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64
	56	//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64
	57	//sys Fstatfs(fd int, stat *Statfs_t) (err error) = SYS_FSTATFS64
	58	//sys Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) = SYS_GETDIRENTRIES64
	59	//sys getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT64
	60	//sys Lstat(path string, stat *Stat_t) (err error) = SYS_LSTAT64
	61	//sys Stat(path string, stat *Stat_t) (err error) = SYS_STAT64
	62	//sys Statfs(path string, stat *Statfs_t) (err error) = SYS_STATFS64

+12

-14

unix/syscall_darwin_arm.go less more

5	5
6	6	import (
7	7	"syscall"
8		"unsafe"
9	8	)
10	9
11	10	func setTimespec(sec, nsec int64) Timespec {

45	44	cmsg.Len = uint32(length)
46	45	}
47	46
48		func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
49		var length = uint64(count)
50
51		_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
52
53		written = int(length)
54
55		if e1 != 0 {
56		err = e1
57		}
58		return
59		}
60
61	47	func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
62	48
63	49	// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
64	50	// of darwin/arm the syscall is called sysctl instead of __sysctl.
65	51	const SYS___SYSCTL = SYS_SYSCTL
	52
	53	//sys Fstat(fd int, stat *Stat_t) (err error)
	54	//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
	55	//sys Fstatfs(fd int, stat *Statfs_t) (err error)
	56	//sys getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT
	57	//sys Lstat(path string, stat *Stat_t) (err error)
	58	//sys Stat(path string, stat *Stat_t) (err error)
	59	//sys Statfs(path string, stat *Statfs_t) (err error)
	60
	61	func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
	62	return 0, ENOSYS
	63	}

+12

-14

unix/syscall_darwin_arm64.go less more

7	7
8	8	import (
9	9	"syscall"
10		"unsafe"
11	10	)
12	11
13	12	func setTimespec(sec, nsec int64) Timespec {

47	46	cmsg.Len = uint32(length)
48	47	}
49	48
50		func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
51		var length = uint64(count)
52
53		_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
54
55		written = int(length)
56
57		if e1 != 0 {
58		err = e1
59		}
60		return
61		}
62
63	49	func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
64	50
65	51	// SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
66	52	// of darwin/arm64 the syscall is called sysctl instead of __sysctl.
67	53	const SYS___SYSCTL = SYS_SYSCTL
	54
	55	//sys Fstat(fd int, stat *Stat_t) (err error)
	56	//sys Fstatat(fd int, path string, stat *Stat_t, flags int) (err error)
	57	//sys Fstatfs(fd int, stat *Statfs_t) (err error)
	58	//sys getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) = SYS_GETFSSTAT
	59	//sys Lstat(path string, stat *Stat_t) (err error)
	60	//sys Stat(path string, stat *Stat_t) (err error)
	61	//sys Statfs(path string, stat *Statfs_t) (err error)
	62
	63	func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
	64	return 0, ENOSYS
	65	}

+31

-0

unix/syscall_darwin_libSystem.go less more

	0	// Copyright 2018 The Go Authors. All rights reserved.
	1	// Use of this source code is governed by a BSD-style
	2	// license that can be found in the LICENSE file.
	3
	4	// +build darwin,go1.12
	5
	6	package unix
	7
	8	import "unsafe"
	9
	10	// Implemented in the runtime package (runtime/sys_darwin.go)
	11	func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
	12	func syscall_syscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
	13	func syscall_syscall6X(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
	14	func syscall_syscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err Errno) // 32-bit only
	15	func syscall_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)
	16	func syscall_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err Errno)
	17
	18	//go:linkname syscall_syscall syscall.syscall
	19	//go:linkname syscall_syscall6 syscall.syscall6
	20	//go:linkname syscall_syscall6X syscall.syscall6X
	21	//go:linkname syscall_syscall9 syscall.syscall9
	22	//go:linkname syscall_rawSyscall syscall.rawSyscall
	23	//go:linkname syscall_rawSyscall6 syscall.rawSyscall6
	24
	25	// Find the entry point for f. See comments in runtime/proc.go for the
	26	// function of the same name.
	27	//go:nosplit
	28	func funcPC(f func()) uintptr {
	29	return (uintptr)(unsafe.Pointer(&f))
	30	}

-0

unix/syscall_dragonfly.go less more

231	231	uname.Machine[unsafe.Sizeof(uname.Machine)-1] = 0
232	232
233	233	return nil
	234	}
	235
	236	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	237	if raceenabled {
	238	raceReleaseMerge(unsafe.Pointer(&ioSync))
	239	}
	240	return sendfile(outfd, infd, offset, count)
234	241	}
235	242
236	243	/*

-0

unix/syscall_freebsd.go less more

497	497	}
498	498
499	499	return dstPos
	500	}
	501
	502	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	503	if raceenabled {
	504	raceReleaseMerge(unsafe.Pointer(&ioSync))
	505	}
	506	return sendfile(outfd, infd, offset, count)
500	507	}
501	508
502	509	/*

-0

unix/syscall_linux.go less more

1357	1357	return err
1358	1358	}
1359	1359	return mount(source, target, fstype, flags, datap)
	1360	}
	1361
	1362	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	1363	if raceenabled {
	1364	raceReleaseMerge(unsafe.Pointer(&ioSync))
	1365	}
	1366	return sendfile(outfd, infd, offset, count)
1360	1367	}
1361	1368
1362	1369	// Sendto

-1

unix/syscall_linux_mips64x.go less more

11	11	//sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error)
12	12	//sys Fadvise(fd int, offset int64, length int64, advice int) (err error) = SYS_FADVISE64
13	13	//sys Fchown(fd int, uid int, gid int) (err error)
14		//sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_NEWFSTATAT
15	14	//sys Fstatfs(fd int, buf *Statfs_t) (err error)
16	15	//sys Ftruncate(fd int, length int64) (err error)
17	16	//sysnb Getegid() (egid int)

147	146	}
148	147
149	148	//sys fstat(fd int, st *stat_t) (err error)
	149	//sys fstatat(dirfd int, path string, st *stat_t, flags int) (err error) = SYS_NEWFSTATAT
150	150	//sys lstat(path string, st *stat_t) (err error)
151	151	//sys stat(path string, st *stat_t) (err error)
152	152
153	153	func Fstat(fd int, s *Stat_t) (err error) {
154	154	st := &stat_t{}
155	155	err = fstat(fd, st)
	156	fillStat_t(s, st)
	157	return
	158	}
	159
	160	func Fstatat(dirfd int, path string, s *Stat_t, flags int) (err error) {
	161	st := &stat_t{}
	162	err = fstatat(dirfd, path, st, flags)
156	163	fillStat_t(s, st)
157	164	return
158	165	}

-0

unix/syscall_netbsd.go less more

241	241	}
242	242
243	243	return nil
	244	}
	245
	246	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	247	if raceenabled {
	248	raceReleaseMerge(unsafe.Pointer(&ioSync))
	249	}
	250	return sendfile(outfd, infd, offset, count)
244	251	}
245	252
246	253	/*

-0

unix/syscall_openbsd.go less more

91	91	return "", EINVAL
92	92	}
93	93	return string(buf[:n]), nil
	94	}
	95
	96	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	97	if raceenabled {
	98	raceReleaseMerge(unsafe.Pointer(&ioSync))
	99	}
	100	return sendfile(outfd, infd, offset, count)
94	101	}
95	102
96	103	// TODO

-0

unix/syscall_solaris.go less more

582	582	return poll(nil, 0, timeout)
583	583	}
584	584	return poll(&fds[0], len(fds), timeout)
	585	}
	586
	587	func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	588	if raceenabled {
	589	raceReleaseMerge(unsafe.Pointer(&ioSync))
	590	}
	591	return sendfile(outfd, infd, offset, count)
585	592	}
586	593
587	594	/*

-7

unix/syscall_unix.go less more

350	350	return
351	351	}
352	352
353		func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
354		if raceenabled {
355		raceReleaseMerge(unsafe.Pointer(&ioSync))
356		}
357		return sendfile(outfd, infd, offset, count)
358		}
359
360	353	var ioSync int64
361	354
362	355	func CloseOnExec(fd int) { fcntl(fd, F_SETFD, FD_CLOEXEC) }

-0

unix/syscall_unix_test.go less more

336	336	}
337	337	set := rlimit
338	338	set.Cur = set.Max - 1
	339	if runtime.GOOS == "darwin" && set.Cur > 10240 {
	340	// The max file limit is 10240, even though
	341	// the max returned by Getrlimit is 1<<63-1.
	342	// This is OPEN_MAX in sys/syslimits.h.
	343	set.Cur = 10240
	344	}
339	345	err = unix.Setrlimit(unix.RLIMIT_NOFILE, &set)
340	346	if err != nil {
341	347	t.Fatalf("Setrlimit: set failed: %#v %v", set, err)

+2420

-1776

unix/zerrors_linux_sparc64.go less more

10	10	import "syscall"
11	11
12	12	const (
13		AF_ALG = 0x26
14		AF_APPLETALK = 0x5
15		AF_ASH = 0x12
16		AF_ATMPVC = 0x8
17		AF_ATMSVC = 0x14
18		AF_AX25 = 0x3
19		AF_BLUETOOTH = 0x1f
20		AF_BRIDGE = 0x7
21		AF_CAIF = 0x25
22		AF_CAN = 0x1d
23		AF_DECnet = 0xc
24		AF_ECONET = 0x13
25		AF_FILE = 0x1
26		AF_IB = 0x1b
27		AF_IEEE802154 = 0x24
28		AF_INET = 0x2
29		AF_INET6 = 0xa
30		AF_IPX = 0x4
31		AF_IRDA = 0x17
32		AF_ISDN = 0x22
33		AF_IUCV = 0x20
34		AF_KCM = 0x29
35		AF_KEY = 0xf
36		AF_LLC = 0x1a
37		AF_LOCAL = 0x1
38		AF_MAX = 0x2a
39		AF_MPLS = 0x1c
40		AF_NETBEUI = 0xd
41		AF_NETLINK = 0x10
42		AF_NETROM = 0x6
43		AF_NFC = 0x27
44		AF_PACKET = 0x11
45		AF_PHONET = 0x23
46		AF_PPPOX = 0x18
47		AF_RDS = 0x15
48		AF_ROSE = 0xb
49		AF_ROUTE = 0x10
50		AF_RXRPC = 0x21
51		AF_SECURITY = 0xe
52		AF_SNA = 0x16
53		AF_TIPC = 0x1e
54		AF_UNIX = 0x1
55		AF_UNSPEC = 0x0
56		AF_VSOCK = 0x28
57		AF_WANPIPE = 0x19
58		AF_X25 = 0x9
59		ALG_OP_DECRYPT = 0x0
60		ALG_OP_ENCRYPT = 0x1
61		ALG_SET_AEAD_ASSOCLEN = 0x4
62		ALG_SET_AEAD_AUTHSIZE = 0x5
63		ALG_SET_IV = 0x2
64		ALG_SET_KEY = 0x1
65		ALG_SET_OP = 0x3
66		ARPHRD_6LOWPAN = 0x339
67		ARPHRD_ADAPT = 0x108
68		ARPHRD_APPLETLK = 0x8
69		ARPHRD_ARCNET = 0x7
70		ARPHRD_ASH = 0x30d
71		ARPHRD_ATM = 0x13
72		ARPHRD_AX25 = 0x3
73		ARPHRD_BIF = 0x307
74		ARPHRD_CAIF = 0x336
75		ARPHRD_CAN = 0x118
76		ARPHRD_CHAOS = 0x5
77		ARPHRD_CISCO = 0x201
78		ARPHRD_CSLIP = 0x101
79		ARPHRD_CSLIP6 = 0x103
80		ARPHRD_DDCMP = 0x205
81		ARPHRD_DLCI = 0xf
82		ARPHRD_ECONET = 0x30e
83		ARPHRD_EETHER = 0x2
84		ARPHRD_ETHER = 0x1
85		ARPHRD_EUI64 = 0x1b
86		ARPHRD_FCAL = 0x311
87		ARPHRD_FCFABRIC = 0x313
88		ARPHRD_FCPL = 0x312
89		ARPHRD_FCPP = 0x310
90		ARPHRD_FDDI = 0x306
91		ARPHRD_FRAD = 0x302
92		ARPHRD_HDLC = 0x201
93		ARPHRD_HIPPI = 0x30c
94		ARPHRD_HWX25 = 0x110
95		ARPHRD_IEEE1394 = 0x18
96		ARPHRD_IEEE802 = 0x6
97		ARPHRD_IEEE80211 = 0x321
98		ARPHRD_IEEE80211_PRISM = 0x322
99		ARPHRD_IEEE80211_RADIOTAP = 0x323
100		ARPHRD_IEEE802154 = 0x324
101		ARPHRD_IEEE802154_MONITOR = 0x325
102		ARPHRD_IEEE802_TR = 0x320
103		ARPHRD_INFINIBAND = 0x20
104		ARPHRD_IP6GRE = 0x337
105		ARPHRD_IPDDP = 0x309
106		ARPHRD_IPGRE = 0x30a
107		ARPHRD_IRDA = 0x30f
108		ARPHRD_LAPB = 0x204
109		ARPHRD_LOCALTLK = 0x305
110		ARPHRD_LOOPBACK = 0x304
111		ARPHRD_METRICOM = 0x17
112		ARPHRD_NETLINK = 0x338
113		ARPHRD_NETROM = 0x0
114		ARPHRD_NONE = 0xfffe
115		ARPHRD_PHONET = 0x334
116		ARPHRD_PHONET_PIPE = 0x335
117		ARPHRD_PIMREG = 0x30b
118		ARPHRD_PPP = 0x200
119		ARPHRD_PRONET = 0x4
120		ARPHRD_RAWHDLC = 0x206
121		ARPHRD_ROSE = 0x10e
122		ARPHRD_RSRVD = 0x104
123		ARPHRD_SIT = 0x308
124		ARPHRD_SKIP = 0x303
125		ARPHRD_SLIP = 0x100
126		ARPHRD_SLIP6 = 0x102
127		ARPHRD_TUNNEL = 0x300
128		ARPHRD_TUNNEL6 = 0x301
129		ARPHRD_VOID = 0xffff
130		ARPHRD_X25 = 0x10f
131		ASI_LEON_DFLUSH = 0x11
132		ASI_LEON_IFLUSH = 0x10
133		ASI_LEON_MMUFLUSH = 0x18
134		B0 = 0x0
135		B1000000 = 0x100c
136		B110 = 0x3
137		B115200 = 0x1002
138		B1152000 = 0x100d
139		B1200 = 0x9
140		B134 = 0x4
141		B150 = 0x5
142		B1500000 = 0x100e
143		B153600 = 0x1006
144		B1800 = 0xa
145		B19200 = 0xe
146		B200 = 0x6
147		B2000000 = 0x100f
148		B230400 = 0x1003
149		B2400 = 0xb
150		B300 = 0x7
151		B307200 = 0x1007
152		B38400 = 0xf
153		B460800 = 0x1004
154		B4800 = 0xc
155		B50 = 0x1
156		B500000 = 0x100a
157		B57600 = 0x1001
158		B576000 = 0x100b
159		B600 = 0x8
160		B614400 = 0x1008
161		B75 = 0x2
162		B76800 = 0x1005
163		B921600 = 0x1009
164		B9600 = 0xd
165		BLKBSZGET = 0x80081270
166		BLKBSZSET = 0x40081271
167		BLKFLSBUF = 0x1261
168		BLKFRAGET = 0x1265
169		BLKFRASET = 0x1264
170		BLKGETSIZE = 0x1260
171		BLKGETSIZE64 = 0x80081272
172		BLKRAGET = 0x1263
173		BLKRASET = 0x1262
174		BLKROGET = 0x125e
175		BLKROSET = 0x125d
176		BLKRRPART = 0x125f
177		BLKSECTGET = 0x1267
178		BLKSECTSET = 0x1266
179		BLKSSZGET = 0x1268
180		BOTHER = 0x1000
181		BPF_A = 0x10
182		BPF_ABS = 0x20
183		BPF_ADD = 0x0
184		BPF_ALU = 0x4
185		BPF_AND = 0x50
186		BPF_B = 0x10
187		BPF_DIV = 0x30
188		BPF_H = 0x8
189		BPF_IMM = 0x0
190		BPF_IND = 0x40
191		BPF_JA = 0x0
192		BPF_JEQ = 0x10
193		BPF_JGE = 0x30
194		BPF_JGT = 0x20
195		BPF_JMP = 0x5
196		BPF_JSET = 0x40
197		BPF_K = 0x0
198		BPF_LD = 0x0
199		BPF_LDX = 0x1
200		BPF_LEN = 0x80
201		BPF_LL_OFF = -0x200000
202		BPF_LSH = 0x60
203		BPF_MAJOR_VERSION = 0x1
204		BPF_MAXINSNS = 0x1000
205		BPF_MEM = 0x60
206		BPF_MEMWORDS = 0x10
207		BPF_MINOR_VERSION = 0x1
208		BPF_MISC = 0x7
209		BPF_MOD = 0x90
210		BPF_MSH = 0xa0
211		BPF_MUL = 0x20
212		BPF_NEG = 0x80
213		BPF_NET_OFF = -0x100000
214		BPF_OR = 0x40
215		BPF_RET = 0x6
216		BPF_RSH = 0x70
217		BPF_ST = 0x2
218		BPF_STX = 0x3
219		BPF_SUB = 0x10
220		BPF_TAX = 0x0
221		BPF_TXA = 0x80
222		BPF_W = 0x0
223		BPF_X = 0x8
224		BPF_XOR = 0xa0
225		BRKINT = 0x2
226		BS0 = 0x0
227		BS1 = 0x2000
228		BSDLY = 0x2000
229		CAN_BCM = 0x2
230		CAN_EFF_FLAG = 0x80000000
231		CAN_EFF_ID_BITS = 0x1d
232		CAN_EFF_MASK = 0x1fffffff
233		CAN_ERR_FLAG = 0x20000000
234		CAN_ERR_MASK = 0x1fffffff
235		CAN_INV_FILTER = 0x20000000
236		CAN_ISOTP = 0x6
237		CAN_MAX_DLC = 0x8
238		CAN_MAX_DLEN = 0x8
239		CAN_MCNET = 0x5
240		CAN_MTU = 0x10
241		CAN_NPROTO = 0x7
242		CAN_RAW = 0x1
243		CAN_RTR_FLAG = 0x40000000
244		CAN_SFF_ID_BITS = 0xb
245		CAN_SFF_MASK = 0x7ff
246		CAN_TP16 = 0x3
247		CAN_TP20 = 0x4
248		CBAUD = 0x100f
249		CBAUDEX = 0x1000
250		CFLUSH = 0xf
251		CIBAUD = 0x100f0000
252		CLOCAL = 0x800
253		CLOCK_BOOTTIME = 0x7
254		CLOCK_BOOTTIME_ALARM = 0x9
255		CLOCK_DEFAULT = 0x0
256		CLOCK_EXT = 0x1
257		CLOCK_INT = 0x2
258		CLOCK_MONOTONIC = 0x1
259		CLOCK_MONOTONIC_COARSE = 0x6
260		CLOCK_MONOTONIC_RAW = 0x4
261		CLOCK_PROCESS_CPUTIME_ID = 0x2
262		CLOCK_REALTIME = 0x0
263		CLOCK_REALTIME_ALARM = 0x8
264		CLOCK_REALTIME_COARSE = 0x5
265		CLOCK_TAI = 0xb
266		CLOCK_THREAD_CPUTIME_ID = 0x3
267		CLOCK_TXFROMRX = 0x4
268		CLOCK_TXINT = 0x3
269		CLONE_CHILD_CLEARTID = 0x200000
270		CLONE_CHILD_SETTID = 0x1000000
271		CLONE_DETACHED = 0x400000
272		CLONE_FILES = 0x400
273		CLONE_FS = 0x200
274		CLONE_IO = 0x80000000
275		CLONE_NEWCGROUP = 0x2000000
276		CLONE_NEWIPC = 0x8000000
277		CLONE_NEWNET = 0x40000000
278		CLONE_NEWNS = 0x20000
279		CLONE_NEWPID = 0x20000000
280		CLONE_NEWUSER = 0x10000000
281		CLONE_NEWUTS = 0x4000000
282		CLONE_PARENT = 0x8000
283		CLONE_PARENT_SETTID = 0x100000
284		CLONE_PTRACE = 0x2000
285		CLONE_SETTLS = 0x80000
286		CLONE_SIGHAND = 0x800
287		CLONE_SYSVSEM = 0x40000
288		CLONE_THREAD = 0x10000
289		CLONE_UNTRACED = 0x800000
290		CLONE_VFORK = 0x4000
291		CLONE_VM = 0x100
292		CMSPAR = 0x40000000
293		CR0 = 0x0
294		CR1 = 0x200
295		CR2 = 0x400
296		CR3 = 0x600
297		CRDLY = 0x600
298		CREAD = 0x80
299		CRTSCTS = 0x80000000
300		CS5 = 0x0
301		CS6 = 0x10
302		CS7 = 0x20
303		CS8 = 0x30
304		CSIGNAL = 0xff
305		CSIZE = 0x30
306		CSTART = 0x11
307		CSTATUS = 0x0
308		CSTOP = 0x13
309		CSTOPB = 0x40
310		CSUSP = 0x1a
311		DT_BLK = 0x6
312		DT_CHR = 0x2
313		DT_DIR = 0x4
314		DT_FIFO = 0x1
315		DT_LNK = 0xa
316		DT_REG = 0x8
317		DT_SOCK = 0xc
318		DT_UNKNOWN = 0x0
319		DT_WHT = 0xe
320		ECHO = 0x8
321		ECHOCTL = 0x200
322		ECHOE = 0x10
323		ECHOK = 0x20
324		ECHOKE = 0x800
325		ECHONL = 0x40
326		ECHOPRT = 0x400
327		EMT_TAGOVF = 0x1
328		ENCODING_DEFAULT = 0x0
329		ENCODING_FM_MARK = 0x3
330		ENCODING_FM_SPACE = 0x4
331		ENCODING_MANCHESTER = 0x5
332		ENCODING_NRZ = 0x1
333		ENCODING_NRZI = 0x2
334		EPOLLERR = 0x8
335		EPOLLET = 0x80000000
336		EPOLLEXCLUSIVE = 0x10000000
337		EPOLLHUP = 0x10
338		EPOLLIN = 0x1
339		EPOLLMSG = 0x400
340		EPOLLONESHOT = 0x40000000
341		EPOLLOUT = 0x4
342		EPOLLPRI = 0x2
343		EPOLLRDBAND = 0x80
344		EPOLLRDHUP = 0x2000
345		EPOLLRDNORM = 0x40
346		EPOLLWAKEUP = 0x20000000
347		EPOLLWRBAND = 0x200
348		EPOLLWRNORM = 0x100
349		EPOLL_CLOEXEC = 0x400000
350		EPOLL_CTL_ADD = 0x1
351		EPOLL_CTL_DEL = 0x2
352		EPOLL_CTL_MOD = 0x3
353		ETH_P_1588 = 0x88f7
354		ETH_P_8021AD = 0x88a8
355		ETH_P_8021AH = 0x88e7
356		ETH_P_8021Q = 0x8100
357		ETH_P_80221 = 0x8917
358		ETH_P_802_2 = 0x4
359		ETH_P_802_3 = 0x1
360		ETH_P_802_3_MIN = 0x600
361		ETH_P_802_EX1 = 0x88b5
362		ETH_P_AARP = 0x80f3
363		ETH_P_AF_IUCV = 0xfbfb
364		ETH_P_ALL = 0x3
365		ETH_P_AOE = 0x88a2
366		ETH_P_ARCNET = 0x1a
367		ETH_P_ARP = 0x806
368		ETH_P_ATALK = 0x809b
369		ETH_P_ATMFATE = 0x8884
370		ETH_P_ATMMPOA = 0x884c
371		ETH_P_AX25 = 0x2
372		ETH_P_BATMAN = 0x4305
373		ETH_P_BPQ = 0x8ff
374		ETH_P_CAIF = 0xf7
375		ETH_P_CAN = 0xc
376		ETH_P_CANFD = 0xd
377		ETH_P_CONTROL = 0x16
378		ETH_P_CUST = 0x6006
379		ETH_P_DDCMP = 0x6
380		ETH_P_DEC = 0x6000
381		ETH_P_DIAG = 0x6005
382		ETH_P_DNA_DL = 0x6001
383		ETH_P_DNA_RC = 0x6002
384		ETH_P_DNA_RT = 0x6003
385		ETH_P_DSA = 0x1b
386		ETH_P_ECONET = 0x18
387		ETH_P_EDSA = 0xdada
388		ETH_P_FCOE = 0x8906
389		ETH_P_FIP = 0x8914
390		ETH_P_HDLC = 0x19
391		ETH_P_HSR = 0x892f
392		ETH_P_IEEE802154 = 0xf6
393		ETH_P_IEEEPUP = 0xa00
394		ETH_P_IEEEPUPAT = 0xa01
395		ETH_P_IP = 0x800
396		ETH_P_IPV6 = 0x86dd
397		ETH_P_IPX = 0x8137
398		ETH_P_IRDA = 0x17
399		ETH_P_LAT = 0x6004
400		ETH_P_LINK_CTL = 0x886c
401		ETH_P_LOCALTALK = 0x9
402		ETH_P_LOOP = 0x60
403		ETH_P_LOOPBACK = 0x9000
404		ETH_P_MACSEC = 0x88e5
405		ETH_P_MOBITEX = 0x15
406		ETH_P_MPLS_MC = 0x8848
407		ETH_P_MPLS_UC = 0x8847
408		ETH_P_MVRP = 0x88f5
409		ETH_P_PAE = 0x888e
410		ETH_P_PAUSE = 0x8808
411		ETH_P_PHONET = 0xf5
412		ETH_P_PPPTALK = 0x10
413		ETH_P_PPP_DISC = 0x8863
414		ETH_P_PPP_MP = 0x8
415		ETH_P_PPP_SES = 0x8864
416		ETH_P_PRP = 0x88fb
417		ETH_P_PUP = 0x200
418		ETH_P_PUPAT = 0x201
419		ETH_P_QINQ1 = 0x9100
420		ETH_P_QINQ2 = 0x9200
421		ETH_P_QINQ3 = 0x9300
422		ETH_P_RARP = 0x8035
423		ETH_P_SCA = 0x6007
424		ETH_P_SLOW = 0x8809
425		ETH_P_SNAP = 0x5
426		ETH_P_TDLS = 0x890d
427		ETH_P_TEB = 0x6558
428		ETH_P_TIPC = 0x88ca
429		ETH_P_TRAILER = 0x1c
430		ETH_P_TR_802_2 = 0x11
431		ETH_P_TSN = 0x22f0
432		ETH_P_WAN_PPP = 0x7
433		ETH_P_WCCP = 0x883e
434		ETH_P_X25 = 0x805
435		ETH_P_XDSA = 0xf8
436		EXTA = 0xe
437		EXTB = 0xf
438		EXTPROC = 0x10000
439		FALLOC_FL_COLLAPSE_RANGE = 0x8
440		FALLOC_FL_INSERT_RANGE = 0x20
441		FALLOC_FL_KEEP_SIZE = 0x1
442		FALLOC_FL_NO_HIDE_STALE = 0x4
443		FALLOC_FL_PUNCH_HOLE = 0x2
444		FALLOC_FL_ZERO_RANGE = 0x10
445		FD_CLOEXEC = 0x1
446		FD_SETSIZE = 0x400
447		FF0 = 0x0
448		FF1 = 0x8000
449		FFDLY = 0x8000
450		FLUSHO = 0x2000
451		F_DUPFD = 0x0
452		F_DUPFD_CLOEXEC = 0x406
453		F_EXLCK = 0x4
454		F_GETFD = 0x1
455		F_GETFL = 0x3
456		F_GETLEASE = 0x401
457		F_GETLK = 0x7
458		F_GETLK64 = 0x7
459		F_GETOWN = 0x5
460		F_GETOWN_EX = 0x10
461		F_GETPIPE_SZ = 0x408
462		F_GETSIG = 0xb
463		F_LOCK = 0x1
464		F_NOTIFY = 0x402
465		F_OFD_GETLK = 0x24
466		F_OFD_SETLK = 0x25
467		F_OFD_SETLKW = 0x26
468		F_OK = 0x0
469		F_RDLCK = 0x1
470		F_SETFD = 0x2
471		F_SETFL = 0x4
472		F_SETLEASE = 0x400
473		F_SETLK = 0x8
474		F_SETLK64 = 0x8
475		F_SETLKW = 0x9
476		F_SETLKW64 = 0x9
477		F_SETOWN = 0x6
478		F_SETOWN_EX = 0xf
479		F_SETPIPE_SZ = 0x407
480		F_SETSIG = 0xa
481		F_SHLCK = 0x8
482		F_TEST = 0x3
483		F_TLOCK = 0x2
484		F_ULOCK = 0x0
485		F_UNLCK = 0x3
486		F_WRLCK = 0x2
487		GRND_NONBLOCK = 0x1
488		GRND_RANDOM = 0x2
489		HUPCL = 0x400
490		IBSHIFT = 0x10
491		ICANON = 0x2
492		ICMPV6_FILTER = 0x1
493		ICRNL = 0x100
494		IEXTEN = 0x8000
495		IFA_F_DADFAILED = 0x8
496		IFA_F_DEPRECATED = 0x20
497		IFA_F_HOMEADDRESS = 0x10
498		IFA_F_MANAGETEMPADDR = 0x100
499		IFA_F_MCAUTOJOIN = 0x400
500		IFA_F_NODAD = 0x2
501		IFA_F_NOPREFIXROUTE = 0x200
502		IFA_F_OPTIMISTIC = 0x4
503		IFA_F_PERMANENT = 0x80
504		IFA_F_SECONDARY = 0x1
505		IFA_F_STABLE_PRIVACY = 0x800
506		IFA_F_TEMPORARY = 0x1
507		IFA_F_TENTATIVE = 0x40
508		IFA_MAX = 0x8
509		IFF_ALLMULTI = 0x200
510		IFF_ATTACH_QUEUE = 0x200
511		IFF_AUTOMEDIA = 0x4000
512		IFF_BROADCAST = 0x2
513		IFF_DEBUG = 0x4
514		IFF_DETACH_QUEUE = 0x400
515		IFF_DORMANT = 0x20000
516		IFF_DYNAMIC = 0x8000
517		IFF_ECHO = 0x40000
518		IFF_LOOPBACK = 0x8
519		IFF_LOWER_UP = 0x10000
520		IFF_MASTER = 0x400
521		IFF_MULTICAST = 0x1000
522		IFF_MULTI_QUEUE = 0x100
523		IFF_NOARP = 0x80
524		IFF_NOFILTER = 0x1000
525		IFF_NOTRAILERS = 0x20
526		IFF_NO_PI = 0x1000
527		IFF_ONE_QUEUE = 0x2000
528		IFF_PERSIST = 0x800
529		IFF_POINTOPOINT = 0x10
530		IFF_PORTSEL = 0x2000
531		IFF_PROMISC = 0x100
532		IFF_RUNNING = 0x40
533		IFF_SLAVE = 0x800
534		IFF_TAP = 0x2
535		IFF_TUN = 0x1
536		IFF_TUN_EXCL = 0x8000
537		IFF_UP = 0x1
538		IFF_VNET_HDR = 0x4000
539		IFF_VOLATILE = 0x70c5a
540		IFNAMSIZ = 0x10
541		IGNBRK = 0x1
542		IGNCR = 0x80
543		IGNPAR = 0x4
544		IMAXBEL = 0x2000
545		INLCR = 0x40
546		INPCK = 0x10
547		IN_ACCESS = 0x1
548		IN_ALL_EVENTS = 0xfff
549		IN_ATTRIB = 0x4
550		IN_CLASSA_HOST = 0xffffff
551		IN_CLASSA_MAX = 0x80
552		IN_CLASSA_NET = 0xff000000
553		IN_CLASSA_NSHIFT = 0x18
554		IN_CLASSB_HOST = 0xffff
555		IN_CLASSB_MAX = 0x10000
556		IN_CLASSB_NET = 0xffff0000
557		IN_CLASSB_NSHIFT = 0x10
558		IN_CLASSC_HOST = 0xff
559		IN_CLASSC_NET = 0xffffff00
560		IN_CLASSC_NSHIFT = 0x8
561		IN_CLOEXEC = 0x400000
562		IN_CLOSE = 0x18
563		IN_CLOSE_NOWRITE = 0x10
564		IN_CLOSE_WRITE = 0x8
565		IN_CREATE = 0x100
566		IN_DELETE = 0x200
567		IN_DELETE_SELF = 0x400
568		IN_DONT_FOLLOW = 0x2000000
569		IN_EXCL_UNLINK = 0x4000000
570		IN_IGNORED = 0x8000
571		IN_ISDIR = 0x40000000
572		IN_LOOPBACKNET = 0x7f
573		IN_MASK_ADD = 0x20000000
574		IN_MODIFY = 0x2
575		IN_MOVE = 0xc0
576		IN_MOVED_FROM = 0x40
577		IN_MOVED_TO = 0x80
578		IN_MOVE_SELF = 0x800
579		IN_NONBLOCK = 0x4000
580		IN_ONESHOT = 0x80000000
581		IN_ONLYDIR = 0x1000000
582		IN_OPEN = 0x20
583		IN_Q_OVERFLOW = 0x4000
584		IN_UNMOUNT = 0x2000
585		IPPROTO_AH = 0x33
586		IPPROTO_BEETPH = 0x5e
587		IPPROTO_COMP = 0x6c
588		IPPROTO_DCCP = 0x21
589		IPPROTO_DSTOPTS = 0x3c
590		IPPROTO_EGP = 0x8
591		IPPROTO_ENCAP = 0x62
592		IPPROTO_ESP = 0x32
593		IPPROTO_FRAGMENT = 0x2c
594		IPPROTO_GRE = 0x2f
595		IPPROTO_HOPOPTS = 0x0
596		IPPROTO_ICMP = 0x1
597		IPPROTO_ICMPV6 = 0x3a
598		IPPROTO_IDP = 0x16
599		IPPROTO_IGMP = 0x2
600		IPPROTO_IP = 0x0
601		IPPROTO_IPIP = 0x4
602		IPPROTO_IPV6 = 0x29
603		IPPROTO_MH = 0x87
604		IPPROTO_MPLS = 0x89
605		IPPROTO_MTP = 0x5c
606		IPPROTO_NONE = 0x3b
607		IPPROTO_PIM = 0x67
608		IPPROTO_PUP = 0xc
609		IPPROTO_RAW = 0xff
610		IPPROTO_ROUTING = 0x2b
611		IPPROTO_RSVP = 0x2e
612		IPPROTO_SCTP = 0x84
613		IPPROTO_TCP = 0x6
614		IPPROTO_TP = 0x1d
615		IPPROTO_UDP = 0x11
616		IPPROTO_UDPLITE = 0x88
617		IPV6_2292DSTOPTS = 0x4
618		IPV6_2292HOPLIMIT = 0x8
619		IPV6_2292HOPOPTS = 0x3
620		IPV6_2292PKTINFO = 0x2
621		IPV6_2292PKTOPTIONS = 0x6
622		IPV6_2292RTHDR = 0x5
623		IPV6_ADDRFORM = 0x1
624		IPV6_ADD_MEMBERSHIP = 0x14
625		IPV6_AUTHHDR = 0xa
626		IPV6_CHECKSUM = 0x7
627		IPV6_DONTFRAG = 0x3e
628		IPV6_DROP_MEMBERSHIP = 0x15
629		IPV6_DSTOPTS = 0x3b
630		IPV6_HDRINCL = 0x24
631		IPV6_HOPLIMIT = 0x34
632		IPV6_HOPOPTS = 0x36
633		IPV6_IPSEC_POLICY = 0x22
634		IPV6_JOIN_ANYCAST = 0x1b
635		IPV6_JOIN_GROUP = 0x14
636		IPV6_LEAVE_ANYCAST = 0x1c
637		IPV6_LEAVE_GROUP = 0x15
638		IPV6_MTU = 0x18
639		IPV6_MTU_DISCOVER = 0x17
640		IPV6_MULTICAST_HOPS = 0x12
641		IPV6_MULTICAST_IF = 0x11
642		IPV6_MULTICAST_LOOP = 0x13
643		IPV6_NEXTHOP = 0x9
644		IPV6_PATHMTU = 0x3d
645		IPV6_PKTINFO = 0x32
646		IPV6_PMTUDISC_DO = 0x2
647		IPV6_PMTUDISC_DONT = 0x0
648		IPV6_PMTUDISC_INTERFACE = 0x4
649		IPV6_PMTUDISC_OMIT = 0x5
650		IPV6_PMTUDISC_PROBE = 0x3
651		IPV6_PMTUDISC_WANT = 0x1
652		IPV6_RECVDSTOPTS = 0x3a
653		IPV6_RECVERR = 0x19
654		IPV6_RECVHOPLIMIT = 0x33
655		IPV6_RECVHOPOPTS = 0x35
656		IPV6_RECVPATHMTU = 0x3c
657		IPV6_RECVPKTINFO = 0x31
658		IPV6_RECVRTHDR = 0x38
659		IPV6_RECVTCLASS = 0x42
660		IPV6_ROUTER_ALERT = 0x16
661		IPV6_RTHDR = 0x39
662		IPV6_RTHDRDSTOPTS = 0x37
663		IPV6_RTHDR_LOOSE = 0x0
664		IPV6_RTHDR_STRICT = 0x1
665		IPV6_RTHDR_TYPE_0 = 0x0
666		IPV6_RXDSTOPTS = 0x3b
667		IPV6_RXHOPOPTS = 0x36
668		IPV6_TCLASS = 0x43
669		IPV6_UNICAST_HOPS = 0x10
670		IPV6_V6ONLY = 0x1a
671		IPV6_XFRM_POLICY = 0x23
672		IP_ADD_MEMBERSHIP = 0x23
673		IP_ADD_SOURCE_MEMBERSHIP = 0x27
674		IP_BIND_ADDRESS_NO_PORT = 0x18
675		IP_BLOCK_SOURCE = 0x26
676		IP_CHECKSUM = 0x17
677		IP_DEFAULT_MULTICAST_LOOP = 0x1
678		IP_DEFAULT_MULTICAST_TTL = 0x1
679		IP_DF = 0x4000
680		IP_DROP_MEMBERSHIP = 0x24
681		IP_DROP_SOURCE_MEMBERSHIP = 0x28
682		IP_FREEBIND = 0xf
683		IP_HDRINCL = 0x3
684		IP_IPSEC_POLICY = 0x10
685		IP_MAXPACKET = 0xffff
686		IP_MAX_MEMBERSHIPS = 0x14
687		IP_MF = 0x2000
688		IP_MINTTL = 0x15
689		IP_MSFILTER = 0x29
690		IP_MSS = 0x240
691		IP_MTU = 0xe
692		IP_MTU_DISCOVER = 0xa
693		IP_MULTICAST_ALL = 0x31
694		IP_MULTICAST_IF = 0x20
695		IP_MULTICAST_LOOP = 0x22
696		IP_MULTICAST_TTL = 0x21
697		IP_NODEFRAG = 0x16
698		IP_OFFMASK = 0x1fff
699		IP_OPTIONS = 0x4
700		IP_ORIGDSTADDR = 0x14
701		IP_PASSSEC = 0x12
702		IP_PKTINFO = 0x8
703		IP_PKTOPTIONS = 0x9
704		IP_PMTUDISC = 0xa
705		IP_PMTUDISC_DO = 0x2
706		IP_PMTUDISC_DONT = 0x0
707		IP_PMTUDISC_INTERFACE = 0x4
708		IP_PMTUDISC_OMIT = 0x5
709		IP_PMTUDISC_PROBE = 0x3
710		IP_PMTUDISC_WANT = 0x1
711		IP_RECVERR = 0xb
712		IP_RECVOPTS = 0x6
713		IP_RECVORIGDSTADDR = 0x14
714		IP_RECVRETOPTS = 0x7
715		IP_RECVTOS = 0xd
716		IP_RECVTTL = 0xc
717		IP_RETOPTS = 0x7
718		IP_RF = 0x8000
719		IP_ROUTER_ALERT = 0x5
720		IP_TOS = 0x1
721		IP_TRANSPARENT = 0x13
722		IP_TTL = 0x2
723		IP_UNBLOCK_SOURCE = 0x25
724		IP_UNICAST_IF = 0x32
725		IP_XFRM_POLICY = 0x11
726		ISIG = 0x1
727		ISTRIP = 0x20
728		IUCLC = 0x200
729		IUTF8 = 0x4000
730		IXANY = 0x800
731		IXOFF = 0x1000
732		IXON = 0x400
733		LINUX_REBOOT_CMD_CAD_OFF = 0x0
734		LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef
735		LINUX_REBOOT_CMD_HALT = 0xcdef0123
736		LINUX_REBOOT_CMD_KEXEC = 0x45584543
737		LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc
738		LINUX_REBOOT_CMD_RESTART = 0x1234567
739		LINUX_REBOOT_CMD_RESTART2 = 0xa1b2c3d4
740		LINUX_REBOOT_CMD_SW_SUSPEND = 0xd000fce2
741		LINUX_REBOOT_MAGIC1 = 0xfee1dead
742		LINUX_REBOOT_MAGIC2 = 0x28121969
743		LOCK_EX = 0x2
744		LOCK_NB = 0x4
745		LOCK_SH = 0x1
746		LOCK_UN = 0x8
747		MADV_DODUMP = 0x11
748		MADV_DOFORK = 0xb
749		MADV_DONTDUMP = 0x10
750		MADV_DONTFORK = 0xa
751		MADV_DONTNEED = 0x4
752		MADV_FREE = 0x8
753		MADV_HUGEPAGE = 0xe
754		MADV_HWPOISON = 0x64
755		MADV_MERGEABLE = 0xc
756		MADV_NOHUGEPAGE = 0xf
757		MADV_NORMAL = 0x0
758		MADV_RANDOM = 0x1
759		MADV_REMOVE = 0x9
760		MADV_SEQUENTIAL = 0x2
761		MADV_UNMERGEABLE = 0xd
762		MADV_WILLNEED = 0x3
763		MAP_ANON = 0x20
764		MAP_ANONYMOUS = 0x20
765		MAP_DENYWRITE = 0x800
766		MAP_EXECUTABLE = 0x1000
767		MAP_FILE = 0x0
768		MAP_FIXED = 0x10
769		MAP_GROWSDOWN = 0x200
770		MAP_HUGETLB = 0x40000
771		MAP_HUGE_MASK = 0x3f
772		MAP_HUGE_SHIFT = 0x1a
773		MAP_LOCKED = 0x100
774		MAP_NONBLOCK = 0x10000
775		MAP_NORESERVE = 0x40
776		MAP_POPULATE = 0x8000
777		MAP_PRIVATE = 0x2
778		MAP_RENAME = 0x20
779		MAP_SHARED = 0x1
780		MAP_STACK = 0x20000
781		MAP_TYPE = 0xf
782		MCL_CURRENT = 0x2000
783		MCL_FUTURE = 0x4000
784		MCL_ONFAULT = 0x8000
785		MNT_DETACH = 0x2
786		MNT_EXPIRE = 0x4
787		MNT_FORCE = 0x1
788		MSG_BATCH = 0x40000
789		MSG_CMSG_CLOEXEC = 0x40000000
790		MSG_CONFIRM = 0x800
791		MSG_CTRUNC = 0x8
792		MSG_DONTROUTE = 0x4
793		MSG_DONTWAIT = 0x40
794		MSG_EOR = 0x80
795		MSG_ERRQUEUE = 0x2000
796		MSG_FASTOPEN = 0x20000000
797		MSG_FIN = 0x200
798		MSG_MORE = 0x8000
799		MSG_NOSIGNAL = 0x4000
800		MSG_OOB = 0x1
801		MSG_PEEK = 0x2
802		MSG_PROXY = 0x10
803		MSG_RST = 0x1000
804		MSG_SYN = 0x400
805		MSG_TRUNC = 0x20
806		MSG_TRYHARD = 0x4
807		MSG_WAITALL = 0x100
808		MSG_WAITFORONE = 0x10000
809		MS_ACTIVE = 0x40000000
810		MS_ASYNC = 0x1
811		MS_BIND = 0x1000
812		MS_DIRSYNC = 0x80
813		MS_INVALIDATE = 0x2
814		MS_I_VERSION = 0x800000
815		MS_KERNMOUNT = 0x400000
816		MS_LAZYTIME = 0x2000000
817		MS_MANDLOCK = 0x40
818		MS_MGC_MSK = 0xffff0000
819		MS_MGC_VAL = 0xc0ed0000
820		MS_MOVE = 0x2000
821		MS_NOATIME = 0x400
822		MS_NODEV = 0x4
823		MS_NODIRATIME = 0x800
824		MS_NOEXEC = 0x8
825		MS_NOSUID = 0x2
826		MS_NOUSER = -0x80000000
827		MS_POSIXACL = 0x10000
828		MS_PRIVATE = 0x40000
829		MS_RDONLY = 0x1
830		MS_REC = 0x4000
831		MS_RELATIME = 0x200000
832		MS_REMOUNT = 0x20
833		MS_RMT_MASK = 0x2800051
834		MS_SHARED = 0x100000
835		MS_SILENT = 0x8000
836		MS_SLAVE = 0x80000
837		MS_STRICTATIME = 0x1000000
838		MS_SYNC = 0x4
839		MS_SYNCHRONOUS = 0x10
840		MS_UNBINDABLE = 0x20000
841		NAME_MAX = 0xff
842		NETLINK_ADD_MEMBERSHIP = 0x1
843		NETLINK_AUDIT = 0x9
844		NETLINK_BROADCAST_ERROR = 0x4
845		NETLINK_CAP_ACK = 0xa
846		NETLINK_CONNECTOR = 0xb
847		NETLINK_CRYPTO = 0x15
848		NETLINK_DNRTMSG = 0xe
849		NETLINK_DROP_MEMBERSHIP = 0x2
850		NETLINK_ECRYPTFS = 0x13
851		NETLINK_FIB_LOOKUP = 0xa
852		NETLINK_FIREWALL = 0x3
853		NETLINK_GENERIC = 0x10
854		NETLINK_INET_DIAG = 0x4
855		NETLINK_IP6_FW = 0xd
856		NETLINK_ISCSI = 0x8
857		NETLINK_KOBJECT_UEVENT = 0xf
858		NETLINK_LISTEN_ALL_NSID = 0x8
859		NETLINK_LIST_MEMBERSHIPS = 0x9
860		NETLINK_NETFILTER = 0xc
861		NETLINK_NFLOG = 0x5
862		NETLINK_NO_ENOBUFS = 0x5
863		NETLINK_PKTINFO = 0x3
864		NETLINK_RDMA = 0x14
865		NETLINK_ROUTE = 0x0
866		NETLINK_RX_RING = 0x6
867		NETLINK_SCSITRANSPORT = 0x12
868		NETLINK_SELINUX = 0x7
869		NETLINK_SOCK_DIAG = 0x4
870		NETLINK_TX_RING = 0x7
871		NETLINK_UNUSED = 0x1
872		NETLINK_USERSOCK = 0x2
873		NETLINK_XFRM = 0x6
874		NL0 = 0x0
875		NL1 = 0x100
876		NLA_ALIGNTO = 0x4
877		NLA_F_NESTED = 0x8000
878		NLA_F_NET_BYTEORDER = 0x4000
879		NLA_HDRLEN = 0x4
880		NLDLY = 0x100
881		NLMSG_ALIGNTO = 0x4
882		NLMSG_DONE = 0x3
883		NLMSG_ERROR = 0x2
884		NLMSG_HDRLEN = 0x10
885		NLMSG_MIN_TYPE = 0x10
886		NLMSG_NOOP = 0x1
887		NLMSG_OVERRUN = 0x4
888		NLM_F_ACK = 0x4
889		NLM_F_APPEND = 0x800
890		NLM_F_ATOMIC = 0x400
891		NLM_F_CREATE = 0x400
892		NLM_F_DUMP = 0x300
893		NLM_F_DUMP_FILTERED = 0x20
894		NLM_F_DUMP_INTR = 0x10
895		NLM_F_ECHO = 0x8
896		NLM_F_EXCL = 0x200
897		NLM_F_MATCH = 0x200
898		NLM_F_MULTI = 0x2
899		NLM_F_REPLACE = 0x100
900		NLM_F_REQUEST = 0x1
901		NLM_F_ROOT = 0x100
902		NOFLSH = 0x80
903		OCRNL = 0x8
904		OFDEL = 0x80
905		OFILL = 0x40
906		OLCUC = 0x2
907		ONLCR = 0x4
908		ONLRET = 0x20
909		ONOCR = 0x10
910		OPOST = 0x1
911		O_ACCMODE = 0x3
912		O_APPEND = 0x8
913		O_ASYNC = 0x40
914		O_CLOEXEC = 0x400000
915		O_CREAT = 0x200
916		O_DIRECT = 0x100000
917		O_DIRECTORY = 0x10000
918		O_DSYNC = 0x2000
919		O_EXCL = 0x800
920		O_FSYNC = 0x802000
921		O_LARGEFILE = 0x0
922		O_NDELAY = 0x4004
923		O_NOATIME = 0x200000
924		O_NOCTTY = 0x8000
925		O_NOFOLLOW = 0x20000
926		O_NONBLOCK = 0x4000
927		O_PATH = 0x1000000
928		O_RDONLY = 0x0
929		O_RDWR = 0x2
930		O_RSYNC = 0x802000
931		O_SYNC = 0x802000
932		O_TMPFILE = 0x2010000
933		O_TRUNC = 0x400
934		O_WRONLY = 0x1
935		PACKET_ADD_MEMBERSHIP = 0x1
936		PACKET_AUXDATA = 0x8
937		PACKET_BROADCAST = 0x1
938		PACKET_COPY_THRESH = 0x7
939		PACKET_DROP_MEMBERSHIP = 0x2
940		PACKET_FANOUT = 0x12
941		PACKET_FANOUT_CBPF = 0x6
942		PACKET_FANOUT_CPU = 0x2
943		PACKET_FANOUT_DATA = 0x16
944		PACKET_FANOUT_EBPF = 0x7
945		PACKET_FANOUT_FLAG_DEFRAG = 0x8000
946		PACKET_FANOUT_FLAG_ROLLOVER = 0x1000
947		PACKET_FANOUT_HASH = 0x0
948		PACKET_FANOUT_LB = 0x1
949		PACKET_FANOUT_QM = 0x5
950		PACKET_FANOUT_RND = 0x4
951		PACKET_FANOUT_ROLLOVER = 0x3
952		PACKET_FASTROUTE = 0x6
953		PACKET_HDRLEN = 0xb
954		PACKET_HOST = 0x0
955		PACKET_KERNEL = 0x7
956		PACKET_LOOPBACK = 0x5
957		PACKET_LOSS = 0xe
958		PACKET_MR_ALLMULTI = 0x2
959		PACKET_MR_MULTICAST = 0x0
960		PACKET_MR_PROMISC = 0x1
961		PACKET_MR_UNICAST = 0x3
962		PACKET_MULTICAST = 0x2
963		PACKET_ORIGDEV = 0x9
964		PACKET_OTHERHOST = 0x3
965		PACKET_OUTGOING = 0x4
966		PACKET_QDISC_BYPASS = 0x14
967		PACKET_RECV_OUTPUT = 0x3
968		PACKET_RESERVE = 0xc
969		PACKET_ROLLOVER_STATS = 0x15
970		PACKET_RX_RING = 0x5
971		PACKET_STATISTICS = 0x6
972		PACKET_TIMESTAMP = 0x11
973		PACKET_TX_HAS_OFF = 0x13
974		PACKET_TX_RING = 0xd
975		PACKET_TX_TIMESTAMP = 0x10
976		PACKET_USER = 0x6
977		PACKET_VERSION = 0xa
978		PACKET_VNET_HDR = 0xf
979		PARENB = 0x100
980		PARITY_CRC16_PR0 = 0x2
981		PARITY_CRC16_PR0_CCITT = 0x4
982		PARITY_CRC16_PR1 = 0x3
983		PARITY_CRC16_PR1_CCITT = 0x5
984		PARITY_CRC32_PR0_CCITT = 0x6
985		PARITY_CRC32_PR1_CCITT = 0x7
986		PARITY_DEFAULT = 0x0
987		PARITY_NONE = 0x1
988		PARMRK = 0x8
989		PARODD = 0x200
990		PENDIN = 0x4000
991		PRIO_PGRP = 0x1
992		PRIO_PROCESS = 0x0
993		PRIO_USER = 0x2
994		PROT_EXEC = 0x4
995		PROT_GROWSDOWN = 0x1000000
996		PROT_GROWSUP = 0x2000000
997		PROT_NONE = 0x0
998		PROT_READ = 0x1
999		PROT_WRITE = 0x2
1000		PR_CAPBSET_DROP = 0x18
1001		PR_CAPBSET_READ = 0x17
1002		PR_CAP_AMBIENT = 0x2f
1003		PR_CAP_AMBIENT_CLEAR_ALL = 0x4
1004		PR_CAP_AMBIENT_IS_SET = 0x1
1005		PR_CAP_AMBIENT_LOWER = 0x3
1006		PR_CAP_AMBIENT_RAISE = 0x2
1007		PR_ENDIAN_BIG = 0x0
1008		PR_ENDIAN_LITTLE = 0x1
1009		PR_ENDIAN_PPC_LITTLE = 0x2
1010		PR_FPEMU_NOPRINT = 0x1
1011		PR_FPEMU_SIGFPE = 0x2
1012		PR_FP_EXC_ASYNC = 0x2
1013		PR_FP_EXC_DISABLED = 0x0
1014		PR_FP_EXC_DIV = 0x10000
1015		PR_FP_EXC_INV = 0x100000
1016		PR_FP_EXC_NONRECOV = 0x1
1017		PR_FP_EXC_OVF = 0x20000
1018		PR_FP_EXC_PRECISE = 0x3
1019		PR_FP_EXC_RES = 0x80000
1020		PR_FP_EXC_SW_ENABLE = 0x80
1021		PR_FP_EXC_UND = 0x40000
1022		PR_FP_MODE_FR = 0x1
1023		PR_FP_MODE_FRE = 0x2
1024		PR_GET_CHILD_SUBREAPER = 0x25
1025		PR_GET_DUMPABLE = 0x3
1026		PR_GET_ENDIAN = 0x13
1027		PR_GET_FPEMU = 0x9
1028		PR_GET_FPEXC = 0xb
1029		PR_GET_FP_MODE = 0x2e
1030		PR_GET_KEEPCAPS = 0x7
1031		PR_GET_NAME = 0x10
1032		PR_GET_NO_NEW_PRIVS = 0x27
1033		PR_GET_PDEATHSIG = 0x2
1034		PR_GET_SECCOMP = 0x15
1035		PR_GET_SECUREBITS = 0x1b
1036		PR_GET_THP_DISABLE = 0x2a
1037		PR_GET_TID_ADDRESS = 0x28
1038		PR_GET_TIMERSLACK = 0x1e
1039		PR_GET_TIMING = 0xd
1040		PR_GET_TSC = 0x19
1041		PR_GET_UNALIGN = 0x5
1042		PR_MCE_KILL = 0x21
1043		PR_MCE_KILL_CLEAR = 0x0
1044		PR_MCE_KILL_DEFAULT = 0x2
1045		PR_MCE_KILL_EARLY = 0x1
1046		PR_MCE_KILL_GET = 0x22
1047		PR_MCE_KILL_LATE = 0x0
1048		PR_MCE_KILL_SET = 0x1
1049		PR_MPX_DISABLE_MANAGEMENT = 0x2c
1050		PR_MPX_ENABLE_MANAGEMENT = 0x2b
1051		PR_SET_CHILD_SUBREAPER = 0x24
1052		PR_SET_DUMPABLE = 0x4
1053		PR_SET_ENDIAN = 0x14
1054		PR_SET_FPEMU = 0xa
1055		PR_SET_FPEXC = 0xc
1056		PR_SET_FP_MODE = 0x2d
1057		PR_SET_KEEPCAPS = 0x8
1058		PR_SET_MM = 0x23
1059		PR_SET_MM_ARG_END = 0x9
1060		PR_SET_MM_ARG_START = 0x8
1061		PR_SET_MM_AUXV = 0xc
1062		PR_SET_MM_BRK = 0x7
1063		PR_SET_MM_END_CODE = 0x2
1064		PR_SET_MM_END_DATA = 0x4
1065		PR_SET_MM_ENV_END = 0xb
1066		PR_SET_MM_ENV_START = 0xa
1067		PR_SET_MM_EXE_FILE = 0xd
1068		PR_SET_MM_MAP = 0xe
1069		PR_SET_MM_MAP_SIZE = 0xf
1070		PR_SET_MM_START_BRK = 0x6
1071		PR_SET_MM_START_CODE = 0x1
1072		PR_SET_MM_START_DATA = 0x3
1073		PR_SET_MM_START_STACK = 0x5
1074		PR_SET_NAME = 0xf
1075		PR_SET_NO_NEW_PRIVS = 0x26
1076		PR_SET_PDEATHSIG = 0x1
1077		PR_SET_PTRACER = 0x59616d61
1078		PR_SET_PTRACER_ANY = -0x1
1079		PR_SET_SECCOMP = 0x16
1080		PR_SET_SECUREBITS = 0x1c
1081		PR_SET_THP_DISABLE = 0x29
1082		PR_SET_TIMERSLACK = 0x1d
1083		PR_SET_TIMING = 0xe
1084		PR_SET_TSC = 0x1a
1085		PR_SET_UNALIGN = 0x6
1086		PR_TASK_PERF_EVENTS_DISABLE = 0x1f
1087		PR_TASK_PERF_EVENTS_ENABLE = 0x20
1088		PR_TIMING_STATISTICAL = 0x0
1089		PR_TIMING_TIMESTAMP = 0x1
1090		PR_TSC_ENABLE = 0x1
1091		PR_TSC_SIGSEGV = 0x2
1092		PR_UNALIGN_NOPRINT = 0x1
1093		PR_UNALIGN_SIGBUS = 0x2
1094		PTRACE_ATTACH = 0x10
1095		PTRACE_CONT = 0x7
1096		PTRACE_DETACH = 0x11
1097		PTRACE_EVENT_CLONE = 0x3
1098		PTRACE_EVENT_EXEC = 0x4
1099		PTRACE_EVENT_EXIT = 0x6
1100		PTRACE_EVENT_FORK = 0x1
1101		PTRACE_EVENT_SECCOMP = 0x7
1102		PTRACE_EVENT_STOP = 0x80
1103		PTRACE_EVENT_VFORK = 0x2
1104		PTRACE_EVENT_VFORK_DONE = 0x5
1105		PTRACE_GETEVENTMSG = 0x4201
1106		PTRACE_GETFPAREGS = 0x14
1107		PTRACE_GETFPREGS = 0xe
1108		PTRACE_GETFPREGS64 = 0x19
1109		PTRACE_GETREGS = 0xc
1110		PTRACE_GETREGS64 = 0x16
1111		PTRACE_GETREGSET = 0x4204
1112		PTRACE_GETSIGINFO = 0x4202
1113		PTRACE_GETSIGMASK = 0x420a
1114		PTRACE_INTERRUPT = 0x4207
1115		PTRACE_KILL = 0x8
1116		PTRACE_LISTEN = 0x4208
1117		PTRACE_O_EXITKILL = 0x100000
1118		PTRACE_O_MASK = 0x3000ff
1119		PTRACE_O_SUSPEND_SECCOMP = 0x200000
1120		PTRACE_O_TRACECLONE = 0x8
1121		PTRACE_O_TRACEEXEC = 0x10
1122		PTRACE_O_TRACEEXIT = 0x40
1123		PTRACE_O_TRACEFORK = 0x2
1124		PTRACE_O_TRACESECCOMP = 0x80
1125		PTRACE_O_TRACESYSGOOD = 0x1
1126		PTRACE_O_TRACEVFORK = 0x4
1127		PTRACE_O_TRACEVFORKDONE = 0x20
1128		PTRACE_PEEKDATA = 0x2
1129		PTRACE_PEEKSIGINFO = 0x4209
1130		PTRACE_PEEKSIGINFO_SHARED = 0x1
1131		PTRACE_PEEKTEXT = 0x1
1132		PTRACE_PEEKUSR = 0x3
1133		PTRACE_POKEDATA = 0x5
1134		PTRACE_POKETEXT = 0x4
1135		PTRACE_POKEUSR = 0x6
1136		PTRACE_READDATA = 0x10
1137		PTRACE_READTEXT = 0x12
1138		PTRACE_SECCOMP_GET_FILTER = 0x420c
1139		PTRACE_SEIZE = 0x4206
1140		PTRACE_SETFPAREGS = 0x15
1141		PTRACE_SETFPREGS = 0xf
1142		PTRACE_SETFPREGS64 = 0x1a
1143		PTRACE_SETOPTIONS = 0x4200
1144		PTRACE_SETREGS = 0xd
1145		PTRACE_SETREGS64 = 0x17
1146		PTRACE_SETREGSET = 0x4205
1147		PTRACE_SETSIGINFO = 0x4203
1148		PTRACE_SETSIGMASK = 0x420b
1149		PTRACE_SINGLESTEP = 0x9
1150		PTRACE_SPARC_DETACH = 0xb
1151		PTRACE_SYSCALL = 0x18
1152		PTRACE_TRACEME = 0x0
1153		PTRACE_WRITEDATA = 0x11
1154		PTRACE_WRITETEXT = 0x13
1155		PT_FP = 0x48
1156		PT_G0 = 0x10
1157		PT_G1 = 0x14
1158		PT_G2 = 0x18
1159		PT_G3 = 0x1c
1160		PT_G4 = 0x20
1161		PT_G5 = 0x24
1162		PT_G6 = 0x28
1163		PT_G7 = 0x2c
1164		PT_I0 = 0x30
1165		PT_I1 = 0x34
1166		PT_I2 = 0x38
1167		PT_I3 = 0x3c
1168		PT_I4 = 0x40
1169		PT_I5 = 0x44
1170		PT_I6 = 0x48
1171		PT_I7 = 0x4c
1172		PT_NPC = 0x8
1173		PT_PC = 0x4
1174		PT_PSR = 0x0
1175		PT_REGS_MAGIC = 0x57ac6c00
1176		PT_TNPC = 0x90
1177		PT_TPC = 0x88
1178		PT_TSTATE = 0x80
1179		PT_V9_FP = 0x70
1180		PT_V9_G0 = 0x0
1181		PT_V9_G1 = 0x8
1182		PT_V9_G2 = 0x10
1183		PT_V9_G3 = 0x18
1184		PT_V9_G4 = 0x20
1185		PT_V9_G5 = 0x28
1186		PT_V9_G6 = 0x30
1187		PT_V9_G7 = 0x38
1188		PT_V9_I0 = 0x40
1189		PT_V9_I1 = 0x48
1190		PT_V9_I2 = 0x50
1191		PT_V9_I3 = 0x58
1192		PT_V9_I4 = 0x60
1193		PT_V9_I5 = 0x68
1194		PT_V9_I6 = 0x70
1195		PT_V9_I7 = 0x78
1196		PT_V9_MAGIC = 0x9c
1197		PT_V9_TNPC = 0x90
1198		PT_V9_TPC = 0x88
1199		PT_V9_TSTATE = 0x80
1200		PT_V9_Y = 0x98
1201		PT_WIM = 0x10
1202		PT_Y = 0xc
1203		RLIMIT_AS = 0x9
1204		RLIMIT_CORE = 0x4
1205		RLIMIT_CPU = 0x0
1206		RLIMIT_DATA = 0x2
1207		RLIMIT_FSIZE = 0x1
1208		RLIMIT_NOFILE = 0x6
1209		RLIMIT_STACK = 0x3
1210		RLIM_INFINITY = -0x1
1211		RTAX_ADVMSS = 0x8
1212		RTAX_CC_ALGO = 0x10
1213		RTAX_CWND = 0x7
1214		RTAX_FEATURES = 0xc
1215		RTAX_FEATURE_ALLFRAG = 0x8
1216		RTAX_FEATURE_ECN = 0x1
1217		RTAX_FEATURE_MASK = 0xf
1218		RTAX_FEATURE_SACK = 0x2
1219		RTAX_FEATURE_TIMESTAMP = 0x4
1220		RTAX_HOPLIMIT = 0xa
1221		RTAX_INITCWND = 0xb
1222		RTAX_INITRWND = 0xe
1223		RTAX_LOCK = 0x1
1224		RTAX_MAX = 0x10
1225		RTAX_MTU = 0x2
1226		RTAX_QUICKACK = 0xf
1227		RTAX_REORDERING = 0x9
1228		RTAX_RTO_MIN = 0xd
1229		RTAX_RTT = 0x4
1230		RTAX_RTTVAR = 0x5
1231		RTAX_SSTHRESH = 0x6
1232		RTAX_UNSPEC = 0x0
1233		RTAX_WINDOW = 0x3
1234		RTA_ALIGNTO = 0x4
1235		RTA_MAX = 0x18
1236		RTCF_DIRECTSRC = 0x4000000
1237		RTCF_DOREDIRECT = 0x1000000
1238		RTCF_LOG = 0x2000000
1239		RTCF_MASQ = 0x400000
1240		RTCF_NAT = 0x800000
1241		RTCF_VALVE = 0x200000
1242		RTF_ADDRCLASSMASK = 0xf8000000
1243		RTF_ADDRCONF = 0x40000
1244		RTF_ALLONLINK = 0x20000
1245		RTF_BROADCAST = 0x10000000
1246		RTF_CACHE = 0x1000000
1247		RTF_DEFAULT = 0x10000
1248		RTF_DYNAMIC = 0x10
1249		RTF_FLOW = 0x2000000
1250		RTF_GATEWAY = 0x2
1251		RTF_HOST = 0x4
1252		RTF_INTERFACE = 0x40000000
1253		RTF_IRTT = 0x100
1254		RTF_LINKRT = 0x100000
1255		RTF_LOCAL = 0x80000000
1256		RTF_MODIFIED = 0x20
1257		RTF_MSS = 0x40
1258		RTF_MTU = 0x40
1259		RTF_MULTICAST = 0x20000000
1260		RTF_NAT = 0x8000000
1261		RTF_NOFORWARD = 0x1000
1262		RTF_NONEXTHOP = 0x200000
1263		RTF_NOPMTUDISC = 0x4000
1264		RTF_POLICY = 0x4000000
1265		RTF_REINSTATE = 0x8
1266		RTF_REJECT = 0x200
1267		RTF_STATIC = 0x400
1268		RTF_THROW = 0x2000
1269		RTF_UP = 0x1
1270		RTF_WINDOW = 0x80
1271		RTF_XRESOLVE = 0x800
1272		RTM_BASE = 0x10
1273		RTM_DELACTION = 0x31
1274		RTM_DELADDR = 0x15
1275		RTM_DELADDRLABEL = 0x49
1276		RTM_DELLINK = 0x11
1277		RTM_DELMDB = 0x55
1278		RTM_DELNEIGH = 0x1d
1279		RTM_DELNSID = 0x59
1280		RTM_DELQDISC = 0x25
1281		RTM_DELROUTE = 0x19
1282		RTM_DELRULE = 0x21
1283		RTM_DELTCLASS = 0x29
1284		RTM_DELTFILTER = 0x2d
1285		RTM_F_CLONED = 0x200
1286		RTM_F_EQUALIZE = 0x400
1287		RTM_F_LOOKUP_TABLE = 0x1000
1288		RTM_F_NOTIFY = 0x100
1289		RTM_F_PREFIX = 0x800
1290		RTM_GETACTION = 0x32
1291		RTM_GETADDR = 0x16
1292		RTM_GETADDRLABEL = 0x4a
1293		RTM_GETANYCAST = 0x3e
1294		RTM_GETDCB = 0x4e
1295		RTM_GETLINK = 0x12
1296		RTM_GETMDB = 0x56
1297		RTM_GETMULTICAST = 0x3a
1298		RTM_GETNEIGH = 0x1e
1299		RTM_GETNEIGHTBL = 0x42
1300		RTM_GETNETCONF = 0x52
1301		RTM_GETNSID = 0x5a
1302		RTM_GETQDISC = 0x26
1303		RTM_GETROUTE = 0x1a
1304		RTM_GETRULE = 0x22
1305		RTM_GETSTATS = 0x5e
1306		RTM_GETTCLASS = 0x2a
1307		RTM_GETTFILTER = 0x2e
1308		RTM_MAX = 0x5f
1309		RTM_NEWACTION = 0x30
1310		RTM_NEWADDR = 0x14
1311		RTM_NEWADDRLABEL = 0x48
1312		RTM_NEWLINK = 0x10
1313		RTM_NEWMDB = 0x54
1314		RTM_NEWNDUSEROPT = 0x44
1315		RTM_NEWNEIGH = 0x1c
1316		RTM_NEWNEIGHTBL = 0x40
1317		RTM_NEWNETCONF = 0x50
1318		RTM_NEWNSID = 0x58
1319		RTM_NEWPREFIX = 0x34
1320		RTM_NEWQDISC = 0x24
1321		RTM_NEWROUTE = 0x18
1322		RTM_NEWRULE = 0x20
1323		RTM_NEWSTATS = 0x5c
1324		RTM_NEWTCLASS = 0x28
1325		RTM_NEWTFILTER = 0x2c
1326		RTM_NR_FAMILIES = 0x14
1327		RTM_NR_MSGTYPES = 0x50
1328		RTM_SETDCB = 0x4f
1329		RTM_SETLINK = 0x13
1330		RTM_SETNEIGHTBL = 0x43
1331		RTNH_ALIGNTO = 0x4
1332		RTNH_COMPARE_MASK = 0x11
1333		RTNH_F_DEAD = 0x1
1334		RTNH_F_LINKDOWN = 0x10
1335		RTNH_F_OFFLOAD = 0x8
1336		RTNH_F_ONLINK = 0x4
1337		RTNH_F_PERVASIVE = 0x2
1338		RTN_MAX = 0xb
1339		RTPROT_BABEL = 0x2a
1340		RTPROT_BIRD = 0xc
1341		RTPROT_BOOT = 0x3
1342		RTPROT_DHCP = 0x10
1343		RTPROT_DNROUTED = 0xd
1344		RTPROT_GATED = 0x8
1345		RTPROT_KERNEL = 0x2
1346		RTPROT_MROUTED = 0x11
1347		RTPROT_MRT = 0xa
1348		RTPROT_NTK = 0xf
1349		RTPROT_RA = 0x9
1350		RTPROT_REDIRECT = 0x1
1351		RTPROT_STATIC = 0x4
1352		RTPROT_UNSPEC = 0x0
1353		RTPROT_XORP = 0xe
1354		RTPROT_ZEBRA = 0xb
1355		RT_CLASS_DEFAULT = 0xfd
1356		RT_CLASS_LOCAL = 0xff
1357		RT_CLASS_MAIN = 0xfe
1358		RT_CLASS_MAX = 0xff
1359		RT_CLASS_UNSPEC = 0x0
1360		RUSAGE_CHILDREN = -0x1
1361		RUSAGE_SELF = 0x0
1362		RUSAGE_THREAD = 0x1
1363		SCM_CREDENTIALS = 0x2
1364		SCM_RIGHTS = 0x1
1365		SCM_TIMESTAMP = 0x1d
1366		SCM_TIMESTAMPING = 0x23
1367		SCM_TIMESTAMPNS = 0x21
1368		SCM_WIFI_STATUS = 0x25
1369		SHUT_RD = 0x0
1370		SHUT_RDWR = 0x2
1371		SHUT_WR = 0x1
1372		SIOCADDDLCI = 0x8980
1373		SIOCADDMULTI = 0x8931
1374		SIOCADDRT = 0x890b
1375		SIOCATMARK = 0x8905
1376		SIOCBONDCHANGEACTIVE = 0x8995
1377		SIOCBONDENSLAVE = 0x8990
1378		SIOCBONDINFOQUERY = 0x8994
1379		SIOCBONDRELEASE = 0x8991
1380		SIOCBONDSETHWADDR = 0x8992
1381		SIOCBONDSLAVEINFOQUERY = 0x8993
1382		SIOCBRADDBR = 0x89a0
1383		SIOCBRADDIF = 0x89a2
1384		SIOCBRDELBR = 0x89a1
1385		SIOCBRDELIF = 0x89a3
1386		SIOCDARP = 0x8953
1387		SIOCDELDLCI = 0x8981
1388		SIOCDELMULTI = 0x8932
1389		SIOCDELRT = 0x890c
1390		SIOCDEVPRIVATE = 0x89f0
1391		SIOCDIFADDR = 0x8936
1392		SIOCDRARP = 0x8960
1393		SIOCETHTOOL = 0x8946
1394		SIOCGARP = 0x8954
1395		SIOCGHWTSTAMP = 0x89b1
1396		SIOCGIFADDR = 0x8915
1397		SIOCGIFBR = 0x8940
1398		SIOCGIFBRDADDR = 0x8919
1399		SIOCGIFCONF = 0x8912
1400		SIOCGIFCOUNT = 0x8938
1401		SIOCGIFDSTADDR = 0x8917
1402		SIOCGIFENCAP = 0x8925
1403		SIOCGIFFLAGS = 0x8913
1404		SIOCGIFHWADDR = 0x8927
1405		SIOCGIFINDEX = 0x8933
1406		SIOCGIFMAP = 0x8970
1407		SIOCGIFMEM = 0x891f
1408		SIOCGIFMETRIC = 0x891d
1409		SIOCGIFMTU = 0x8921
1410		SIOCGIFNAME = 0x8910
1411		SIOCGIFNETMASK = 0x891b
1412		SIOCGIFPFLAGS = 0x8935
1413		SIOCGIFSLAVE = 0x8929
1414		SIOCGIFTXQLEN = 0x8942
1415		SIOCGIFVLAN = 0x8982
1416		SIOCGMIIPHY = 0x8947
1417		SIOCGMIIREG = 0x8948
1418		SIOCGPGRP = 0x8904
1419		SIOCGRARP = 0x8961
1420		SIOCGSTAMP = 0x8906
1421		SIOCGSTAMPNS = 0x8907
1422		SIOCINQ = 0x4004667f
1423		SIOCOUTQ = 0x40047473
1424		SIOCOUTQNSD = 0x894b
1425		SIOCPROTOPRIVATE = 0x89e0
1426		SIOCRTMSG = 0x890d
1427		SIOCSARP = 0x8955
1428		SIOCSHWTSTAMP = 0x89b0
1429		SIOCSIFADDR = 0x8916
1430		SIOCSIFBR = 0x8941
1431		SIOCSIFBRDADDR = 0x891a
1432		SIOCSIFDSTADDR = 0x8918
1433		SIOCSIFENCAP = 0x8926
1434		SIOCSIFFLAGS = 0x8914
1435		SIOCSIFHWADDR = 0x8924
1436		SIOCSIFHWBROADCAST = 0x8937
1437		SIOCSIFLINK = 0x8911
1438		SIOCSIFMAP = 0x8971
1439		SIOCSIFMEM = 0x8920
1440		SIOCSIFMETRIC = 0x891e
1441		SIOCSIFMTU = 0x8922
1442		SIOCSIFNAME = 0x8923
1443		SIOCSIFNETMASK = 0x891c
1444		SIOCSIFPFLAGS = 0x8934
1445		SIOCSIFSLAVE = 0x8930
1446		SIOCSIFTXQLEN = 0x8943
1447		SIOCSIFVLAN = 0x8983
1448		SIOCSMIIREG = 0x8949
1449		SIOCSPGRP = 0x8902
1450		SIOCSRARP = 0x8962
1451		SIOCWANDEV = 0x894a
1452		SOCK_CLOEXEC = 0x400000
1453		SOCK_DCCP = 0x6
1454		SOCK_DGRAM = 0x2
1455		SOCK_NONBLOCK = 0x4000
1456		SOCK_PACKET = 0xa
1457		SOCK_RAW = 0x3
1458		SOCK_RDM = 0x4
1459		SOCK_SEQPACKET = 0x5
1460		SOCK_STREAM = 0x1
1461		SOL_AAL = 0x109
1462		SOL_ALG = 0x117
1463		SOL_ATM = 0x108
1464		SOL_CAIF = 0x116
1465		SOL_DCCP = 0x10d
1466		SOL_DECNET = 0x105
1467		SOL_ICMPV6 = 0x3a
1468		SOL_IP = 0x0
1469		SOL_IPV6 = 0x29
1470		SOL_IRDA = 0x10a
1471		SOL_IUCV = 0x115
1472		SOL_KCM = 0x119
1473		SOL_LLC = 0x10c
1474		SOL_NETBEUI = 0x10b
1475		SOL_NETLINK = 0x10e
1476		SOL_NFC = 0x118
1477		SOL_PACKET = 0x107
1478		SOL_PNPIPE = 0x113
1479		SOL_PPPOL2TP = 0x111
1480		SOL_RAW = 0xff
1481		SOL_RDS = 0x114
1482		SOL_RXRPC = 0x110
1483		SOL_SOCKET = 0xffff
1484		SOL_TCP = 0x6
1485		SOL_TIPC = 0x10f
1486		SOL_X25 = 0x106
1487		SOMAXCONN = 0x80
1488		SO_ACCEPTCONN = 0x8000
1489		SO_ATTACH_BPF = 0x34
1490		SO_ATTACH_FILTER = 0x1a
1491		SO_ATTACH_REUSEPORT_CBPF = 0x35
1492		SO_ATTACH_REUSEPORT_EBPF = 0x36
1493		SO_BINDTODEVICE = 0xd
1494		SO_BPF_EXTENSIONS = 0x32
1495		SO_BROADCAST = 0x20
1496		SO_BSDCOMPAT = 0x400
1497		SO_BUSY_POLL = 0x30
1498		SO_CNX_ADVICE = 0x37
1499		SO_DEBUG = 0x1
1500		SO_DETACH_BPF = 0x1b
1501		SO_DETACH_FILTER = 0x1b
1502		SO_DOMAIN = 0x1029
1503		SO_DONTROUTE = 0x10
1504		SO_ERROR = 0x1007
1505		SO_GET_FILTER = 0x1a
1506		SO_INCOMING_CPU = 0x33
1507		SO_KEEPALIVE = 0x8
1508		SO_LINGER = 0x80
1509		SO_LOCK_FILTER = 0x28
1510		SO_MARK = 0x22
1511		SO_MAX_PACING_RATE = 0x31
1512		SO_NOFCS = 0x27
1513		SO_NO_CHECK = 0xb
1514		SO_OOBINLINE = 0x100
1515		SO_PASSCRED = 0x2
1516		SO_PASSSEC = 0x1f
1517		SO_PEEK_OFF = 0x26
1518		SO_PEERCRED = 0x40
1519		SO_PEERNAME = 0x1c
1520		SO_PEERSEC = 0x1e
1521		SO_PRIORITY = 0xc
1522		SO_PROTOCOL = 0x1028
1523		SO_RCVBUF = 0x1002
1524		SO_RCVBUFFORCE = 0x100b
1525		SO_RCVLOWAT = 0x800
1526		SO_RCVTIMEO = 0x2000
1527		SO_REUSEADDR = 0x4
1528		SO_REUSEPORT = 0x200
1529		SO_RXQ_OVFL = 0x24
1530		SO_SECURITY_AUTHENTICATION = 0x5001
1531		SO_SECURITY_ENCRYPTION_NETWORK = 0x5004
1532		SO_SECURITY_ENCRYPTION_TRANSPORT = 0x5002
1533		SO_SELECT_ERR_QUEUE = 0x29
1534		SO_SNDBUF = 0x1001
1535		SO_SNDBUFFORCE = 0x100a
1536		SO_SNDLOWAT = 0x1000
1537		SO_SNDTIMEO = 0x4000
1538		SO_TIMESTAMP = 0x1d
1539		SO_TIMESTAMPING = 0x23
1540		SO_TIMESTAMPNS = 0x21
1541		SO_TYPE = 0x1008
1542		SO_VM_SOCKETS_BUFFER_MAX_SIZE = 0x2
1543		SO_VM_SOCKETS_BUFFER_MIN_SIZE = 0x1
1544		SO_VM_SOCKETS_BUFFER_SIZE = 0x0
1545		SO_VM_SOCKETS_CONNECT_TIMEOUT = 0x6
1546		SO_VM_SOCKETS_NONBLOCK_TXRX = 0x7
1547		SO_VM_SOCKETS_PEER_HOST_VM_ID = 0x3
1548		SO_VM_SOCKETS_TRUSTED = 0x5
1549		SO_WIFI_STATUS = 0x25
1550		SPLICE_F_GIFT = 0x8
1551		SPLICE_F_MORE = 0x4
1552		SPLICE_F_MOVE = 0x1
1553		SPLICE_F_NONBLOCK = 0x2
1554		S_BLKSIZE = 0x200
1555		S_IEXEC = 0x40
1556		S_IFBLK = 0x6000
1557		S_IFCHR = 0x2000
1558		S_IFDIR = 0x4000
1559		S_IFIFO = 0x1000
1560		S_IFLNK = 0xa000
1561		S_IFMT = 0xf000
1562		S_IFREG = 0x8000
1563		S_IFSOCK = 0xc000
1564		S_IREAD = 0x100
1565		S_IRGRP = 0x20
1566		S_IROTH = 0x4
1567		S_IRUSR = 0x100
1568		S_IRWXG = 0x38
1569		S_IRWXO = 0x7
1570		S_IRWXU = 0x1c0
1571		S_ISGID = 0x400
1572		S_ISUID = 0x800
1573		S_ISVTX = 0x200
1574		S_IWGRP = 0x10
1575		S_IWOTH = 0x2
1576		S_IWRITE = 0x80
1577		S_IWUSR = 0x80
1578		S_IXGRP = 0x8
1579		S_IXOTH = 0x1
1580		S_IXUSR = 0x40
1581		TAB0 = 0x0
1582		TAB1 = 0x800
1583		TAB2 = 0x1000
1584		TAB3 = 0x1800
1585		TABDLY = 0x1800
1586		TCFLSH = 0x20005407
1587		TCGETA = 0x40125401
1588		TCGETS = 0x40245408
1589		TCGETS2 = 0x402c540c
1590		TCIFLUSH = 0x0
1591		TCIOFF = 0x2
1592		TCIOFLUSH = 0x2
1593		TCION = 0x3
1594		TCOFLUSH = 0x1
1595		TCOOFF = 0x0
1596		TCOON = 0x1
1597		TCP_CC_INFO = 0x1a
1598		TCP_CONGESTION = 0xd
1599		TCP_COOKIE_IN_ALWAYS = 0x1
1600		TCP_COOKIE_MAX = 0x10
1601		TCP_COOKIE_MIN = 0x8
1602		TCP_COOKIE_OUT_NEVER = 0x2
1603		TCP_COOKIE_PAIR_SIZE = 0x20
1604		TCP_COOKIE_TRANSACTIONS = 0xf
1605		TCP_CORK = 0x3
1606		TCP_DEFER_ACCEPT = 0x9
1607		TCP_FASTOPEN = 0x17
1608		TCP_INFO = 0xb
1609		TCP_KEEPCNT = 0x6
1610		TCP_KEEPIDLE = 0x4
1611		TCP_KEEPINTVL = 0x5
1612		TCP_LINGER2 = 0x8
1613		TCP_MAXSEG = 0x2
1614		TCP_MAXWIN = 0xffff
1615		TCP_MAX_WINSHIFT = 0xe
1616		TCP_MD5SIG = 0xe
1617		TCP_MD5SIG_MAXKEYLEN = 0x50
1618		TCP_MSS = 0x200
1619		TCP_MSS_DEFAULT = 0x218
1620		TCP_MSS_DESIRED = 0x4c4
1621		TCP_NODELAY = 0x1
1622		TCP_NOTSENT_LOWAT = 0x19
1623		TCP_QUEUE_SEQ = 0x15
1624		TCP_QUICKACK = 0xc
1625		TCP_REPAIR = 0x13
1626		TCP_REPAIR_OPTIONS = 0x16
1627		TCP_REPAIR_QUEUE = 0x14
1628		TCP_SAVED_SYN = 0x1c
1629		TCP_SAVE_SYN = 0x1b
1630		TCP_SYNCNT = 0x7
1631		TCP_S_DATA_IN = 0x4
1632		TCP_S_DATA_OUT = 0x8
1633		TCP_THIN_DUPACK = 0x11
1634		TCP_THIN_LINEAR_TIMEOUTS = 0x10
1635		TCP_TIMESTAMP = 0x18
1636		TCP_USER_TIMEOUT = 0x12
1637		TCP_WINDOW_CLAMP = 0xa
1638		TCSAFLUSH = 0x2
1639		TCSBRK = 0x20005405
1640		TCSBRKP = 0x5425
1641		TCSETA = 0x80125402
1642		TCSETAF = 0x80125404
1643		TCSETAW = 0x80125403
1644		TCSETS = 0x80245409
1645		TCSETS2 = 0x802c540d
1646		TCSETSF = 0x8024540b
1647		TCSETSF2 = 0x802c540f
1648		TCSETSW = 0x8024540a
1649		TCSETSW2 = 0x802c540e
1650		TCXONC = 0x20005406
1651		TIOCCBRK = 0x2000747a
1652		TIOCCONS = 0x20007424
1653		TIOCEXCL = 0x2000740d
1654		TIOCGDEV = 0x40045432
1655		TIOCGETD = 0x40047400
1656		TIOCGEXCL = 0x40045440
1657		TIOCGICOUNT = 0x545d
1658		TIOCGLCKTRMIOS = 0x5456
1659		TIOCGPGRP = 0x40047483
1660		TIOCGPKT = 0x40045438
1661		TIOCGPTLCK = 0x40045439
1662		TIOCGPTN = 0x40047486
1663		TIOCGRS485 = 0x40205441
1664		TIOCGSERIAL = 0x541e
1665		TIOCGSID = 0x40047485
1666		TIOCGSOFTCAR = 0x40047464
1667		TIOCGWINSZ = 0x40087468
1668		TIOCINQ = 0x4004667f
1669		TIOCLINUX = 0x541c
1670		TIOCMBIC = 0x8004746b
1671		TIOCMBIS = 0x8004746c
1672		TIOCMGET = 0x4004746a
1673		TIOCMIWAIT = 0x545c
1674		TIOCMSET = 0x8004746d
1675		TIOCM_CAR = 0x40
1676		TIOCM_CD = 0x40
1677		TIOCM_CTS = 0x20
1678		TIOCM_DSR = 0x100
1679		TIOCM_DTR = 0x2
1680		TIOCM_LE = 0x1
1681		TIOCM_LOOP = 0x8000
1682		TIOCM_OUT1 = 0x2000
1683		TIOCM_OUT2 = 0x4000
1684		TIOCM_RI = 0x80
1685		TIOCM_RNG = 0x80
1686		TIOCM_RTS = 0x4
1687		TIOCM_SR = 0x10
1688		TIOCM_ST = 0x8
1689		TIOCNOTTY = 0x20007471
1690		TIOCNXCL = 0x2000740e
1691		TIOCOUTQ = 0x40047473
1692		TIOCPKT = 0x80047470
1693		TIOCPKT_DATA = 0x0
1694		TIOCPKT_DOSTOP = 0x20
1695		TIOCPKT_FLUSHREAD = 0x1
1696		TIOCPKT_FLUSHWRITE = 0x2
1697		TIOCPKT_IOCTL = 0x40
1698		TIOCPKT_NOSTOP = 0x10
1699		TIOCPKT_START = 0x8
1700		TIOCPKT_STOP = 0x4
1701		TIOCSBRK = 0x2000747b
1702		TIOCSCTTY = 0x20007484
1703		TIOCSERCONFIG = 0x5453
1704		TIOCSERGETLSR = 0x5459
1705		TIOCSERGETMULTI = 0x545a
1706		TIOCSERGSTRUCT = 0x5458
1707		TIOCSERGWILD = 0x5454
1708		TIOCSERSETMULTI = 0x545b
1709		TIOCSERSWILD = 0x5455
1710		TIOCSER_TEMT = 0x1
1711		TIOCSETD = 0x80047401
1712		TIOCSIG = 0x80047488
1713		TIOCSLCKTRMIOS = 0x5457
1714		TIOCSPGRP = 0x80047482
1715		TIOCSPTLCK = 0x80047487
1716		TIOCSRS485 = 0xc0205442
1717		TIOCSSERIAL = 0x541f
1718		TIOCSSOFTCAR = 0x80047465
1719		TIOCSTART = 0x2000746e
1720		TIOCSTI = 0x80017472
1721		TIOCSTOP = 0x2000746f
1722		TIOCSWINSZ = 0x80087467
1723		TIOCVHANGUP = 0x20005437
1724		TOSTOP = 0x100
1725		TUNATTACHFILTER = 0x801054d5
1726		TUNDETACHFILTER = 0x801054d6
1727		TUNGETFEATURES = 0x400454cf
1728		TUNGETFILTER = 0x401054db
1729		TUNGETIFF = 0x400454d2
1730		TUNGETSNDBUF = 0x400454d3
1731		TUNGETVNETBE = 0x400454df
1732		TUNGETVNETHDRSZ = 0x400454d7
1733		TUNGETVNETLE = 0x400454dd
1734		TUNSETDEBUG = 0x800454c9
1735		TUNSETGROUP = 0x800454ce
1736		TUNSETIFF = 0x800454ca
1737		TUNSETIFINDEX = 0x800454da
1738		TUNSETLINK = 0x800454cd
1739		TUNSETNOCSUM = 0x800454c8
1740		TUNSETOFFLOAD = 0x800454d0
1741		TUNSETOWNER = 0x800454cc
1742		TUNSETPERSIST = 0x800454cb
1743		TUNSETQUEUE = 0x800454d9
1744		TUNSETSNDBUF = 0x800454d4
1745		TUNSETTXFILTER = 0x800454d1
1746		TUNSETVNETBE = 0x800454de
1747		TUNSETVNETHDRSZ = 0x800454d8
1748		TUNSETVNETLE = 0x800454dc
1749		VDISCARD = 0xd
1750		VDSUSP = 0xb
1751		VEOF = 0x4
1752		VEOL = 0x5
1753		VEOL2 = 0x6
1754		VERASE = 0x2
1755		VINTR = 0x0
1756		VKILL = 0x3
1757		VLNEXT = 0xf
1758		VMADDR_CID_ANY = 0xffffffff
1759		VMADDR_CID_HOST = 0x2
1760		VMADDR_CID_HYPERVISOR = 0x0
1761		VMADDR_CID_RESERVED = 0x1
1762		VMADDR_PORT_ANY = 0xffffffff
1763		VMIN = 0x4
1764		VQUIT = 0x1
1765		VREPRINT = 0xc
1766		VSTART = 0x8
1767		VSTOP = 0x9
1768		VSUSP = 0xa
1769		VSWTC = 0x7
1770		VT0 = 0x0
1771		VT1 = 0x4000
1772		VTDLY = 0x4000
1773		VTIME = 0x5
1774		VWERASE = 0xe
1775		WALL = 0x40000000
1776		WCLONE = 0x80000000
1777		WCONTINUED = 0x8
1778		WEXITED = 0x4
1779		WNOHANG = 0x1
1780		WNOTHREAD = 0x20000000
1781		WNOWAIT = 0x1000000
1782		WORDSIZE = 0x40
1783		WRAP = 0x20000
1784		WSTOPPED = 0x2
1785		WUNTRACED = 0x2
1786		XCASE = 0x4
1787		XTABS = 0x1800
1788		__TIOCFLUSH = 0x80047410
	13	AAFS_MAGIC = 0x5a3c69f0
	14	ADFS_SUPER_MAGIC = 0xadf5
	15	AFFS_SUPER_MAGIC = 0xadff
	16	AFS_FS_MAGIC = 0x6b414653
	17	AFS_SUPER_MAGIC = 0x5346414f
	18	AF_ALG = 0x26
	19	AF_APPLETALK = 0x5
	20	AF_ASH = 0x12
	21	AF_ATMPVC = 0x8
	22	AF_ATMSVC = 0x14
	23	AF_AX25 = 0x3
	24	AF_BLUETOOTH = 0x1f
	25	AF_BRIDGE = 0x7
	26	AF_CAIF = 0x25
	27	AF_CAN = 0x1d
	28	AF_DECnet = 0xc
	29	AF_ECONET = 0x13
	30	AF_FILE = 0x1
	31	AF_IB = 0x1b
	32	AF_IEEE802154 = 0x24
	33	AF_INET = 0x2
	34	AF_INET6 = 0xa
	35	AF_IPX = 0x4
	36	AF_IRDA = 0x17
	37	AF_ISDN = 0x22
	38	AF_IUCV = 0x20
	39	AF_KCM = 0x29
	40	AF_KEY = 0xf
	41	AF_LLC = 0x1a
	42	AF_LOCAL = 0x1
	43	AF_MAX = 0x2c
	44	AF_MPLS = 0x1c
	45	AF_NETBEUI = 0xd
	46	AF_NETLINK = 0x10
	47	AF_NETROM = 0x6
	48	AF_NFC = 0x27
	49	AF_PACKET = 0x11
	50	AF_PHONET = 0x23
	51	AF_PPPOX = 0x18
	52	AF_QIPCRTR = 0x2a
	53	AF_RDS = 0x15
	54	AF_ROSE = 0xb
	55	AF_ROUTE = 0x10
	56	AF_RXRPC = 0x21
	57	AF_SECURITY = 0xe
	58	AF_SMC = 0x2b
	59	AF_SNA = 0x16
	60	AF_TIPC = 0x1e
	61	AF_UNIX = 0x1
	62	AF_UNSPEC = 0x0
	63	AF_VSOCK = 0x28
	64	AF_WANPIPE = 0x19
	65	AF_X25 = 0x9
	66	AF_XDP = 0x2c
	67	ALG_OP_DECRYPT = 0x0
	68	ALG_OP_ENCRYPT = 0x1
	69	ALG_SET_AEAD_ASSOCLEN = 0x4
	70	ALG_SET_AEAD_AUTHSIZE = 0x5
	71	ALG_SET_IV = 0x2
	72	ALG_SET_KEY = 0x1
	73	ALG_SET_OP = 0x3
	74	ANON_INODE_FS_MAGIC = 0x9041934
	75	ARPHRD_6LOWPAN = 0x339
	76	ARPHRD_ADAPT = 0x108
	77	ARPHRD_APPLETLK = 0x8
	78	ARPHRD_ARCNET = 0x7
	79	ARPHRD_ASH = 0x30d
	80	ARPHRD_ATM = 0x13
	81	ARPHRD_AX25 = 0x3
	82	ARPHRD_BIF = 0x307
	83	ARPHRD_CAIF = 0x336
	84	ARPHRD_CAN = 0x118
	85	ARPHRD_CHAOS = 0x5
	86	ARPHRD_CISCO = 0x201
	87	ARPHRD_CSLIP = 0x101
	88	ARPHRD_CSLIP6 = 0x103
	89	ARPHRD_DDCMP = 0x205
	90	ARPHRD_DLCI = 0xf
	91	ARPHRD_ECONET = 0x30e
	92	ARPHRD_EETHER = 0x2
	93	ARPHRD_ETHER = 0x1
	94	ARPHRD_EUI64 = 0x1b
	95	ARPHRD_FCAL = 0x311
	96	ARPHRD_FCFABRIC = 0x313
	97	ARPHRD_FCPL = 0x312
	98	ARPHRD_FCPP = 0x310
	99	ARPHRD_FDDI = 0x306
	100	ARPHRD_FRAD = 0x302
	101	ARPHRD_HDLC = 0x201
	102	ARPHRD_HIPPI = 0x30c
	103	ARPHRD_HWX25 = 0x110
	104	ARPHRD_IEEE1394 = 0x18
	105	ARPHRD_IEEE802 = 0x6
	106	ARPHRD_IEEE80211 = 0x321
	107	ARPHRD_IEEE80211_PRISM = 0x322
	108	ARPHRD_IEEE80211_RADIOTAP = 0x323
	109	ARPHRD_IEEE802154 = 0x324
	110	ARPHRD_IEEE802154_MONITOR = 0x325
	111	ARPHRD_IEEE802_TR = 0x320
	112	ARPHRD_INFINIBAND = 0x20
	113	ARPHRD_IP6GRE = 0x337
	114	ARPHRD_IPDDP = 0x309
	115	ARPHRD_IPGRE = 0x30a
	116	ARPHRD_IRDA = 0x30f
	117	ARPHRD_LAPB = 0x204
	118	ARPHRD_LOCALTLK = 0x305
	119	ARPHRD_LOOPBACK = 0x304
	120	ARPHRD_METRICOM = 0x17
	121	ARPHRD_NETLINK = 0x338
	122	ARPHRD_NETROM = 0x0
	123	ARPHRD_NONE = 0xfffe
	124	ARPHRD_PHONET = 0x334
	125	ARPHRD_PHONET_PIPE = 0x335
	126	ARPHRD_PIMREG = 0x30b
	127	ARPHRD_PPP = 0x200
	128	ARPHRD_PRONET = 0x4
	129	ARPHRD_RAWHDLC = 0x206
	130	ARPHRD_RAWIP = 0x207
	131	ARPHRD_ROSE = 0x10e
	132	ARPHRD_RSRVD = 0x104
	133	ARPHRD_SIT = 0x308
	134	ARPHRD_SKIP = 0x303
	135	ARPHRD_SLIP = 0x100
	136	ARPHRD_SLIP6 = 0x102
	137	ARPHRD_TUNNEL = 0x300
	138	ARPHRD_TUNNEL6 = 0x301
	139	ARPHRD_VOID = 0xffff
	140	ARPHRD_VSOCKMON = 0x33a
	141	ARPHRD_X25 = 0x10f
	142	ASI_LEON_DFLUSH = 0x11
	143	ASI_LEON_IFLUSH = 0x10
	144	ASI_LEON_MMUFLUSH = 0x18
	145	AUTOFS_SUPER_MAGIC = 0x187
	146	B0 = 0x0
	147	B1000000 = 0x1008
	148	B110 = 0x3
	149	B115200 = 0x1002
	150	B1152000 = 0x1009
	151	B1200 = 0x9
	152	B134 = 0x4
	153	B150 = 0x5
	154	B1500000 = 0x100a
	155	B1800 = 0xa
	156	B19200 = 0xe
	157	B200 = 0x6
	158	B2000000 = 0x100b
	159	B230400 = 0x1003
	160	B2400 = 0xb
	161	B2500000 = 0x100c
	162	B300 = 0x7
	163	B3000000 = 0x100d
	164	B3500000 = 0x100e
	165	B38400 = 0xf
	166	B4000000 = 0x100f
	167	B460800 = 0x1004
	168	B4800 = 0xc
	169	B50 = 0x1
	170	B500000 = 0x1005
	171	B57600 = 0x1001
	172	B576000 = 0x1006
	173	B600 = 0x8
	174	B75 = 0x2
	175	B921600 = 0x1007
	176	B9600 = 0xd
	177	BALLOON_KVM_MAGIC = 0x13661366
	178	BDEVFS_MAGIC = 0x62646576
	179	BINFMTFS_MAGIC = 0x42494e4d
	180	BLKBSZGET = 0x40081270
	181	BLKBSZSET = 0x80081271
	182	BLKFLSBUF = 0x20001261
	183	BLKFRAGET = 0x20001265
	184	BLKFRASET = 0x20001264
	185	BLKGETSIZE = 0x20001260
	186	BLKGETSIZE64 = 0x40081272
	187	BLKPBSZGET = 0x2000127b
	188	BLKRAGET = 0x20001263
	189	BLKRASET = 0x20001262
	190	BLKROGET = 0x2000125e
	191	BLKROSET = 0x2000125d
	192	BLKRRPART = 0x2000125f
	193	BLKSECTGET = 0x20001267
	194	BLKSECTSET = 0x20001266
	195	BLKSSZGET = 0x20001268
	196	BOTHER = 0x1000
	197	BPF_A = 0x10
	198	BPF_ABS = 0x20
	199	BPF_ADD = 0x0
	200	BPF_ALU = 0x4
	201	BPF_AND = 0x50
	202	BPF_B = 0x10
	203	BPF_DIV = 0x30
	204	BPF_FS_MAGIC = 0xcafe4a11
	205	BPF_H = 0x8
	206	BPF_IMM = 0x0
	207	BPF_IND = 0x40
	208	BPF_JA = 0x0
	209	BPF_JEQ = 0x10
	210	BPF_JGE = 0x30
	211	BPF_JGT = 0x20
	212	BPF_JMP = 0x5
	213	BPF_JSET = 0x40
	214	BPF_K = 0x0
	215	BPF_LD = 0x0
	216	BPF_LDX = 0x1
	217	BPF_LEN = 0x80
	218	BPF_LL_OFF = -0x200000
	219	BPF_LSH = 0x60
	220	BPF_MAJOR_VERSION = 0x1
	221	BPF_MAXINSNS = 0x1000
	222	BPF_MEM = 0x60
	223	BPF_MEMWORDS = 0x10
	224	BPF_MINOR_VERSION = 0x1
	225	BPF_MISC = 0x7
	226	BPF_MOD = 0x90
	227	BPF_MSH = 0xa0
	228	BPF_MUL = 0x20
	229	BPF_NEG = 0x80
	230	BPF_NET_OFF = -0x100000
	231	BPF_OR = 0x40
	232	BPF_RET = 0x6
	233	BPF_RSH = 0x70
	234	BPF_ST = 0x2
	235	BPF_STX = 0x3
	236	BPF_SUB = 0x10
	237	BPF_TAX = 0x0
	238	BPF_TXA = 0x80
	239	BPF_W = 0x0
	240	BPF_X = 0x8
	241	BPF_XOR = 0xa0
	242	BRKINT = 0x2
	243	BS0 = 0x0
	244	BS1 = 0x2000
	245	BSDLY = 0x2000
	246	BTRFS_SUPER_MAGIC = 0x9123683e
	247	BTRFS_TEST_MAGIC = 0x73727279
	248	CAN_BCM = 0x2
	249	CAN_EFF_FLAG = 0x80000000
	250	CAN_EFF_ID_BITS = 0x1d
	251	CAN_EFF_MASK = 0x1fffffff
	252	CAN_ERR_FLAG = 0x20000000
	253	CAN_ERR_MASK = 0x1fffffff
	254	CAN_INV_FILTER = 0x20000000
	255	CAN_ISOTP = 0x6
	256	CAN_MAX_DLC = 0x8
	257	CAN_MAX_DLEN = 0x8
	258	CAN_MCNET = 0x5
	259	CAN_MTU = 0x10
	260	CAN_NPROTO = 0x7
	261	CAN_RAW = 0x1
	262	CAN_RAW_FILTER_MAX = 0x200
	263	CAN_RTR_FLAG = 0x40000000
	264	CAN_SFF_ID_BITS = 0xb
	265	CAN_SFF_MASK = 0x7ff
	266	CAN_TP16 = 0x3
	267	CAN_TP20 = 0x4
	268	CBAUD = 0x100f
	269	CBAUDEX = 0x1000
	270	CFLUSH = 0xf
	271	CGROUP2_SUPER_MAGIC = 0x63677270
	272	CGROUP_SUPER_MAGIC = 0x27e0eb
	273	CIBAUD = 0x100f0000
	274	CLOCAL = 0x800
	275	CLOCK_BOOTTIME = 0x7
	276	CLOCK_BOOTTIME_ALARM = 0x9
	277	CLOCK_DEFAULT = 0x0
	278	CLOCK_EXT = 0x1
	279	CLOCK_INT = 0x2
	280	CLOCK_MONOTONIC = 0x1
	281	CLOCK_MONOTONIC_COARSE = 0x6
	282	CLOCK_MONOTONIC_RAW = 0x4
	283	CLOCK_PROCESS_CPUTIME_ID = 0x2
	284	CLOCK_REALTIME = 0x0
	285	CLOCK_REALTIME_ALARM = 0x8
	286	CLOCK_REALTIME_COARSE = 0x5
	287	CLOCK_TAI = 0xb
	288	CLOCK_THREAD_CPUTIME_ID = 0x3
	289	CLOCK_TXFROMRX = 0x4
	290	CLOCK_TXINT = 0x3
	291	CLONE_CHILD_CLEARTID = 0x200000
	292	CLONE_CHILD_SETTID = 0x1000000
	293	CLONE_DETACHED = 0x400000
	294	CLONE_FILES = 0x400
	295	CLONE_FS = 0x200
	296	CLONE_IO = 0x80000000
	297	CLONE_NEWCGROUP = 0x2000000
	298	CLONE_NEWIPC = 0x8000000
	299	CLONE_NEWNET = 0x40000000
	300	CLONE_NEWNS = 0x20000
	301	CLONE_NEWPID = 0x20000000
	302	CLONE_NEWUSER = 0x10000000
	303	CLONE_NEWUTS = 0x4000000
	304	CLONE_PARENT = 0x8000
	305	CLONE_PARENT_SETTID = 0x100000
	306	CLONE_PTRACE = 0x2000
	307	CLONE_SETTLS = 0x80000
	308	CLONE_SIGHAND = 0x800
	309	CLONE_SYSVSEM = 0x40000
	310	CLONE_THREAD = 0x10000
	311	CLONE_UNTRACED = 0x800000
	312	CLONE_VFORK = 0x4000
	313	CLONE_VM = 0x100
	314	CMSPAR = 0x40000000
	315	CODA_SUPER_MAGIC = 0x73757245
	316	CR0 = 0x0
	317	CR1 = 0x200
	318	CR2 = 0x400
	319	CR3 = 0x600
	320	CRAMFS_MAGIC = 0x28cd3d45
	321	CRDLY = 0x600
	322	CREAD = 0x80
	323	CRTSCTS = 0x80000000
	324	CS5 = 0x0
	325	CS6 = 0x10
	326	CS7 = 0x20
	327	CS8 = 0x30
	328	CSIGNAL = 0xff
	329	CSIZE = 0x30
	330	CSTART = 0x11
	331	CSTATUS = 0x0
	332	CSTOP = 0x13
	333	CSTOPB = 0x40
	334	CSUSP = 0x1a
	335	DAXFS_MAGIC = 0x64646178
	336	DEBUGFS_MAGIC = 0x64626720
	337	DEVPTS_SUPER_MAGIC = 0x1cd1
	338	DT_BLK = 0x6
	339	DT_CHR = 0x2
	340	DT_DIR = 0x4
	341	DT_FIFO = 0x1
	342	DT_LNK = 0xa
	343	DT_REG = 0x8
	344	DT_SOCK = 0xc
	345	DT_UNKNOWN = 0x0
	346	DT_WHT = 0xe
	347	ECHO = 0x8
	348	ECHOCTL = 0x200
	349	ECHOE = 0x10
	350	ECHOK = 0x20
	351	ECHOKE = 0x800
	352	ECHONL = 0x40
	353	ECHOPRT = 0x400
	354	ECRYPTFS_SUPER_MAGIC = 0xf15f
	355	EFD_CLOEXEC = 0x400000
	356	EFD_NONBLOCK = 0x4000
	357	EFD_SEMAPHORE = 0x1
	358	EFIVARFS_MAGIC = 0xde5e81e4
	359	EFS_SUPER_MAGIC = 0x414a53
	360	EMT_TAGOVF = 0x1
	361	ENCODING_DEFAULT = 0x0
	362	ENCODING_FM_MARK = 0x3
	363	ENCODING_FM_SPACE = 0x4
	364	ENCODING_MANCHESTER = 0x5
	365	ENCODING_NRZ = 0x1
	366	ENCODING_NRZI = 0x2
	367	EPOLLERR = 0x8
	368	EPOLLET = 0x80000000
	369	EPOLLEXCLUSIVE = 0x10000000
	370	EPOLLHUP = 0x10
	371	EPOLLIN = 0x1
	372	EPOLLMSG = 0x400
	373	EPOLLONESHOT = 0x40000000
	374	EPOLLOUT = 0x4
	375	EPOLLPRI = 0x2
	376	EPOLLRDBAND = 0x80
	377	EPOLLRDHUP = 0x2000
	378	EPOLLRDNORM = 0x40
	379	EPOLLWAKEUP = 0x20000000
	380	EPOLLWRBAND = 0x200
	381	EPOLLWRNORM = 0x100
	382	EPOLL_CLOEXEC = 0x400000
	383	EPOLL_CTL_ADD = 0x1
	384	EPOLL_CTL_DEL = 0x2
	385	EPOLL_CTL_MOD = 0x3
	386	ETH_P_1588 = 0x88f7
	387	ETH_P_8021AD = 0x88a8
	388	ETH_P_8021AH = 0x88e7
	389	ETH_P_8021Q = 0x8100
	390	ETH_P_80221 = 0x8917
	391	ETH_P_802_2 = 0x4
	392	ETH_P_802_3 = 0x1
	393	ETH_P_802_3_MIN = 0x600
	394	ETH_P_802_EX1 = 0x88b5
	395	ETH_P_AARP = 0x80f3
	396	ETH_P_AF_IUCV = 0xfbfb
	397	ETH_P_ALL = 0x3
	398	ETH_P_AOE = 0x88a2
	399	ETH_P_ARCNET = 0x1a
	400	ETH_P_ARP = 0x806
	401	ETH_P_ATALK = 0x809b
	402	ETH_P_ATMFATE = 0x8884
	403	ETH_P_ATMMPOA = 0x884c
	404	ETH_P_AX25 = 0x2
	405	ETH_P_BATMAN = 0x4305
	406	ETH_P_BPQ = 0x8ff
	407	ETH_P_CAIF = 0xf7
	408	ETH_P_CAN = 0xc
	409	ETH_P_CANFD = 0xd
	410	ETH_P_CONTROL = 0x16
	411	ETH_P_CUST = 0x6006
	412	ETH_P_DDCMP = 0x6
	413	ETH_P_DEC = 0x6000
	414	ETH_P_DIAG = 0x6005
	415	ETH_P_DNA_DL = 0x6001
	416	ETH_P_DNA_RC = 0x6002
	417	ETH_P_DNA_RT = 0x6003
	418	ETH_P_DSA = 0x1b
	419	ETH_P_ECONET = 0x18
	420	ETH_P_EDSA = 0xdada
	421	ETH_P_ERSPAN = 0x88be
	422	ETH_P_ERSPAN2 = 0x22eb
	423	ETH_P_FCOE = 0x8906
	424	ETH_P_FIP = 0x8914
	425	ETH_P_HDLC = 0x19
	426	ETH_P_HSR = 0x892f
	427	ETH_P_IBOE = 0x8915
	428	ETH_P_IEEE802154 = 0xf6
	429	ETH_P_IEEEPUP = 0xa00
	430	ETH_P_IEEEPUPAT = 0xa01
	431	ETH_P_IFE = 0xed3e
	432	ETH_P_IP = 0x800
	433	ETH_P_IPV6 = 0x86dd
	434	ETH_P_IPX = 0x8137
	435	ETH_P_IRDA = 0x17
	436	ETH_P_LAT = 0x6004
	437	ETH_P_LINK_CTL = 0x886c
	438	ETH_P_LOCALTALK = 0x9
	439	ETH_P_LOOP = 0x60
	440	ETH_P_LOOPBACK = 0x9000
	441	ETH_P_MACSEC = 0x88e5
	442	ETH_P_MAP = 0xf9
	443	ETH_P_MOBITEX = 0x15
	444	ETH_P_MPLS_MC = 0x8848
	445	ETH_P_MPLS_UC = 0x8847
	446	ETH_P_MVRP = 0x88f5
	447	ETH_P_NCSI = 0x88f8
	448	ETH_P_NSH = 0x894f
	449	ETH_P_PAE = 0x888e
	450	ETH_P_PAUSE = 0x8808
	451	ETH_P_PHONET = 0xf5
	452	ETH_P_PPPTALK = 0x10
	453	ETH_P_PPP_DISC = 0x8863
	454	ETH_P_PPP_MP = 0x8
	455	ETH_P_PPP_SES = 0x8864
	456	ETH_P_PREAUTH = 0x88c7
	457	ETH_P_PRP = 0x88fb
	458	ETH_P_PUP = 0x200
	459	ETH_P_PUPAT = 0x201
	460	ETH_P_QINQ1 = 0x9100
	461	ETH_P_QINQ2 = 0x9200
	462	ETH_P_QINQ3 = 0x9300
	463	ETH_P_RARP = 0x8035
	464	ETH_P_SCA = 0x6007
	465	ETH_P_SLOW = 0x8809
	466	ETH_P_SNAP = 0x5
	467	ETH_P_TDLS = 0x890d
	468	ETH_P_TEB = 0x6558
	469	ETH_P_TIPC = 0x88ca
	470	ETH_P_TRAILER = 0x1c
	471	ETH_P_TR_802_2 = 0x11
	472	ETH_P_TSN = 0x22f0
	473	ETH_P_WAN_PPP = 0x7
	474	ETH_P_WCCP = 0x883e
	475	ETH_P_X25 = 0x805
	476	ETH_P_XDSA = 0xf8
	477	EXABYTE_ENABLE_NEST = 0xf0
	478	EXT2_SUPER_MAGIC = 0xef53
	479	EXT3_SUPER_MAGIC = 0xef53
	480	EXT4_SUPER_MAGIC = 0xef53
	481	EXTA = 0xe
	482	EXTB = 0xf
	483	EXTPROC = 0x10000
	484	F2FS_SUPER_MAGIC = 0xf2f52010
	485	FALLOC_FL_COLLAPSE_RANGE = 0x8
	486	FALLOC_FL_INSERT_RANGE = 0x20
	487	FALLOC_FL_KEEP_SIZE = 0x1
	488	FALLOC_FL_NO_HIDE_STALE = 0x4
	489	FALLOC_FL_PUNCH_HOLE = 0x2
	490	FALLOC_FL_UNSHARE_RANGE = 0x40
	491	FALLOC_FL_ZERO_RANGE = 0x10
	492	FD_CLOEXEC = 0x1
	493	FD_SETSIZE = 0x400
	494	FF0 = 0x0
	495	FF1 = 0x8000
	496	FFDLY = 0x8000
	497	FLUSHO = 0x1000
	498	FS_ENCRYPTION_MODE_AES_128_CBC = 0x5
	499	FS_ENCRYPTION_MODE_AES_128_CTS = 0x6
	500	FS_ENCRYPTION_MODE_AES_256_CBC = 0x3
	501	FS_ENCRYPTION_MODE_AES_256_CTS = 0x4
	502	FS_ENCRYPTION_MODE_AES_256_GCM = 0x2
	503	FS_ENCRYPTION_MODE_AES_256_XTS = 0x1
	504	FS_ENCRYPTION_MODE_INVALID = 0x0
	505	FS_ENCRYPTION_MODE_SPECK128_256_CTS = 0x8
	506	FS_ENCRYPTION_MODE_SPECK128_256_XTS = 0x7
	507	FS_IOC_GET_ENCRYPTION_POLICY = 0x800c6615
	508	FS_IOC_GET_ENCRYPTION_PWSALT = 0x80106614
	509	FS_IOC_SET_ENCRYPTION_POLICY = 0x400c6613
	510	FS_KEY_DESCRIPTOR_SIZE = 0x8
	511	FS_KEY_DESC_PREFIX = "fscrypt:"
	512	FS_KEY_DESC_PREFIX_SIZE = 0x8
	513	FS_MAX_KEY_SIZE = 0x40
	514	FS_POLICY_FLAGS_PAD_16 = 0x2
	515	FS_POLICY_FLAGS_PAD_32 = 0x3
	516	FS_POLICY_FLAGS_PAD_4 = 0x0
	517	FS_POLICY_FLAGS_PAD_8 = 0x1
	518	FS_POLICY_FLAGS_PAD_MASK = 0x3
	519	FS_POLICY_FLAGS_VALID = 0x3
	520	FUTEXFS_SUPER_MAGIC = 0xbad1dea
	521	F_ADD_SEALS = 0x409
	522	F_DUPFD = 0x0
	523	F_DUPFD_CLOEXEC = 0x406
	524	F_EXLCK = 0x4
	525	F_GETFD = 0x1
	526	F_GETFL = 0x3
	527	F_GETLEASE = 0x401
	528	F_GETLK = 0x7
	529	F_GETLK64 = 0x7
	530	F_GETOWN = 0x5
	531	F_GETOWN_EX = 0x10
	532	F_GETPIPE_SZ = 0x408
	533	F_GETSIG = 0xb
	534	F_GET_FILE_RW_HINT = 0x40d
	535	F_GET_RW_HINT = 0x40b
	536	F_GET_SEALS = 0x40a
	537	F_LOCK = 0x1
	538	F_NOTIFY = 0x402
	539	F_OFD_GETLK = 0x24
	540	F_OFD_SETLK = 0x25
	541	F_OFD_SETLKW = 0x26
	542	F_OK = 0x0
	543	F_RDLCK = 0x1
	544	F_SEAL_GROW = 0x4
	545	F_SEAL_SEAL = 0x1
	546	F_SEAL_SHRINK = 0x2
	547	F_SEAL_WRITE = 0x8
	548	F_SETFD = 0x2
	549	F_SETFL = 0x4
	550	F_SETLEASE = 0x400
	551	F_SETLK = 0x8
	552	F_SETLK64 = 0x8
	553	F_SETLKW = 0x9
	554	F_SETLKW64 = 0x9
	555	F_SETOWN = 0x6
	556	F_SETOWN_EX = 0xf
	557	F_SETPIPE_SZ = 0x407
	558	F_SETSIG = 0xa
	559	F_SET_FILE_RW_HINT = 0x40e
	560	F_SET_RW_HINT = 0x40c
	561	F_SHLCK = 0x8
	562	F_TEST = 0x3
	563	F_TLOCK = 0x2
	564	F_ULOCK = 0x0
	565	F_UNLCK = 0x3
	566	F_WRLCK = 0x2
	567	GENL_ADMIN_PERM = 0x1
	568	GENL_CMD_CAP_DO = 0x2
	569	GENL_CMD_CAP_DUMP = 0x4
	570	GENL_CMD_CAP_HASPOL = 0x8
	571	GENL_HDRLEN = 0x4
	572	GENL_ID_CTRL = 0x10
	573	GENL_ID_PMCRAID = 0x12
	574	GENL_ID_VFS_DQUOT = 0x11
	575	GENL_MAX_ID = 0x3ff
	576	GENL_MIN_ID = 0x10
	577	GENL_NAMSIZ = 0x10
	578	GENL_START_ALLOC = 0x13
	579	GENL_UNS_ADMIN_PERM = 0x10
	580	GRND_NONBLOCK = 0x1
	581	GRND_RANDOM = 0x2
	582	HDIO_DRIVE_CMD = 0x31f
	583	HDIO_DRIVE_CMD_AEB = 0x31e
	584	HDIO_DRIVE_CMD_HDR_SIZE = 0x4
	585	HDIO_DRIVE_HOB_HDR_SIZE = 0x8
	586	HDIO_DRIVE_RESET = 0x31c
	587	HDIO_DRIVE_TASK = 0x31e
	588	HDIO_DRIVE_TASKFILE = 0x31d
	589	HDIO_DRIVE_TASK_HDR_SIZE = 0x8
	590	HDIO_GETGEO = 0x301
	591	HDIO_GET_32BIT = 0x309
	592	HDIO_GET_ACOUSTIC = 0x30f
	593	HDIO_GET_ADDRESS = 0x310
	594	HDIO_GET_BUSSTATE = 0x31a
	595	HDIO_GET_DMA = 0x30b
	596	HDIO_GET_IDENTITY = 0x30d
	597	HDIO_GET_KEEPSETTINGS = 0x308
	598	HDIO_GET_MULTCOUNT = 0x304
	599	HDIO_GET_NICE = 0x30c
	600	HDIO_GET_NOWERR = 0x30a
	601	HDIO_GET_QDMA = 0x305
	602	HDIO_GET_UNMASKINTR = 0x302
	603	HDIO_GET_WCACHE = 0x30e
	604	HDIO_OBSOLETE_IDENTITY = 0x307
	605	HDIO_SCAN_HWIF = 0x328
	606	HDIO_SET_32BIT = 0x324
	607	HDIO_SET_ACOUSTIC = 0x32c
	608	HDIO_SET_ADDRESS = 0x32f
	609	HDIO_SET_BUSSTATE = 0x32d
	610	HDIO_SET_DMA = 0x326
	611	HDIO_SET_KEEPSETTINGS = 0x323
	612	HDIO_SET_MULTCOUNT = 0x321
	613	HDIO_SET_NICE = 0x329
	614	HDIO_SET_NOWERR = 0x325
	615	HDIO_SET_PIO_MODE = 0x327
	616	HDIO_SET_QDMA = 0x32e
	617	HDIO_SET_UNMASKINTR = 0x322
	618	HDIO_SET_WCACHE = 0x32b
	619	HDIO_SET_XFER = 0x306
	620	HDIO_TRISTATE_HWIF = 0x31b
	621	HDIO_UNREGISTER_HWIF = 0x32a
	622	HOSTFS_SUPER_MAGIC = 0xc0ffee
	623	HPFS_SUPER_MAGIC = 0xf995e849
	624	HUGETLBFS_MAGIC = 0x958458f6
	625	HUPCL = 0x400
	626	IBSHIFT = 0x10
	627	ICANON = 0x2
	628	ICMPV6_FILTER = 0x1
	629	ICRNL = 0x100
	630	IEXTEN = 0x8000
	631	IFA_F_DADFAILED = 0x8
	632	IFA_F_DEPRECATED = 0x20
	633	IFA_F_HOMEADDRESS = 0x10
	634	IFA_F_MANAGETEMPADDR = 0x100
	635	IFA_F_MCAUTOJOIN = 0x400
	636	IFA_F_NODAD = 0x2
	637	IFA_F_NOPREFIXROUTE = 0x200
	638	IFA_F_OPTIMISTIC = 0x4
	639	IFA_F_PERMANENT = 0x80
	640	IFA_F_SECONDARY = 0x1
	641	IFA_F_STABLE_PRIVACY = 0x800
	642	IFA_F_TEMPORARY = 0x1
	643	IFA_F_TENTATIVE = 0x40
	644	IFA_MAX = 0x9
	645	IFF_ALLMULTI = 0x200
	646	IFF_ATTACH_QUEUE = 0x200
	647	IFF_AUTOMEDIA = 0x4000
	648	IFF_BROADCAST = 0x2
	649	IFF_DEBUG = 0x4
	650	IFF_DETACH_QUEUE = 0x400
	651	IFF_DORMANT = 0x20000
	652	IFF_DYNAMIC = 0x8000
	653	IFF_ECHO = 0x40000
	654	IFF_LOOPBACK = 0x8
	655	IFF_LOWER_UP = 0x10000
	656	IFF_MASTER = 0x400
	657	IFF_MULTICAST = 0x1000
	658	IFF_MULTI_QUEUE = 0x100
	659	IFF_NAPI = 0x10
	660	IFF_NAPI_FRAGS = 0x20
	661	IFF_NOARP = 0x80
	662	IFF_NOFILTER = 0x1000
	663	IFF_NOTRAILERS = 0x20
	664	IFF_NO_PI = 0x1000
	665	IFF_ONE_QUEUE = 0x2000
	666	IFF_PERSIST = 0x800
	667	IFF_POINTOPOINT = 0x10
	668	IFF_PORTSEL = 0x2000
	669	IFF_PROMISC = 0x100
	670	IFF_RUNNING = 0x40
	671	IFF_SLAVE = 0x800
	672	IFF_TAP = 0x2
	673	IFF_TUN = 0x1
	674	IFF_TUN_EXCL = 0x8000
	675	IFF_UP = 0x1
	676	IFF_VNET_HDR = 0x4000
	677	IFF_VOLATILE = 0x70c5a
	678	IFNAMSIZ = 0x10
	679	IGNBRK = 0x1
	680	IGNCR = 0x80
	681	IGNPAR = 0x4
	682	IMAXBEL = 0x2000
	683	INLCR = 0x40
	684	INPCK = 0x10
	685	IN_ACCESS = 0x1
	686	IN_ALL_EVENTS = 0xfff
	687	IN_ATTRIB = 0x4
	688	IN_CLASSA_HOST = 0xffffff
	689	IN_CLASSA_MAX = 0x80
	690	IN_CLASSA_NET = 0xff000000
	691	IN_CLASSA_NSHIFT = 0x18
	692	IN_CLASSB_HOST = 0xffff
	693	IN_CLASSB_MAX = 0x10000
	694	IN_CLASSB_NET = 0xffff0000
	695	IN_CLASSB_NSHIFT = 0x10
	696	IN_CLASSC_HOST = 0xff
	697	IN_CLASSC_NET = 0xffffff00
	698	IN_CLASSC_NSHIFT = 0x8
	699	IN_CLOEXEC = 0x400000
	700	IN_CLOSE = 0x18
	701	IN_CLOSE_NOWRITE = 0x10
	702	IN_CLOSE_WRITE = 0x8
	703	IN_CREATE = 0x100
	704	IN_DELETE = 0x200
	705	IN_DELETE_SELF = 0x400
	706	IN_DONT_FOLLOW = 0x2000000
	707	IN_EXCL_UNLINK = 0x4000000
	708	IN_IGNORED = 0x8000
	709	IN_ISDIR = 0x40000000
	710	IN_LOOPBACKNET = 0x7f
	711	IN_MASK_ADD = 0x20000000
	712	IN_MODIFY = 0x2
	713	IN_MOVE = 0xc0
	714	IN_MOVED_FROM = 0x40
	715	IN_MOVED_TO = 0x80
	716	IN_MOVE_SELF = 0x800
	717	IN_NONBLOCK = 0x4000
	718	IN_ONESHOT = 0x80000000
	719	IN_ONLYDIR = 0x1000000
	720	IN_OPEN = 0x20
	721	IN_Q_OVERFLOW = 0x4000
	722	IN_UNMOUNT = 0x2000
	723	IOCTL_VM_SOCKETS_GET_LOCAL_CID = 0x200007b9
	724	IPPROTO_AH = 0x33
	725	IPPROTO_BEETPH = 0x5e
	726	IPPROTO_COMP = 0x6c
	727	IPPROTO_DCCP = 0x21
	728	IPPROTO_DSTOPTS = 0x3c
	729	IPPROTO_EGP = 0x8
	730	IPPROTO_ENCAP = 0x62
	731	IPPROTO_ESP = 0x32
	732	IPPROTO_FRAGMENT = 0x2c
	733	IPPROTO_GRE = 0x2f
	734	IPPROTO_HOPOPTS = 0x0
	735	IPPROTO_ICMP = 0x1
	736	IPPROTO_ICMPV6 = 0x3a
	737	IPPROTO_IDP = 0x16
	738	IPPROTO_IGMP = 0x2
	739	IPPROTO_IP = 0x0
	740	IPPROTO_IPIP = 0x4
	741	IPPROTO_IPV6 = 0x29
	742	IPPROTO_MH = 0x87
	743	IPPROTO_MPLS = 0x89
	744	IPPROTO_MTP = 0x5c
	745	IPPROTO_NONE = 0x3b
	746	IPPROTO_PIM = 0x67
	747	IPPROTO_PUP = 0xc
	748	IPPROTO_RAW = 0xff
	749	IPPROTO_ROUTING = 0x2b
	750	IPPROTO_RSVP = 0x2e
	751	IPPROTO_SCTP = 0x84
	752	IPPROTO_TCP = 0x6
	753	IPPROTO_TP = 0x1d
	754	IPPROTO_UDP = 0x11
	755	IPPROTO_UDPLITE = 0x88
	756	IPV6_2292DSTOPTS = 0x4
	757	IPV6_2292HOPLIMIT = 0x8
	758	IPV6_2292HOPOPTS = 0x3
	759	IPV6_2292PKTINFO = 0x2
	760	IPV6_2292PKTOPTIONS = 0x6
	761	IPV6_2292RTHDR = 0x5
	762	IPV6_ADDRFORM = 0x1
	763	IPV6_ADDR_PREFERENCES = 0x48
	764	IPV6_ADD_MEMBERSHIP = 0x14
	765	IPV6_AUTHHDR = 0xa
	766	IPV6_AUTOFLOWLABEL = 0x46
	767	IPV6_CHECKSUM = 0x7
	768	IPV6_DONTFRAG = 0x3e
	769	IPV6_DROP_MEMBERSHIP = 0x15
	770	IPV6_DSTOPTS = 0x3b
	771	IPV6_FREEBIND = 0x4e
	772	IPV6_HDRINCL = 0x24
	773	IPV6_HOPLIMIT = 0x34
	774	IPV6_HOPOPTS = 0x36
	775	IPV6_IPSEC_POLICY = 0x22
	776	IPV6_JOIN_ANYCAST = 0x1b
	777	IPV6_JOIN_GROUP = 0x14
	778	IPV6_LEAVE_ANYCAST = 0x1c
	779	IPV6_LEAVE_GROUP = 0x15
	780	IPV6_MINHOPCOUNT = 0x49
	781	IPV6_MTU = 0x18
	782	IPV6_MTU_DISCOVER = 0x17
	783	IPV6_MULTICAST_HOPS = 0x12
	784	IPV6_MULTICAST_IF = 0x11
	785	IPV6_MULTICAST_LOOP = 0x13
	786	IPV6_NEXTHOP = 0x9
	787	IPV6_ORIGDSTADDR = 0x4a
	788	IPV6_PATHMTU = 0x3d
	789	IPV6_PKTINFO = 0x32
	790	IPV6_PMTUDISC_DO = 0x2
	791	IPV6_PMTUDISC_DONT = 0x0
	792	IPV6_PMTUDISC_INTERFACE = 0x4
	793	IPV6_PMTUDISC_OMIT = 0x5
	794	IPV6_PMTUDISC_PROBE = 0x3
	795	IPV6_PMTUDISC_WANT = 0x1
	796	IPV6_RECVDSTOPTS = 0x3a
	797	IPV6_RECVERR = 0x19
	798	IPV6_RECVFRAGSIZE = 0x4d
	799	IPV6_RECVHOPLIMIT = 0x33
	800	IPV6_RECVHOPOPTS = 0x35
	801	IPV6_RECVORIGDSTADDR = 0x4a
	802	IPV6_RECVPATHMTU = 0x3c
	803	IPV6_RECVPKTINFO = 0x31
	804	IPV6_RECVRTHDR = 0x38
	805	IPV6_RECVTCLASS = 0x42
	806	IPV6_ROUTER_ALERT = 0x16
	807	IPV6_RTHDR = 0x39
	808	IPV6_RTHDRDSTOPTS = 0x37
	809	IPV6_RTHDR_LOOSE = 0x0
	810	IPV6_RTHDR_STRICT = 0x1
	811	IPV6_RTHDR_TYPE_0 = 0x0
	812	IPV6_RXDSTOPTS = 0x3b
	813	IPV6_RXHOPOPTS = 0x36
	814	IPV6_TCLASS = 0x43
	815	IPV6_TRANSPARENT = 0x4b
	816	IPV6_UNICAST_HOPS = 0x10
	817	IPV6_UNICAST_IF = 0x4c
	818	IPV6_V6ONLY = 0x1a
	819	IPV6_XFRM_POLICY = 0x23
	820	IP_ADD_MEMBERSHIP = 0x23
	821	IP_ADD_SOURCE_MEMBERSHIP = 0x27
	822	IP_BIND_ADDRESS_NO_PORT = 0x18
	823	IP_BLOCK_SOURCE = 0x26
	824	IP_CHECKSUM = 0x17
	825	IP_DEFAULT_MULTICAST_LOOP = 0x1
	826	IP_DEFAULT_MULTICAST_TTL = 0x1
	827	IP_DF = 0x4000
	828	IP_DROP_MEMBERSHIP = 0x24
	829	IP_DROP_SOURCE_MEMBERSHIP = 0x28
	830	IP_FREEBIND = 0xf
	831	IP_HDRINCL = 0x3
	832	IP_IPSEC_POLICY = 0x10
	833	IP_MAXPACKET = 0xffff
	834	IP_MAX_MEMBERSHIPS = 0x14
	835	IP_MF = 0x2000
	836	IP_MINTTL = 0x15
	837	IP_MSFILTER = 0x29
	838	IP_MSS = 0x240
	839	IP_MTU = 0xe
	840	IP_MTU_DISCOVER = 0xa
	841	IP_MULTICAST_ALL = 0x31
	842	IP_MULTICAST_IF = 0x20
	843	IP_MULTICAST_LOOP = 0x22
	844	IP_MULTICAST_TTL = 0x21
	845	IP_NODEFRAG = 0x16
	846	IP_OFFMASK = 0x1fff
	847	IP_OPTIONS = 0x4
	848	IP_ORIGDSTADDR = 0x14
	849	IP_PASSSEC = 0x12
	850	IP_PKTINFO = 0x8
	851	IP_PKTOPTIONS = 0x9
	852	IP_PMTUDISC = 0xa
	853	IP_PMTUDISC_DO = 0x2
	854	IP_PMTUDISC_DONT = 0x0
	855	IP_PMTUDISC_INTERFACE = 0x4
	856	IP_PMTUDISC_OMIT = 0x5
	857	IP_PMTUDISC_PROBE = 0x3
	858	IP_PMTUDISC_WANT = 0x1
	859	IP_RECVERR = 0xb
	860	IP_RECVFRAGSIZE = 0x19
	861	IP_RECVOPTS = 0x6
	862	IP_RECVORIGDSTADDR = 0x14
	863	IP_RECVRETOPTS = 0x7
	864	IP_RECVTOS = 0xd
	865	IP_RECVTTL = 0xc
	866	IP_RETOPTS = 0x7
	867	IP_RF = 0x8000
	868	IP_ROUTER_ALERT = 0x5
	869	IP_TOS = 0x1
	870	IP_TRANSPARENT = 0x13
	871	IP_TTL = 0x2
	872	IP_UNBLOCK_SOURCE = 0x25
	873	IP_UNICAST_IF = 0x32
	874	IP_XFRM_POLICY = 0x11
	875	ISIG = 0x1
	876	ISOFS_SUPER_MAGIC = 0x9660
	877	ISTRIP = 0x20
	878	IUCLC = 0x200
	879	IUTF8 = 0x4000
	880	IXANY = 0x800
	881	IXOFF = 0x1000
	882	IXON = 0x400
	883	JFFS2_SUPER_MAGIC = 0x72b6
	884	KEXEC_ARCH_386 = 0x30000
	885	KEXEC_ARCH_68K = 0x40000
	886	KEXEC_ARCH_AARCH64 = 0xb70000
	887	KEXEC_ARCH_ARM = 0x280000
	888	KEXEC_ARCH_DEFAULT = 0x0
	889	KEXEC_ARCH_IA_64 = 0x320000
	890	KEXEC_ARCH_MASK = 0xffff0000
	891	KEXEC_ARCH_MIPS = 0x80000
	892	KEXEC_ARCH_MIPS_LE = 0xa0000
	893	KEXEC_ARCH_PPC = 0x140000
	894	KEXEC_ARCH_PPC64 = 0x150000
	895	KEXEC_ARCH_S390 = 0x160000
	896	KEXEC_ARCH_SH = 0x2a0000
	897	KEXEC_ARCH_X86_64 = 0x3e0000
	898	KEXEC_FILE_NO_INITRAMFS = 0x4
	899	KEXEC_FILE_ON_CRASH = 0x2
	900	KEXEC_FILE_UNLOAD = 0x1
	901	KEXEC_ON_CRASH = 0x1
	902	KEXEC_PRESERVE_CONTEXT = 0x2
	903	KEXEC_SEGMENT_MAX = 0x10
	904	KEYCTL_ASSUME_AUTHORITY = 0x10
	905	KEYCTL_CHOWN = 0x4
	906	KEYCTL_CLEAR = 0x7
	907	KEYCTL_DESCRIBE = 0x6
	908	KEYCTL_DH_COMPUTE = 0x17
	909	KEYCTL_GET_KEYRING_ID = 0x0
	910	KEYCTL_GET_PERSISTENT = 0x16
	911	KEYCTL_GET_SECURITY = 0x11
	912	KEYCTL_INSTANTIATE = 0xc
	913	KEYCTL_INSTANTIATE_IOV = 0x14
	914	KEYCTL_INVALIDATE = 0x15
	915	KEYCTL_JOIN_SESSION_KEYRING = 0x1
	916	KEYCTL_LINK = 0x8
	917	KEYCTL_NEGATE = 0xd
	918	KEYCTL_READ = 0xb
	919	KEYCTL_REJECT = 0x13
	920	KEYCTL_RESTRICT_KEYRING = 0x1d
	921	KEYCTL_REVOKE = 0x3
	922	KEYCTL_SEARCH = 0xa
	923	KEYCTL_SESSION_TO_PARENT = 0x12
	924	KEYCTL_SETPERM = 0x5
	925	KEYCTL_SET_REQKEY_KEYRING = 0xe
	926	KEYCTL_SET_TIMEOUT = 0xf
	927	KEYCTL_UNLINK = 0x9
	928	KEYCTL_UPDATE = 0x2
	929	KEY_REQKEY_DEFL_DEFAULT = 0x0
	930	KEY_REQKEY_DEFL_GROUP_KEYRING = 0x6
	931	KEY_REQKEY_DEFL_NO_CHANGE = -0x1
	932	KEY_REQKEY_DEFL_PROCESS_KEYRING = 0x2
	933	KEY_REQKEY_DEFL_REQUESTOR_KEYRING = 0x7
	934	KEY_REQKEY_DEFL_SESSION_KEYRING = 0x3
	935	KEY_REQKEY_DEFL_THREAD_KEYRING = 0x1
	936	KEY_REQKEY_DEFL_USER_KEYRING = 0x4
	937	KEY_REQKEY_DEFL_USER_SESSION_KEYRING = 0x5
	938	KEY_SPEC_GROUP_KEYRING = -0x6
	939	KEY_SPEC_PROCESS_KEYRING = -0x2
	940	KEY_SPEC_REQKEY_AUTH_KEY = -0x7
	941	KEY_SPEC_REQUESTOR_KEYRING = -0x8
	942	KEY_SPEC_SESSION_KEYRING = -0x3
	943	KEY_SPEC_THREAD_KEYRING = -0x1
	944	KEY_SPEC_USER_KEYRING = -0x4
	945	KEY_SPEC_USER_SESSION_KEYRING = -0x5
	946	LINUX_REBOOT_CMD_CAD_OFF = 0x0
	947	LINUX_REBOOT_CMD_CAD_ON = 0x89abcdef
	948	LINUX_REBOOT_CMD_HALT = 0xcdef0123
	949	LINUX_REBOOT_CMD_KEXEC = 0x45584543
	950	LINUX_REBOOT_CMD_POWER_OFF = 0x4321fedc
	951	LINUX_REBOOT_CMD_RESTART = 0x1234567
	952	LINUX_REBOOT_CMD_RESTART2 = 0xa1b2c3d4
	953	LINUX_REBOOT_CMD_SW_SUSPEND = 0xd000fce2
	954	LINUX_REBOOT_MAGIC1 = 0xfee1dead
	955	LINUX_REBOOT_MAGIC2 = 0x28121969
	956	LOCK_EX = 0x2
	957	LOCK_NB = 0x4
	958	LOCK_SH = 0x1
	959	LOCK_UN = 0x8
	960	MADV_DODUMP = 0x11
	961	MADV_DOFORK = 0xb
	962	MADV_DONTDUMP = 0x10
	963	MADV_DONTFORK = 0xa
	964	MADV_DONTNEED = 0x4
	965	MADV_FREE = 0x8
	966	MADV_HUGEPAGE = 0xe
	967	MADV_HWPOISON = 0x64
	968	MADV_KEEPONFORK = 0x13
	969	MADV_MERGEABLE = 0xc
	970	MADV_NOHUGEPAGE = 0xf
	971	MADV_NORMAL = 0x0
	972	MADV_RANDOM = 0x1
	973	MADV_REMOVE = 0x9
	974	MADV_SEQUENTIAL = 0x2
	975	MADV_UNMERGEABLE = 0xd
	976	MADV_WILLNEED = 0x3
	977	MADV_WIPEONFORK = 0x12
	978	MAP_ANON = 0x20
	979	MAP_ANONYMOUS = 0x20
	980	MAP_DENYWRITE = 0x800
	981	MAP_EXECUTABLE = 0x1000
	982	MAP_FILE = 0x0
	983	MAP_FIXED = 0x10
	984	MAP_FIXED_NOREPLACE = 0x100000
	985	MAP_GROWSDOWN = 0x200
	986	MAP_HUGETLB = 0x40000
	987	MAP_HUGE_MASK = 0x3f
	988	MAP_HUGE_SHIFT = 0x1a
	989	MAP_LOCKED = 0x100
	990	MAP_NONBLOCK = 0x10000
	991	MAP_NORESERVE = 0x40
	992	MAP_POPULATE = 0x8000
	993	MAP_PRIVATE = 0x2
	994	MAP_RENAME = 0x20
	995	MAP_SHARED = 0x1
	996	MAP_SHARED_VALIDATE = 0x3
	997	MAP_STACK = 0x20000
	998	MAP_TYPE = 0xf
	999	MCL_CURRENT = 0x2000
	1000	MCL_FUTURE = 0x4000
	1001	MCL_ONFAULT = 0x8000
	1002	MFD_ALLOW_SEALING = 0x2
	1003	MFD_CLOEXEC = 0x1
	1004	MFD_HUGETLB = 0x4
	1005	MFD_HUGE_16GB = -0x78000000
	1006	MFD_HUGE_16MB = 0x60000000
	1007	MFD_HUGE_1GB = 0x78000000
	1008	MFD_HUGE_1MB = 0x50000000
	1009	MFD_HUGE_256MB = 0x70000000
	1010	MFD_HUGE_2GB = 0x7c000000
	1011	MFD_HUGE_2MB = 0x54000000
	1012	MFD_HUGE_32MB = 0x64000000
	1013	MFD_HUGE_512KB = 0x4c000000
	1014	MFD_HUGE_512MB = 0x74000000
	1015	MFD_HUGE_64KB = 0x40000000
	1016	MFD_HUGE_8MB = 0x5c000000
	1017	MFD_HUGE_MASK = 0x3f
	1018	MFD_HUGE_SHIFT = 0x1a
	1019	MINIX2_SUPER_MAGIC = 0x2468
	1020	MINIX2_SUPER_MAGIC2 = 0x2478
	1021	MINIX3_SUPER_MAGIC = 0x4d5a
	1022	MINIX_SUPER_MAGIC = 0x137f
	1023	MINIX_SUPER_MAGIC2 = 0x138f
	1024	MNT_DETACH = 0x2
	1025	MNT_EXPIRE = 0x4
	1026	MNT_FORCE = 0x1
	1027	MODULE_INIT_IGNORE_MODVERSIONS = 0x1
	1028	MODULE_INIT_IGNORE_VERMAGIC = 0x2
	1029	MSDOS_SUPER_MAGIC = 0x4d44
	1030	MSG_BATCH = 0x40000
	1031	MSG_CMSG_CLOEXEC = 0x40000000
	1032	MSG_CONFIRM = 0x800
	1033	MSG_CTRUNC = 0x8
	1034	MSG_DONTROUTE = 0x4
	1035	MSG_DONTWAIT = 0x40
	1036	MSG_EOR = 0x80
	1037	MSG_ERRQUEUE = 0x2000
	1038	MSG_FASTOPEN = 0x20000000
	1039	MSG_FIN = 0x200
	1040	MSG_MORE = 0x8000
	1041	MSG_NOSIGNAL = 0x4000
	1042	MSG_OOB = 0x1
	1043	MSG_PEEK = 0x2
	1044	MSG_PROXY = 0x10
	1045	MSG_RST = 0x1000
	1046	MSG_SYN = 0x400
	1047	MSG_TRUNC = 0x20
	1048	MSG_TRYHARD = 0x4
	1049	MSG_WAITALL = 0x100
	1050	MSG_WAITFORONE = 0x10000
	1051	MSG_ZEROCOPY = 0x4000000
	1052	MS_ACTIVE = 0x40000000
	1053	MS_ASYNC = 0x1
	1054	MS_BIND = 0x1000
	1055	MS_BORN = 0x20000000
	1056	MS_DIRSYNC = 0x80
	1057	MS_INVALIDATE = 0x2
	1058	MS_I_VERSION = 0x800000
	1059	MS_KERNMOUNT = 0x400000
	1060	MS_LAZYTIME = 0x2000000
	1061	MS_MANDLOCK = 0x40
	1062	MS_MGC_MSK = 0xffff0000
	1063	MS_MGC_VAL = 0xc0ed0000
	1064	MS_MOVE = 0x2000
	1065	MS_NOATIME = 0x400
	1066	MS_NODEV = 0x4
	1067	MS_NODIRATIME = 0x800
	1068	MS_NOEXEC = 0x8
	1069	MS_NOREMOTELOCK = 0x8000000
	1070	MS_NOSEC = 0x10000000
	1071	MS_NOSUID = 0x2
	1072	MS_NOUSER = -0x80000000
	1073	MS_POSIXACL = 0x10000
	1074	MS_PRIVATE = 0x40000
	1075	MS_RDONLY = 0x1
	1076	MS_REC = 0x4000
	1077	MS_RELATIME = 0x200000
	1078	MS_REMOUNT = 0x20
	1079	MS_RMT_MASK = 0x2800051
	1080	MS_SHARED = 0x100000
	1081	MS_SILENT = 0x8000
	1082	MS_SLAVE = 0x80000
	1083	MS_STRICTATIME = 0x1000000
	1084	MS_SUBMOUNT = 0x4000000
	1085	MS_SYNC = 0x4
	1086	MS_SYNCHRONOUS = 0x10
	1087	MS_UNBINDABLE = 0x20000
	1088	MS_VERBOSE = 0x8000
	1089	MTD_INODE_FS_MAGIC = 0x11307854
	1090	NAME_MAX = 0xff
	1091	NCP_SUPER_MAGIC = 0x564c
	1092	NETLINK_ADD_MEMBERSHIP = 0x1
	1093	NETLINK_AUDIT = 0x9
	1094	NETLINK_BROADCAST_ERROR = 0x4
	1095	NETLINK_CAP_ACK = 0xa
	1096	NETLINK_CONNECTOR = 0xb
	1097	NETLINK_CRYPTO = 0x15
	1098	NETLINK_DNRTMSG = 0xe
	1099	NETLINK_DROP_MEMBERSHIP = 0x2
	1100	NETLINK_ECRYPTFS = 0x13
	1101	NETLINK_EXT_ACK = 0xb
	1102	NETLINK_FIB_LOOKUP = 0xa
	1103	NETLINK_FIREWALL = 0x3
	1104	NETLINK_GENERIC = 0x10
	1105	NETLINK_INET_DIAG = 0x4
	1106	NETLINK_IP6_FW = 0xd
	1107	NETLINK_ISCSI = 0x8
	1108	NETLINK_KOBJECT_UEVENT = 0xf
	1109	NETLINK_LISTEN_ALL_NSID = 0x8
	1110	NETLINK_LIST_MEMBERSHIPS = 0x9
	1111	NETLINK_NETFILTER = 0xc
	1112	NETLINK_NFLOG = 0x5
	1113	NETLINK_NO_ENOBUFS = 0x5
	1114	NETLINK_PKTINFO = 0x3
	1115	NETLINK_RDMA = 0x14
	1116	NETLINK_ROUTE = 0x0
	1117	NETLINK_RX_RING = 0x6
	1118	NETLINK_SCSITRANSPORT = 0x12
	1119	NETLINK_SELINUX = 0x7
	1120	NETLINK_SMC = 0x16
	1121	NETLINK_SOCK_DIAG = 0x4
	1122	NETLINK_TX_RING = 0x7
	1123	NETLINK_UNUSED = 0x1
	1124	NETLINK_USERSOCK = 0x2
	1125	NETLINK_XFRM = 0x6
	1126	NETNSA_MAX = 0x3
	1127	NETNSA_NSID_NOT_ASSIGNED = -0x1
	1128	NFNETLINK_V0 = 0x0
	1129	NFNLGRP_ACCT_QUOTA = 0x8
	1130	NFNLGRP_CONNTRACK_DESTROY = 0x3
	1131	NFNLGRP_CONNTRACK_EXP_DESTROY = 0x6
	1132	NFNLGRP_CONNTRACK_EXP_NEW = 0x4
	1133	NFNLGRP_CONNTRACK_EXP_UPDATE = 0x5
	1134	NFNLGRP_CONNTRACK_NEW = 0x1
	1135	NFNLGRP_CONNTRACK_UPDATE = 0x2
	1136	NFNLGRP_MAX = 0x9
	1137	NFNLGRP_NFTABLES = 0x7
	1138	NFNLGRP_NFTRACE = 0x9
	1139	NFNLGRP_NONE = 0x0
	1140	NFNL_BATCH_MAX = 0x1
	1141	NFNL_MSG_BATCH_BEGIN = 0x10
	1142	NFNL_MSG_BATCH_END = 0x11
	1143	NFNL_NFA_NEST = 0x8000
	1144	NFNL_SUBSYS_ACCT = 0x7
	1145	NFNL_SUBSYS_COUNT = 0xc
	1146	NFNL_SUBSYS_CTHELPER = 0x9
	1147	NFNL_SUBSYS_CTNETLINK = 0x1
	1148	NFNL_SUBSYS_CTNETLINK_EXP = 0x2
	1149	NFNL_SUBSYS_CTNETLINK_TIMEOUT = 0x8
	1150	NFNL_SUBSYS_IPSET = 0x6
	1151	NFNL_SUBSYS_NFTABLES = 0xa
	1152	NFNL_SUBSYS_NFT_COMPAT = 0xb
	1153	NFNL_SUBSYS_NONE = 0x0
	1154	NFNL_SUBSYS_OSF = 0x5
	1155	NFNL_SUBSYS_QUEUE = 0x3
	1156	NFNL_SUBSYS_ULOG = 0x4
	1157	NFS_SUPER_MAGIC = 0x6969
	1158	NILFS_SUPER_MAGIC = 0x3434
	1159	NL0 = 0x0
	1160	NL1 = 0x100
	1161	NLA_ALIGNTO = 0x4
	1162	NLA_F_NESTED = 0x8000
	1163	NLA_F_NET_BYTEORDER = 0x4000
	1164	NLA_HDRLEN = 0x4
	1165	NLDLY = 0x100
	1166	NLMSG_ALIGNTO = 0x4
	1167	NLMSG_DONE = 0x3
	1168	NLMSG_ERROR = 0x2
	1169	NLMSG_HDRLEN = 0x10
	1170	NLMSG_MIN_TYPE = 0x10
	1171	NLMSG_NOOP = 0x1
	1172	NLMSG_OVERRUN = 0x4
	1173	NLM_F_ACK = 0x4
	1174	NLM_F_ACK_TLVS = 0x200
	1175	NLM_F_APPEND = 0x800
	1176	NLM_F_ATOMIC = 0x400
	1177	NLM_F_CAPPED = 0x100
	1178	NLM_F_CREATE = 0x400
	1179	NLM_F_DUMP = 0x300
	1180	NLM_F_DUMP_FILTERED = 0x20
	1181	NLM_F_DUMP_INTR = 0x10
	1182	NLM_F_ECHO = 0x8
	1183	NLM_F_EXCL = 0x200
	1184	NLM_F_MATCH = 0x200
	1185	NLM_F_MULTI = 0x2
	1186	NLM_F_NONREC = 0x100
	1187	NLM_F_REPLACE = 0x100
	1188	NLM_F_REQUEST = 0x1
	1189	NLM_F_ROOT = 0x100
	1190	NOFLSH = 0x80
	1191	NSFS_MAGIC = 0x6e736673
	1192	OCFS2_SUPER_MAGIC = 0x7461636f
	1193	OCRNL = 0x8
	1194	OFDEL = 0x80
	1195	OFILL = 0x40
	1196	OLCUC = 0x2
	1197	ONLCR = 0x4
	1198	ONLRET = 0x20
	1199	ONOCR = 0x10
	1200	OPENPROM_SUPER_MAGIC = 0x9fa1
	1201	OPOST = 0x1
	1202	OVERLAYFS_SUPER_MAGIC = 0x794c7630
	1203	O_ACCMODE = 0x3
	1204	O_APPEND = 0x8
	1205	O_ASYNC = 0x40
	1206	O_CLOEXEC = 0x400000
	1207	O_CREAT = 0x200
	1208	O_DIRECT = 0x100000
	1209	O_DIRECTORY = 0x10000
	1210	O_DSYNC = 0x2000
	1211	O_EXCL = 0x800
	1212	O_FSYNC = 0x802000
	1213	O_LARGEFILE = 0x0
	1214	O_NDELAY = 0x4004
	1215	O_NOATIME = 0x200000
	1216	O_NOCTTY = 0x8000
	1217	O_NOFOLLOW = 0x20000
	1218	O_NONBLOCK = 0x4000
	1219	O_PATH = 0x1000000
	1220	O_RDONLY = 0x0
	1221	O_RDWR = 0x2
	1222	O_RSYNC = 0x802000
	1223	O_SYNC = 0x802000
	1224	O_TMPFILE = 0x2010000
	1225	O_TRUNC = 0x400
	1226	O_WRONLY = 0x1
	1227	PACKET_ADD_MEMBERSHIP = 0x1
	1228	PACKET_AUXDATA = 0x8
	1229	PACKET_BROADCAST = 0x1
	1230	PACKET_COPY_THRESH = 0x7
	1231	PACKET_DROP_MEMBERSHIP = 0x2
	1232	PACKET_FANOUT = 0x12
	1233	PACKET_FANOUT_CBPF = 0x6
	1234	PACKET_FANOUT_CPU = 0x2
	1235	PACKET_FANOUT_DATA = 0x16
	1236	PACKET_FANOUT_EBPF = 0x7
	1237	PACKET_FANOUT_FLAG_DEFRAG = 0x8000
	1238	PACKET_FANOUT_FLAG_ROLLOVER = 0x1000
	1239	PACKET_FANOUT_FLAG_UNIQUEID = 0x2000
	1240	PACKET_FANOUT_HASH = 0x0
	1241	PACKET_FANOUT_LB = 0x1
	1242	PACKET_FANOUT_QM = 0x5
	1243	PACKET_FANOUT_RND = 0x4
	1244	PACKET_FANOUT_ROLLOVER = 0x3
	1245	PACKET_FASTROUTE = 0x6
	1246	PACKET_HDRLEN = 0xb
	1247	PACKET_HOST = 0x0
	1248	PACKET_KERNEL = 0x7
	1249	PACKET_LOOPBACK = 0x5
	1250	PACKET_LOSS = 0xe
	1251	PACKET_MR_ALLMULTI = 0x2
	1252	PACKET_MR_MULTICAST = 0x0
	1253	PACKET_MR_PROMISC = 0x1
	1254	PACKET_MR_UNICAST = 0x3
	1255	PACKET_MULTICAST = 0x2
	1256	PACKET_ORIGDEV = 0x9
	1257	PACKET_OTHERHOST = 0x3
	1258	PACKET_OUTGOING = 0x4
	1259	PACKET_QDISC_BYPASS = 0x14
	1260	PACKET_RECV_OUTPUT = 0x3
	1261	PACKET_RESERVE = 0xc
	1262	PACKET_ROLLOVER_STATS = 0x15
	1263	PACKET_RX_RING = 0x5
	1264	PACKET_STATISTICS = 0x6
	1265	PACKET_TIMESTAMP = 0x11
	1266	PACKET_TX_HAS_OFF = 0x13
	1267	PACKET_TX_RING = 0xd
	1268	PACKET_TX_TIMESTAMP = 0x10
	1269	PACKET_USER = 0x6
	1270	PACKET_VERSION = 0xa
	1271	PACKET_VNET_HDR = 0xf
	1272	PARENB = 0x100
	1273	PARITY_CRC16_PR0 = 0x2
	1274	PARITY_CRC16_PR0_CCITT = 0x4
	1275	PARITY_CRC16_PR1 = 0x3
	1276	PARITY_CRC16_PR1_CCITT = 0x5
	1277	PARITY_CRC32_PR0_CCITT = 0x6
	1278	PARITY_CRC32_PR1_CCITT = 0x7
	1279	PARITY_DEFAULT = 0x0
	1280	PARITY_NONE = 0x1
	1281	PARMRK = 0x8
	1282	PARODD = 0x200
	1283	PENDIN = 0x4000
	1284	PERF_EVENT_IOC_DISABLE = 0x20002401
	1285	PERF_EVENT_IOC_ENABLE = 0x20002400
	1286	PERF_EVENT_IOC_ID = 0x40082407
	1287	PERF_EVENT_IOC_MODIFY_ATTRIBUTES = 0x8008240b
	1288	PERF_EVENT_IOC_PAUSE_OUTPUT = 0x80042409
	1289	PERF_EVENT_IOC_PERIOD = 0x80082404
	1290	PERF_EVENT_IOC_QUERY_BPF = 0xc008240a
	1291	PERF_EVENT_IOC_REFRESH = 0x20002402
	1292	PERF_EVENT_IOC_RESET = 0x20002403
	1293	PERF_EVENT_IOC_SET_BPF = 0x80042408
	1294	PERF_EVENT_IOC_SET_FILTER = 0x80082406
	1295	PERF_EVENT_IOC_SET_OUTPUT = 0x20002405
	1296	PIPEFS_MAGIC = 0x50495045
	1297	PPPIOCATTACH = 0x8004743d
	1298	PPPIOCATTCHAN = 0x80047438
	1299	PPPIOCCONNECT = 0x8004743a
	1300	PPPIOCDETACH = 0x8004743c
	1301	PPPIOCDISCONN = 0x20007439
	1302	PPPIOCGASYNCMAP = 0x40047458
	1303	PPPIOCGCHAN = 0x40047437
	1304	PPPIOCGDEBUG = 0x40047441
	1305	PPPIOCGFLAGS = 0x4004745a
	1306	PPPIOCGIDLE = 0x4010743f
	1307	PPPIOCGL2TPSTATS = 0x40487436
	1308	PPPIOCGMRU = 0x40047453
	1309	PPPIOCGNPMODE = 0xc008744c
	1310	PPPIOCGRASYNCMAP = 0x40047455
	1311	PPPIOCGUNIT = 0x40047456
	1312	PPPIOCGXASYNCMAP = 0x40207450
	1313	PPPIOCNEWUNIT = 0xc004743e
	1314	PPPIOCSACTIVE = 0x80107446
	1315	PPPIOCSASYNCMAP = 0x80047457
	1316	PPPIOCSCOMPRESS = 0x8010744d
	1317	PPPIOCSDEBUG = 0x80047440
	1318	PPPIOCSFLAGS = 0x80047459
	1319	PPPIOCSMAXCID = 0x80047451
	1320	PPPIOCSMRRU = 0x8004743b
	1321	PPPIOCSMRU = 0x80047452
	1322	PPPIOCSNPMODE = 0x8008744b
	1323	PPPIOCSPASS = 0x80107447
	1324	PPPIOCSRASYNCMAP = 0x80047454
	1325	PPPIOCSXASYNCMAP = 0x8020744f
	1326	PPPIOCXFERUNIT = 0x2000744e
	1327	PRIO_PGRP = 0x1
	1328	PRIO_PROCESS = 0x0
	1329	PRIO_USER = 0x2
	1330	PROC_SUPER_MAGIC = 0x9fa0
	1331	PROT_EXEC = 0x4
	1332	PROT_GROWSDOWN = 0x1000000
	1333	PROT_GROWSUP = 0x2000000
	1334	PROT_NONE = 0x0
	1335	PROT_READ = 0x1
	1336	PROT_WRITE = 0x2
	1337	PR_CAPBSET_DROP = 0x18
	1338	PR_CAPBSET_READ = 0x17
	1339	PR_CAP_AMBIENT = 0x2f
	1340	PR_CAP_AMBIENT_CLEAR_ALL = 0x4
	1341	PR_CAP_AMBIENT_IS_SET = 0x1
	1342	PR_CAP_AMBIENT_LOWER = 0x3
	1343	PR_CAP_AMBIENT_RAISE = 0x2
	1344	PR_ENDIAN_BIG = 0x0
	1345	PR_ENDIAN_LITTLE = 0x1
	1346	PR_ENDIAN_PPC_LITTLE = 0x2
	1347	PR_FPEMU_NOPRINT = 0x1
	1348	PR_FPEMU_SIGFPE = 0x2
	1349	PR_FP_EXC_ASYNC = 0x2
	1350	PR_FP_EXC_DISABLED = 0x0
	1351	PR_FP_EXC_DIV = 0x10000
	1352	PR_FP_EXC_INV = 0x100000
	1353	PR_FP_EXC_NONRECOV = 0x1
	1354	PR_FP_EXC_OVF = 0x20000
	1355	PR_FP_EXC_PRECISE = 0x3
	1356	PR_FP_EXC_RES = 0x80000
	1357	PR_FP_EXC_SW_ENABLE = 0x80
	1358	PR_FP_EXC_UND = 0x40000
	1359	PR_FP_MODE_FR = 0x1
	1360	PR_FP_MODE_FRE = 0x2
	1361	PR_GET_CHILD_SUBREAPER = 0x25
	1362	PR_GET_DUMPABLE = 0x3
	1363	PR_GET_ENDIAN = 0x13
	1364	PR_GET_FPEMU = 0x9
	1365	PR_GET_FPEXC = 0xb
	1366	PR_GET_FP_MODE = 0x2e
	1367	PR_GET_KEEPCAPS = 0x7
	1368	PR_GET_NAME = 0x10
	1369	PR_GET_NO_NEW_PRIVS = 0x27
	1370	PR_GET_PDEATHSIG = 0x2
	1371	PR_GET_SECCOMP = 0x15
	1372	PR_GET_SECUREBITS = 0x1b
	1373	PR_GET_SPECULATION_CTRL = 0x34
	1374	PR_GET_THP_DISABLE = 0x2a
	1375	PR_GET_TID_ADDRESS = 0x28
	1376	PR_GET_TIMERSLACK = 0x1e
	1377	PR_GET_TIMING = 0xd
	1378	PR_GET_TSC = 0x19
	1379	PR_GET_UNALIGN = 0x5
	1380	PR_MCE_KILL = 0x21
	1381	PR_MCE_KILL_CLEAR = 0x0
	1382	PR_MCE_KILL_DEFAULT = 0x2
	1383	PR_MCE_KILL_EARLY = 0x1
	1384	PR_MCE_KILL_GET = 0x22
	1385	PR_MCE_KILL_LATE = 0x0
	1386	PR_MCE_KILL_SET = 0x1
	1387	PR_MPX_DISABLE_MANAGEMENT = 0x2c
	1388	PR_MPX_ENABLE_MANAGEMENT = 0x2b
	1389	PR_SET_CHILD_SUBREAPER = 0x24
	1390	PR_SET_DUMPABLE = 0x4
	1391	PR_SET_ENDIAN = 0x14
	1392	PR_SET_FPEMU = 0xa
	1393	PR_SET_FPEXC = 0xc
	1394	PR_SET_FP_MODE = 0x2d
	1395	PR_SET_KEEPCAPS = 0x8
	1396	PR_SET_MM = 0x23
	1397	PR_SET_MM_ARG_END = 0x9
	1398	PR_SET_MM_ARG_START = 0x8
	1399	PR_SET_MM_AUXV = 0xc
	1400	PR_SET_MM_BRK = 0x7
	1401	PR_SET_MM_END_CODE = 0x2
	1402	PR_SET_MM_END_DATA = 0x4
	1403	PR_SET_MM_ENV_END = 0xb
	1404	PR_SET_MM_ENV_START = 0xa
	1405	PR_SET_MM_EXE_FILE = 0xd
	1406	PR_SET_MM_MAP = 0xe
	1407	PR_SET_MM_MAP_SIZE = 0xf
	1408	PR_SET_MM_START_BRK = 0x6
	1409	PR_SET_MM_START_CODE = 0x1
	1410	PR_SET_MM_START_DATA = 0x3
	1411	PR_SET_MM_START_STACK = 0x5
	1412	PR_SET_NAME = 0xf
	1413	PR_SET_NO_NEW_PRIVS = 0x26
	1414	PR_SET_PDEATHSIG = 0x1
	1415	PR_SET_PTRACER = 0x59616d61
	1416	PR_SET_PTRACER_ANY = 0xffffffffffffffff
	1417	PR_SET_SECCOMP = 0x16
	1418	PR_SET_SECUREBITS = 0x1c
	1419	PR_SET_SPECULATION_CTRL = 0x35
	1420	PR_SET_THP_DISABLE = 0x29
	1421	PR_SET_TIMERSLACK = 0x1d
	1422	PR_SET_TIMING = 0xe
	1423	PR_SET_TSC = 0x1a
	1424	PR_SET_UNALIGN = 0x6
	1425	PR_SPEC_DISABLE = 0x4
	1426	PR_SPEC_ENABLE = 0x2
	1427	PR_SPEC_FORCE_DISABLE = 0x8
	1428	PR_SPEC_NOT_AFFECTED = 0x0
	1429	PR_SPEC_PRCTL = 0x1
	1430	PR_SPEC_STORE_BYPASS = 0x0
	1431	PR_SVE_GET_VL = 0x33
	1432	PR_SVE_SET_VL = 0x32
	1433	PR_SVE_SET_VL_ONEXEC = 0x40000
	1434	PR_SVE_VL_INHERIT = 0x20000
	1435	PR_SVE_VL_LEN_MASK = 0xffff
	1436	PR_TASK_PERF_EVENTS_DISABLE = 0x1f
	1437	PR_TASK_PERF_EVENTS_ENABLE = 0x20
	1438	PR_TIMING_STATISTICAL = 0x0
	1439	PR_TIMING_TIMESTAMP = 0x1
	1440	PR_TSC_ENABLE = 0x1
	1441	PR_TSC_SIGSEGV = 0x2
	1442	PR_UNALIGN_NOPRINT = 0x1
	1443	PR_UNALIGN_SIGBUS = 0x2
	1444	PSTOREFS_MAGIC = 0x6165676c
	1445	PTRACE_ATTACH = 0x10
	1446	PTRACE_CONT = 0x7
	1447	PTRACE_DETACH = 0x11
	1448	PTRACE_EVENT_CLONE = 0x3
	1449	PTRACE_EVENT_EXEC = 0x4
	1450	PTRACE_EVENT_EXIT = 0x6
	1451	PTRACE_EVENT_FORK = 0x1
	1452	PTRACE_EVENT_SECCOMP = 0x7
	1453	PTRACE_EVENT_STOP = 0x80
	1454	PTRACE_EVENT_VFORK = 0x2
	1455	PTRACE_EVENT_VFORK_DONE = 0x5
	1456	PTRACE_GETEVENTMSG = 0x4201
	1457	PTRACE_GETFPAREGS = 0x14
	1458	PTRACE_GETFPREGS = 0xe
	1459	PTRACE_GETFPREGS64 = 0x19
	1460	PTRACE_GETREGS = 0xc
	1461	PTRACE_GETREGS64 = 0x16
	1462	PTRACE_GETREGSET = 0x4204
	1463	PTRACE_GETSIGINFO = 0x4202
	1464	PTRACE_GETSIGMASK = 0x420a
	1465	PTRACE_INTERRUPT = 0x4207
	1466	PTRACE_KILL = 0x8
	1467	PTRACE_LISTEN = 0x4208
	1468	PTRACE_O_EXITKILL = 0x100000
	1469	PTRACE_O_MASK = 0x3000ff
	1470	PTRACE_O_SUSPEND_SECCOMP = 0x200000
	1471	PTRACE_O_TRACECLONE = 0x8
	1472	PTRACE_O_TRACEEXEC = 0x10
	1473	PTRACE_O_TRACEEXIT = 0x40
	1474	PTRACE_O_TRACEFORK = 0x2
	1475	PTRACE_O_TRACESECCOMP = 0x80
	1476	PTRACE_O_TRACESYSGOOD = 0x1
	1477	PTRACE_O_TRACEVFORK = 0x4
	1478	PTRACE_O_TRACEVFORKDONE = 0x20
	1479	PTRACE_PEEKDATA = 0x2
	1480	PTRACE_PEEKSIGINFO = 0x4209
	1481	PTRACE_PEEKSIGINFO_SHARED = 0x1
	1482	PTRACE_PEEKTEXT = 0x1
	1483	PTRACE_PEEKUSR = 0x3
	1484	PTRACE_POKEDATA = 0x5
	1485	PTRACE_POKETEXT = 0x4
	1486	PTRACE_POKEUSR = 0x6
	1487	PTRACE_READDATA = 0x10
	1488	PTRACE_READTEXT = 0x12
	1489	PTRACE_SECCOMP_GET_FILTER = 0x420c
	1490	PTRACE_SECCOMP_GET_METADATA = 0x420d
	1491	PTRACE_SEIZE = 0x4206
	1492	PTRACE_SETFPAREGS = 0x15
	1493	PTRACE_SETFPREGS = 0xf
	1494	PTRACE_SETFPREGS64 = 0x1a
	1495	PTRACE_SETOPTIONS = 0x4200
	1496	PTRACE_SETREGS = 0xd
	1497	PTRACE_SETREGS64 = 0x17
	1498	PTRACE_SETREGSET = 0x4205
	1499	PTRACE_SETSIGINFO = 0x4203
	1500	PTRACE_SETSIGMASK = 0x420b
	1501	PTRACE_SINGLESTEP = 0x9
	1502	PTRACE_SPARC_DETACH = 0xb
	1503	PTRACE_SYSCALL = 0x18
	1504	PTRACE_TRACEME = 0x0
	1505	PTRACE_WRITEDATA = 0x11
	1506	PTRACE_WRITETEXT = 0x13
	1507	PT_FP = 0x48
	1508	PT_G0 = 0x10
	1509	PT_G1 = 0x14
	1510	PT_G2 = 0x18
	1511	PT_G3 = 0x1c
	1512	PT_G4 = 0x20
	1513	PT_G5 = 0x24
	1514	PT_G6 = 0x28
	1515	PT_G7 = 0x2c
	1516	PT_I0 = 0x30
	1517	PT_I1 = 0x34
	1518	PT_I2 = 0x38
	1519	PT_I3 = 0x3c
	1520	PT_I4 = 0x40
	1521	PT_I5 = 0x44
	1522	PT_I6 = 0x48
	1523	PT_I7 = 0x4c
	1524	PT_NPC = 0x8
	1525	PT_PC = 0x4
	1526	PT_PSR = 0x0
	1527	PT_REGS_MAGIC = 0x57ac6c00
	1528	PT_TNPC = 0x90
	1529	PT_TPC = 0x88
	1530	PT_TSTATE = 0x80
	1531	PT_V9_FP = 0x70
	1532	PT_V9_G0 = 0x0
	1533	PT_V9_G1 = 0x8
	1534	PT_V9_G2 = 0x10
	1535	PT_V9_G3 = 0x18
	1536	PT_V9_G4 = 0x20
	1537	PT_V9_G5 = 0x28
	1538	PT_V9_G6 = 0x30
	1539	PT_V9_G7 = 0x38
	1540	PT_V9_I0 = 0x40
	1541	PT_V9_I1 = 0x48
	1542	PT_V9_I2 = 0x50
	1543	PT_V9_I3 = 0x58
	1544	PT_V9_I4 = 0x60
	1545	PT_V9_I5 = 0x68
	1546	PT_V9_I6 = 0x70
	1547	PT_V9_I7 = 0x78
	1548	PT_V9_MAGIC = 0x9c
	1549	PT_V9_TNPC = 0x90
	1550	PT_V9_TPC = 0x88
	1551	PT_V9_TSTATE = 0x80
	1552	PT_V9_Y = 0x98
	1553	PT_WIM = 0x10
	1554	PT_Y = 0xc
	1555	QNX4_SUPER_MAGIC = 0x2f
	1556	QNX6_SUPER_MAGIC = 0x68191122
	1557	RAMFS_MAGIC = 0x858458f6
	1558	RDTGROUP_SUPER_MAGIC = 0x7655821
	1559	REISERFS_SUPER_MAGIC = 0x52654973
	1560	RENAME_EXCHANGE = 0x2
	1561	RENAME_NOREPLACE = 0x1
	1562	RENAME_WHITEOUT = 0x4
	1563	RLIMIT_AS = 0x9
	1564	RLIMIT_CORE = 0x4
	1565	RLIMIT_CPU = 0x0
	1566	RLIMIT_DATA = 0x2
	1567	RLIMIT_FSIZE = 0x1
	1568	RLIMIT_LOCKS = 0xa
	1569	RLIMIT_MEMLOCK = 0x8
	1570	RLIMIT_MSGQUEUE = 0xc
	1571	RLIMIT_NICE = 0xd
	1572	RLIMIT_NOFILE = 0x6
	1573	RLIMIT_NPROC = 0x7
	1574	RLIMIT_RSS = 0x5
	1575	RLIMIT_RTPRIO = 0xe
	1576	RLIMIT_RTTIME = 0xf
	1577	RLIMIT_SIGPENDING = 0xb
	1578	RLIMIT_STACK = 0x3
	1579	RLIM_INFINITY = 0xffffffffffffffff
	1580	RTAX_ADVMSS = 0x8
	1581	RTAX_CC_ALGO = 0x10
	1582	RTAX_CWND = 0x7
	1583	RTAX_FASTOPEN_NO_COOKIE = 0x11
	1584	RTAX_FEATURES = 0xc
	1585	RTAX_FEATURE_ALLFRAG = 0x8
	1586	RTAX_FEATURE_ECN = 0x1
	1587	RTAX_FEATURE_MASK = 0xf
	1588	RTAX_FEATURE_SACK = 0x2
	1589	RTAX_FEATURE_TIMESTAMP = 0x4
	1590	RTAX_HOPLIMIT = 0xa
	1591	RTAX_INITCWND = 0xb
	1592	RTAX_INITRWND = 0xe
	1593	RTAX_LOCK = 0x1
	1594	RTAX_MAX = 0x11
	1595	RTAX_MTU = 0x2
	1596	RTAX_QUICKACK = 0xf
	1597	RTAX_REORDERING = 0x9
	1598	RTAX_RTO_MIN = 0xd
	1599	RTAX_RTT = 0x4
	1600	RTAX_RTTVAR = 0x5
	1601	RTAX_SSTHRESH = 0x6
	1602	RTAX_UNSPEC = 0x0
	1603	RTAX_WINDOW = 0x3
	1604	RTA_ALIGNTO = 0x4
	1605	RTA_MAX = 0x1d
	1606	RTCF_DIRECTSRC = 0x4000000
	1607	RTCF_DOREDIRECT = 0x1000000
	1608	RTCF_LOG = 0x2000000
	1609	RTCF_MASQ = 0x400000
	1610	RTCF_NAT = 0x800000
	1611	RTCF_VALVE = 0x200000
	1612	RTC_AF = 0x20
	1613	RTC_AIE_OFF = 0x20007002
	1614	RTC_AIE_ON = 0x20007001
	1615	RTC_ALM_READ = 0x40247008
	1616	RTC_ALM_SET = 0x80247007
	1617	RTC_EPOCH_READ = 0x4008700d
	1618	RTC_EPOCH_SET = 0x8008700e
	1619	RTC_IRQF = 0x80
	1620	RTC_IRQP_READ = 0x4008700b
	1621	RTC_IRQP_SET = 0x8008700c
	1622	RTC_MAX_FREQ = 0x2000
	1623	RTC_PF = 0x40
	1624	RTC_PIE_OFF = 0x20007006
	1625	RTC_PIE_ON = 0x20007005
	1626	RTC_PLL_GET = 0x40207011
	1627	RTC_PLL_SET = 0x80207012
	1628	RTC_RD_TIME = 0x40247009
	1629	RTC_SET_TIME = 0x8024700a
	1630	RTC_UF = 0x10
	1631	RTC_UIE_OFF = 0x20007004
	1632	RTC_UIE_ON = 0x20007003
	1633	RTC_VL_CLR = 0x20007014
	1634	RTC_VL_READ = 0x40047013
	1635	RTC_WIE_OFF = 0x20007010
	1636	RTC_WIE_ON = 0x2000700f
	1637	RTC_WKALM_RD = 0x40287010
	1638	RTC_WKALM_SET = 0x8028700f
	1639	RTF_ADDRCLASSMASK = 0xf8000000
	1640	RTF_ADDRCONF = 0x40000
	1641	RTF_ALLONLINK = 0x20000
	1642	RTF_BROADCAST = 0x10000000
	1643	RTF_CACHE = 0x1000000
	1644	RTF_DEFAULT = 0x10000
	1645	RTF_DYNAMIC = 0x10
	1646	RTF_FLOW = 0x2000000
	1647	RTF_GATEWAY = 0x2
	1648	RTF_HOST = 0x4
	1649	RTF_INTERFACE = 0x40000000
	1650	RTF_IRTT = 0x100
	1651	RTF_LINKRT = 0x100000
	1652	RTF_LOCAL = 0x80000000
	1653	RTF_MODIFIED = 0x20
	1654	RTF_MSS = 0x40
	1655	RTF_MTU = 0x40
	1656	RTF_MULTICAST = 0x20000000
	1657	RTF_NAT = 0x8000000
	1658	RTF_NOFORWARD = 0x1000
	1659	RTF_NONEXTHOP = 0x200000
	1660	RTF_NOPMTUDISC = 0x4000
	1661	RTF_POLICY = 0x4000000
	1662	RTF_REINSTATE = 0x8
	1663	RTF_REJECT = 0x200
	1664	RTF_STATIC = 0x400
	1665	RTF_THROW = 0x2000
	1666	RTF_UP = 0x1
	1667	RTF_WINDOW = 0x80
	1668	RTF_XRESOLVE = 0x800
	1669	RTM_BASE = 0x10
	1670	RTM_DELACTION = 0x31
	1671	RTM_DELADDR = 0x15
	1672	RTM_DELADDRLABEL = 0x49
	1673	RTM_DELCHAIN = 0x65
	1674	RTM_DELLINK = 0x11
	1675	RTM_DELMDB = 0x55
	1676	RTM_DELNEIGH = 0x1d
	1677	RTM_DELNETCONF = 0x51
	1678	RTM_DELNSID = 0x59
	1679	RTM_DELQDISC = 0x25
	1680	RTM_DELROUTE = 0x19
	1681	RTM_DELRULE = 0x21
	1682	RTM_DELTCLASS = 0x29
	1683	RTM_DELTFILTER = 0x2d
	1684	RTM_F_CLONED = 0x200
	1685	RTM_F_EQUALIZE = 0x400
	1686	RTM_F_FIB_MATCH = 0x2000
	1687	RTM_F_LOOKUP_TABLE = 0x1000
	1688	RTM_F_NOTIFY = 0x100
	1689	RTM_F_PREFIX = 0x800
	1690	RTM_GETACTION = 0x32
	1691	RTM_GETADDR = 0x16
	1692	RTM_GETADDRLABEL = 0x4a
	1693	RTM_GETANYCAST = 0x3e
	1694	RTM_GETCHAIN = 0x66
	1695	RTM_GETDCB = 0x4e
	1696	RTM_GETLINK = 0x12
	1697	RTM_GETMDB = 0x56
	1698	RTM_GETMULTICAST = 0x3a
	1699	RTM_GETNEIGH = 0x1e
	1700	RTM_GETNEIGHTBL = 0x42
	1701	RTM_GETNETCONF = 0x52
	1702	RTM_GETNSID = 0x5a
	1703	RTM_GETQDISC = 0x26
	1704	RTM_GETROUTE = 0x1a
	1705	RTM_GETRULE = 0x22
	1706	RTM_GETSTATS = 0x5e
	1707	RTM_GETTCLASS = 0x2a
	1708	RTM_GETTFILTER = 0x2e
	1709	RTM_MAX = 0x67
	1710	RTM_NEWACTION = 0x30
	1711	RTM_NEWADDR = 0x14
	1712	RTM_NEWADDRLABEL = 0x48
	1713	RTM_NEWCACHEREPORT = 0x60
	1714	RTM_NEWCHAIN = 0x64
	1715	RTM_NEWLINK = 0x10
	1716	RTM_NEWMDB = 0x54
	1717	RTM_NEWNDUSEROPT = 0x44
	1718	RTM_NEWNEIGH = 0x1c
	1719	RTM_NEWNEIGHTBL = 0x40
	1720	RTM_NEWNETCONF = 0x50
	1721	RTM_NEWNSID = 0x58
	1722	RTM_NEWPREFIX = 0x34
	1723	RTM_NEWQDISC = 0x24
	1724	RTM_NEWROUTE = 0x18
	1725	RTM_NEWRULE = 0x20
	1726	RTM_NEWSTATS = 0x5c
	1727	RTM_NEWTCLASS = 0x28
	1728	RTM_NEWTFILTER = 0x2c
	1729	RTM_NR_FAMILIES = 0x16
	1730	RTM_NR_MSGTYPES = 0x58
	1731	RTM_SETDCB = 0x4f
	1732	RTM_SETLINK = 0x13
	1733	RTM_SETNEIGHTBL = 0x43
	1734	RTNH_ALIGNTO = 0x4
	1735	RTNH_COMPARE_MASK = 0x19
	1736	RTNH_F_DEAD = 0x1
	1737	RTNH_F_LINKDOWN = 0x10
	1738	RTNH_F_OFFLOAD = 0x8
	1739	RTNH_F_ONLINK = 0x4
	1740	RTNH_F_PERVASIVE = 0x2
	1741	RTNH_F_UNRESOLVED = 0x20
	1742	RTN_MAX = 0xb
	1743	RTPROT_BABEL = 0x2a
	1744	RTPROT_BGP = 0xba
	1745	RTPROT_BIRD = 0xc
	1746	RTPROT_BOOT = 0x3
	1747	RTPROT_DHCP = 0x10
	1748	RTPROT_DNROUTED = 0xd
	1749	RTPROT_EIGRP = 0xc0
	1750	RTPROT_GATED = 0x8
	1751	RTPROT_ISIS = 0xbb
	1752	RTPROT_KERNEL = 0x2
	1753	RTPROT_MROUTED = 0x11
	1754	RTPROT_MRT = 0xa
	1755	RTPROT_NTK = 0xf
	1756	RTPROT_OSPF = 0xbc
	1757	RTPROT_RA = 0x9
	1758	RTPROT_REDIRECT = 0x1
	1759	RTPROT_RIP = 0xbd
	1760	RTPROT_STATIC = 0x4
	1761	RTPROT_UNSPEC = 0x0
	1762	RTPROT_XORP = 0xe
	1763	RTPROT_ZEBRA = 0xb
	1764	RT_CLASS_DEFAULT = 0xfd
	1765	RT_CLASS_LOCAL = 0xff
	1766	RT_CLASS_MAIN = 0xfe
	1767	RT_CLASS_MAX = 0xff
	1768	RT_CLASS_UNSPEC = 0x0
	1769	RUSAGE_CHILDREN = -0x1
	1770	RUSAGE_SELF = 0x0
	1771	RUSAGE_THREAD = 0x1
	1772	SCM_CREDENTIALS = 0x2
	1773	SCM_RIGHTS = 0x1
	1774	SCM_TIMESTAMP = 0x1d
	1775	SCM_TIMESTAMPING = 0x23
	1776	SCM_TIMESTAMPING_OPT_STATS = 0x38
	1777	SCM_TIMESTAMPING_PKTINFO = 0x3c
	1778	SCM_TIMESTAMPNS = 0x21
	1779	SCM_TXTIME = 0x3f
	1780	SCM_WIFI_STATUS = 0x25
	1781	SC_LOG_FLUSH = 0x100000
	1782	SECCOMP_MODE_DISABLED = 0x0
	1783	SECCOMP_MODE_FILTER = 0x2
	1784	SECCOMP_MODE_STRICT = 0x1
	1785	SECURITYFS_MAGIC = 0x73636673
	1786	SELINUX_MAGIC = 0xf97cff8c
	1787	SHUT_RD = 0x0
	1788	SHUT_RDWR = 0x2
	1789	SHUT_WR = 0x1
	1790	SIOCADDDLCI = 0x8980
	1791	SIOCADDMULTI = 0x8931
	1792	SIOCADDRT = 0x890b
	1793	SIOCATMARK = 0x8905
	1794	SIOCBONDCHANGEACTIVE = 0x8995
	1795	SIOCBONDENSLAVE = 0x8990
	1796	SIOCBONDINFOQUERY = 0x8994
	1797	SIOCBONDRELEASE = 0x8991
	1798	SIOCBONDSETHWADDR = 0x8992
	1799	SIOCBONDSLAVEINFOQUERY = 0x8993
	1800	SIOCBRADDBR = 0x89a0
	1801	SIOCBRADDIF = 0x89a2
	1802	SIOCBRDELBR = 0x89a1
	1803	SIOCBRDELIF = 0x89a3
	1804	SIOCDARP = 0x8953
	1805	SIOCDELDLCI = 0x8981
	1806	SIOCDELMULTI = 0x8932
	1807	SIOCDELRT = 0x890c
	1808	SIOCDEVPRIVATE = 0x89f0
	1809	SIOCDIFADDR = 0x8936
	1810	SIOCDRARP = 0x8960
	1811	SIOCETHTOOL = 0x8946
	1812	SIOCGARP = 0x8954
	1813	SIOCGHWTSTAMP = 0x89b1
	1814	SIOCGIFADDR = 0x8915
	1815	SIOCGIFBR = 0x8940
	1816	SIOCGIFBRDADDR = 0x8919
	1817	SIOCGIFCONF = 0x8912
	1818	SIOCGIFCOUNT = 0x8938
	1819	SIOCGIFDSTADDR = 0x8917
	1820	SIOCGIFENCAP = 0x8925
	1821	SIOCGIFFLAGS = 0x8913
	1822	SIOCGIFHWADDR = 0x8927
	1823	SIOCGIFINDEX = 0x8933
	1824	SIOCGIFMAP = 0x8970
	1825	SIOCGIFMEM = 0x891f
	1826	SIOCGIFMETRIC = 0x891d
	1827	SIOCGIFMTU = 0x8921
	1828	SIOCGIFNAME = 0x8910
	1829	SIOCGIFNETMASK = 0x891b
	1830	SIOCGIFPFLAGS = 0x8935
	1831	SIOCGIFSLAVE = 0x8929
	1832	SIOCGIFTXQLEN = 0x8942
	1833	SIOCGIFVLAN = 0x8982
	1834	SIOCGMIIPHY = 0x8947
	1835	SIOCGMIIREG = 0x8948
	1836	SIOCGPGRP = 0x8904
	1837	SIOCGPPPCSTATS = 0x89f2
	1838	SIOCGPPPSTATS = 0x89f0
	1839	SIOCGPPPVER = 0x89f1
	1840	SIOCGRARP = 0x8961
	1841	SIOCGSKNS = 0x894c
	1842	SIOCGSTAMP = 0x8906
	1843	SIOCGSTAMPNS = 0x8907
	1844	SIOCINQ = 0x4004667f
	1845	SIOCOUTQ = 0x40047473
	1846	SIOCOUTQNSD = 0x894b
	1847	SIOCPROTOPRIVATE = 0x89e0
	1848	SIOCRTMSG = 0x890d
	1849	SIOCSARP = 0x8955
	1850	SIOCSHWTSTAMP = 0x89b0
	1851	SIOCSIFADDR = 0x8916
	1852	SIOCSIFBR = 0x8941
	1853	SIOCSIFBRDADDR = 0x891a
	1854	SIOCSIFDSTADDR = 0x8918
	1855	SIOCSIFENCAP = 0x8926
	1856	SIOCSIFFLAGS = 0x8914
	1857	SIOCSIFHWADDR = 0x8924
	1858	SIOCSIFHWBROADCAST = 0x8937
	1859	SIOCSIFLINK = 0x8911
	1860	SIOCSIFMAP = 0x8971
	1861	SIOCSIFMEM = 0x8920
	1862	SIOCSIFMETRIC = 0x891e
	1863	SIOCSIFMTU = 0x8922
	1864	SIOCSIFNAME = 0x8923
	1865	SIOCSIFNETMASK = 0x891c
	1866	SIOCSIFPFLAGS = 0x8934
	1867	SIOCSIFSLAVE = 0x8930
	1868	SIOCSIFTXQLEN = 0x8943
	1869	SIOCSIFVLAN = 0x8983
	1870	SIOCSMIIREG = 0x8949
	1871	SIOCSPGRP = 0x8902
	1872	SIOCSRARP = 0x8962
	1873	SIOCWANDEV = 0x894a
	1874	SMACK_MAGIC = 0x43415d53
	1875	SMART_AUTOSAVE = 0xd2
	1876	SMART_AUTO_OFFLINE = 0xdb
	1877	SMART_DISABLE = 0xd9
	1878	SMART_ENABLE = 0xd8
	1879	SMART_HCYL_PASS = 0xc2
	1880	SMART_IMMEDIATE_OFFLINE = 0xd4
	1881	SMART_LCYL_PASS = 0x4f
	1882	SMART_READ_LOG_SECTOR = 0xd5
	1883	SMART_READ_THRESHOLDS = 0xd1
	1884	SMART_READ_VALUES = 0xd0
	1885	SMART_SAVE = 0xd3
	1886	SMART_STATUS = 0xda
	1887	SMART_WRITE_LOG_SECTOR = 0xd6
	1888	SMART_WRITE_THRESHOLDS = 0xd7
	1889	SMB_SUPER_MAGIC = 0x517b
	1890	SOCKFS_MAGIC = 0x534f434b
	1891	SOCK_CLOEXEC = 0x400000
	1892	SOCK_DCCP = 0x6
	1893	SOCK_DGRAM = 0x2
	1894	SOCK_IOC_TYPE = 0x89
	1895	SOCK_NONBLOCK = 0x4000
	1896	SOCK_PACKET = 0xa
	1897	SOCK_RAW = 0x3
	1898	SOCK_RDM = 0x4
	1899	SOCK_SEQPACKET = 0x5
	1900	SOCK_STREAM = 0x1
	1901	SOL_AAL = 0x109
	1902	SOL_ALG = 0x117
	1903	SOL_ATM = 0x108
	1904	SOL_CAIF = 0x116
	1905	SOL_CAN_BASE = 0x64
	1906	SOL_DCCP = 0x10d
	1907	SOL_DECNET = 0x105
	1908	SOL_ICMPV6 = 0x3a
	1909	SOL_IP = 0x0
	1910	SOL_IPV6 = 0x29
	1911	SOL_IRDA = 0x10a
	1912	SOL_IUCV = 0x115
	1913	SOL_KCM = 0x119
	1914	SOL_LLC = 0x10c
	1915	SOL_NETBEUI = 0x10b
	1916	SOL_NETLINK = 0x10e
	1917	SOL_NFC = 0x118
	1918	SOL_PACKET = 0x107
	1919	SOL_PNPIPE = 0x113
	1920	SOL_PPPOL2TP = 0x111
	1921	SOL_RAW = 0xff
	1922	SOL_RDS = 0x114
	1923	SOL_RXRPC = 0x110
	1924	SOL_SOCKET = 0xffff
	1925	SOL_TCP = 0x6
	1926	SOL_TIPC = 0x10f
	1927	SOL_TLS = 0x11a
	1928	SOL_X25 = 0x106
	1929	SOL_XDP = 0x11b
	1930	SOMAXCONN = 0x80
	1931	SO_ACCEPTCONN = 0x8000
	1932	SO_ATTACH_BPF = 0x34
	1933	SO_ATTACH_FILTER = 0x1a
	1934	SO_ATTACH_REUSEPORT_CBPF = 0x35
	1935	SO_ATTACH_REUSEPORT_EBPF = 0x36
	1936	SO_BINDTODEVICE = 0xd
	1937	SO_BPF_EXTENSIONS = 0x32
	1938	SO_BROADCAST = 0x20
	1939	SO_BSDCOMPAT = 0x400
	1940	SO_BUSY_POLL = 0x30
	1941	SO_CNX_ADVICE = 0x37
	1942	SO_COOKIE = 0x3b
	1943	SO_DEBUG = 0x1
	1944	SO_DETACH_BPF = 0x1b
	1945	SO_DETACH_FILTER = 0x1b
	1946	SO_DOMAIN = 0x1029
	1947	SO_DONTROUTE = 0x10
	1948	SO_ERROR = 0x1007
	1949	SO_GET_FILTER = 0x1a
	1950	SO_INCOMING_CPU = 0x33
	1951	SO_INCOMING_NAPI_ID = 0x3a
	1952	SO_KEEPALIVE = 0x8
	1953	SO_LINGER = 0x80
	1954	SO_LOCK_FILTER = 0x28
	1955	SO_MARK = 0x22
	1956	SO_MAX_PACING_RATE = 0x31
	1957	SO_MEMINFO = 0x39
	1958	SO_NOFCS = 0x27
	1959	SO_NO_CHECK = 0xb
	1960	SO_OOBINLINE = 0x100
	1961	SO_PASSCRED = 0x2
	1962	SO_PASSSEC = 0x1f
	1963	SO_PEEK_OFF = 0x26
	1964	SO_PEERCRED = 0x40
	1965	SO_PEERGROUPS = 0x3d
	1966	SO_PEERNAME = 0x1c
	1967	SO_PEERSEC = 0x1e
	1968	SO_PRIORITY = 0xc
	1969	SO_PROTOCOL = 0x1028
	1970	SO_RCVBUF = 0x1002
	1971	SO_RCVBUFFORCE = 0x100b
	1972	SO_RCVLOWAT = 0x800
	1973	SO_RCVTIMEO = 0x2000
	1974	SO_REUSEADDR = 0x4
	1975	SO_REUSEPORT = 0x200
	1976	SO_RXQ_OVFL = 0x24
	1977	SO_SECURITY_AUTHENTICATION = 0x5001
	1978	SO_SECURITY_ENCRYPTION_NETWORK = 0x5004
	1979	SO_SECURITY_ENCRYPTION_TRANSPORT = 0x5002
	1980	SO_SELECT_ERR_QUEUE = 0x29
	1981	SO_SNDBUF = 0x1001
	1982	SO_SNDBUFFORCE = 0x100a
	1983	SO_SNDLOWAT = 0x1000
	1984	SO_SNDTIMEO = 0x4000
	1985	SO_TIMESTAMP = 0x1d
	1986	SO_TIMESTAMPING = 0x23
	1987	SO_TIMESTAMPNS = 0x21
	1988	SO_TXTIME = 0x3f
	1989	SO_TYPE = 0x1008
	1990	SO_VM_SOCKETS_BUFFER_MAX_SIZE = 0x2
	1991	SO_VM_SOCKETS_BUFFER_MIN_SIZE = 0x1
	1992	SO_VM_SOCKETS_BUFFER_SIZE = 0x0
	1993	SO_VM_SOCKETS_CONNECT_TIMEOUT = 0x6
	1994	SO_VM_SOCKETS_NONBLOCK_TXRX = 0x7
	1995	SO_VM_SOCKETS_PEER_HOST_VM_ID = 0x3
	1996	SO_VM_SOCKETS_TRUSTED = 0x5
	1997	SO_WIFI_STATUS = 0x25
	1998	SO_ZEROCOPY = 0x3e
	1999	SPLICE_F_GIFT = 0x8
	2000	SPLICE_F_MORE = 0x4
	2001	SPLICE_F_MOVE = 0x1
	2002	SPLICE_F_NONBLOCK = 0x2
	2003	SQUASHFS_MAGIC = 0x73717368
	2004	STACK_END_MAGIC = 0x57ac6e9d
	2005	STATX_ALL = 0xfff
	2006	STATX_ATIME = 0x20
	2007	STATX_ATTR_APPEND = 0x20
	2008	STATX_ATTR_AUTOMOUNT = 0x1000
	2009	STATX_ATTR_COMPRESSED = 0x4
	2010	STATX_ATTR_ENCRYPTED = 0x800
	2011	STATX_ATTR_IMMUTABLE = 0x10
	2012	STATX_ATTR_NODUMP = 0x40
	2013	STATX_BASIC_STATS = 0x7ff
	2014	STATX_BLOCKS = 0x400
	2015	STATX_BTIME = 0x800
	2016	STATX_CTIME = 0x80
	2017	STATX_GID = 0x10
	2018	STATX_INO = 0x100
	2019	STATX_MODE = 0x2
	2020	STATX_MTIME = 0x40
	2021	STATX_NLINK = 0x4
	2022	STATX_SIZE = 0x200
	2023	STATX_TYPE = 0x1
	2024	STATX_UID = 0x8
	2025	STATX__RESERVED = 0x80000000
	2026	SYNC_FILE_RANGE_WAIT_AFTER = 0x4
	2027	SYNC_FILE_RANGE_WAIT_BEFORE = 0x1
	2028	SYNC_FILE_RANGE_WRITE = 0x2
	2029	SYSFS_MAGIC = 0x62656572
	2030	S_BLKSIZE = 0x200
	2031	S_IEXEC = 0x40
	2032	S_IFBLK = 0x6000
	2033	S_IFCHR = 0x2000
	2034	S_IFDIR = 0x4000
	2035	S_IFIFO = 0x1000
	2036	S_IFLNK = 0xa000
	2037	S_IFMT = 0xf000
	2038	S_IFREG = 0x8000
	2039	S_IFSOCK = 0xc000
	2040	S_IREAD = 0x100
	2041	S_IRGRP = 0x20
	2042	S_IROTH = 0x4
	2043	S_IRUSR = 0x100
	2044	S_IRWXG = 0x38
	2045	S_IRWXO = 0x7
	2046	S_IRWXU = 0x1c0
	2047	S_ISGID = 0x400
	2048	S_ISUID = 0x800
	2049	S_ISVTX = 0x200
	2050	S_IWGRP = 0x10
	2051	S_IWOTH = 0x2
	2052	S_IWRITE = 0x80
	2053	S_IWUSR = 0x80
	2054	S_IXGRP = 0x8
	2055	S_IXOTH = 0x1
	2056	S_IXUSR = 0x40
	2057	TAB0 = 0x0
	2058	TAB1 = 0x800
	2059	TAB2 = 0x1000
	2060	TAB3 = 0x1800
	2061	TABDLY = 0x1800
	2062	TASKSTATS_CMD_ATTR_MAX = 0x4
	2063	TASKSTATS_CMD_MAX = 0x2
	2064	TASKSTATS_GENL_NAME = "TASKSTATS"
	2065	TASKSTATS_GENL_VERSION = 0x1
	2066	TASKSTATS_TYPE_MAX = 0x6
	2067	TASKSTATS_VERSION = 0x8
	2068	TCFLSH = 0x20005407
	2069	TCGETA = 0x40125401
	2070	TCGETS = 0x40245408
	2071	TCGETS2 = 0x402c540c
	2072	TCIFLUSH = 0x0
	2073	TCIOFF = 0x2
	2074	TCIOFLUSH = 0x2
	2075	TCION = 0x3
	2076	TCOFLUSH = 0x1
	2077	TCOOFF = 0x0
	2078	TCOON = 0x1
	2079	TCP_CC_INFO = 0x1a
	2080	TCP_CONGESTION = 0xd
	2081	TCP_COOKIE_IN_ALWAYS = 0x1
	2082	TCP_COOKIE_MAX = 0x10
	2083	TCP_COOKIE_MIN = 0x8
	2084	TCP_COOKIE_OUT_NEVER = 0x2
	2085	TCP_COOKIE_PAIR_SIZE = 0x20
	2086	TCP_COOKIE_TRANSACTIONS = 0xf
	2087	TCP_CORK = 0x3
	2088	TCP_DEFER_ACCEPT = 0x9
	2089	TCP_FASTOPEN = 0x17
	2090	TCP_FASTOPEN_CONNECT = 0x1e
	2091	TCP_FASTOPEN_KEY = 0x21
	2092	TCP_FASTOPEN_NO_COOKIE = 0x22
	2093	TCP_INFO = 0xb
	2094	TCP_KEEPCNT = 0x6
	2095	TCP_KEEPIDLE = 0x4
	2096	TCP_KEEPINTVL = 0x5
	2097	TCP_LINGER2 = 0x8
	2098	TCP_MAXSEG = 0x2
	2099	TCP_MAXWIN = 0xffff
	2100	TCP_MAX_WINSHIFT = 0xe
	2101	TCP_MD5SIG = 0xe
	2102	TCP_MD5SIG_EXT = 0x20
	2103	TCP_MD5SIG_FLAG_PREFIX = 0x1
	2104	TCP_MD5SIG_MAXKEYLEN = 0x50
	2105	TCP_MSS = 0x200
	2106	TCP_MSS_DEFAULT = 0x218
	2107	TCP_MSS_DESIRED = 0x4c4
	2108	TCP_NODELAY = 0x1
	2109	TCP_NOTSENT_LOWAT = 0x19
	2110	TCP_QUEUE_SEQ = 0x15
	2111	TCP_QUICKACK = 0xc
	2112	TCP_REPAIR = 0x13
	2113	TCP_REPAIR_OPTIONS = 0x16
	2114	TCP_REPAIR_QUEUE = 0x14
	2115	TCP_REPAIR_WINDOW = 0x1d
	2116	TCP_SAVED_SYN = 0x1c
	2117	TCP_SAVE_SYN = 0x1b
	2118	TCP_SYNCNT = 0x7
	2119	TCP_S_DATA_IN = 0x4
	2120	TCP_S_DATA_OUT = 0x8
	2121	TCP_THIN_DUPACK = 0x11
	2122	TCP_THIN_LINEAR_TIMEOUTS = 0x10
	2123	TCP_TIMESTAMP = 0x18
	2124	TCP_ULP = 0x1f
	2125	TCP_USER_TIMEOUT = 0x12
	2126	TCP_WINDOW_CLAMP = 0xa
	2127	TCSAFLUSH = 0x2
	2128	TCSBRK = 0x20005405
	2129	TCSBRKP = 0x5425
	2130	TCSETA = 0x80125402
	2131	TCSETAF = 0x80125404
	2132	TCSETAW = 0x80125403
	2133	TCSETS = 0x80245409
	2134	TCSETS2 = 0x802c540d
	2135	TCSETSF = 0x8024540b
	2136	TCSETSF2 = 0x802c540f
	2137	TCSETSW = 0x8024540a
	2138	TCSETSW2 = 0x802c540e
	2139	TCXONC = 0x20005406
	2140	TIOCCBRK = 0x2000747a
	2141	TIOCCONS = 0x20007424
	2142	TIOCEXCL = 0x2000740d
	2143	TIOCGDEV = 0x40045432
	2144	TIOCGETD = 0x40047400
	2145	TIOCGEXCL = 0x40045440
	2146	TIOCGICOUNT = 0x545d
	2147	TIOCGLCKTRMIOS = 0x5456
	2148	TIOCGPGRP = 0x40047483
	2149	TIOCGPKT = 0x40045438
	2150	TIOCGPTLCK = 0x40045439
	2151	TIOCGPTN = 0x40047486
	2152	TIOCGPTPEER = 0x20007489
	2153	TIOCGRS485 = 0x40205441
	2154	TIOCGSERIAL = 0x541e
	2155	TIOCGSID = 0x40047485
	2156	TIOCGSOFTCAR = 0x40047464
	2157	TIOCGWINSZ = 0x40087468
	2158	TIOCINQ = 0x4004667f
	2159	TIOCLINUX = 0x541c
	2160	TIOCMBIC = 0x8004746b
	2161	TIOCMBIS = 0x8004746c
	2162	TIOCMGET = 0x4004746a
	2163	TIOCMIWAIT = 0x545c
	2164	TIOCMSET = 0x8004746d
	2165	TIOCM_CAR = 0x40
	2166	TIOCM_CD = 0x40
	2167	TIOCM_CTS = 0x20
	2168	TIOCM_DSR = 0x100
	2169	TIOCM_DTR = 0x2
	2170	TIOCM_LE = 0x1
	2171	TIOCM_RI = 0x80
	2172	TIOCM_RNG = 0x80
	2173	TIOCM_RTS = 0x4
	2174	TIOCM_SR = 0x10
	2175	TIOCM_ST = 0x8
	2176	TIOCNOTTY = 0x20007471
	2177	TIOCNXCL = 0x2000740e
	2178	TIOCOUTQ = 0x40047473
	2179	TIOCPKT = 0x80047470
	2180	TIOCPKT_DATA = 0x0
	2181	TIOCPKT_DOSTOP = 0x20
	2182	TIOCPKT_FLUSHREAD = 0x1
	2183	TIOCPKT_FLUSHWRITE = 0x2
	2184	TIOCPKT_IOCTL = 0x40
	2185	TIOCPKT_NOSTOP = 0x10
	2186	TIOCPKT_START = 0x8
	2187	TIOCPKT_STOP = 0x4
	2188	TIOCSBRK = 0x2000747b
	2189	TIOCSCTTY = 0x20007484
	2190	TIOCSERCONFIG = 0x5453
	2191	TIOCSERGETLSR = 0x5459
	2192	TIOCSERGETMULTI = 0x545a
	2193	TIOCSERGSTRUCT = 0x5458
	2194	TIOCSERGWILD = 0x5454
	2195	TIOCSERSETMULTI = 0x545b
	2196	TIOCSERSWILD = 0x5455
	2197	TIOCSETD = 0x80047401
	2198	TIOCSIG = 0x80047488
	2199	TIOCSLCKTRMIOS = 0x5457
	2200	TIOCSPGRP = 0x80047482
	2201	TIOCSPTLCK = 0x80047487
	2202	TIOCSRS485 = 0xc0205442
	2203	TIOCSSERIAL = 0x541f
	2204	TIOCSSOFTCAR = 0x80047465
	2205	TIOCSTART = 0x2000746e
	2206	TIOCSTI = 0x80017472
	2207	TIOCSTOP = 0x2000746f
	2208	TIOCSWINSZ = 0x80087467
	2209	TIOCVHANGUP = 0x20005437
	2210	TMPFS_MAGIC = 0x1021994
	2211	TOSTOP = 0x100
	2212	TPACKET_ALIGNMENT = 0x10
	2213	TPACKET_HDRLEN = 0x34
	2214	TP_STATUS_AVAILABLE = 0x0
	2215	TP_STATUS_BLK_TMO = 0x20
	2216	TP_STATUS_COPY = 0x2
	2217	TP_STATUS_CSUMNOTREADY = 0x8
	2218	TP_STATUS_CSUM_VALID = 0x80
	2219	TP_STATUS_KERNEL = 0x0
	2220	TP_STATUS_LOSING = 0x4
	2221	TP_STATUS_SENDING = 0x2
	2222	TP_STATUS_SEND_REQUEST = 0x1
	2223	TP_STATUS_TS_RAW_HARDWARE = -0x80000000
	2224	TP_STATUS_TS_SOFTWARE = 0x20000000
	2225	TP_STATUS_TS_SYS_HARDWARE = 0x40000000
	2226	TP_STATUS_USER = 0x1
	2227	TP_STATUS_VLAN_TPID_VALID = 0x40
	2228	TP_STATUS_VLAN_VALID = 0x10
	2229	TP_STATUS_WRONG_FORMAT = 0x4
	2230	TRACEFS_MAGIC = 0x74726163
	2231	TS_COMM_LEN = 0x20
	2232	TUNATTACHFILTER = 0x801054d5
	2233	TUNDETACHFILTER = 0x801054d6
	2234	TUNGETFEATURES = 0x400454cf
	2235	TUNGETFILTER = 0x401054db
	2236	TUNGETIFF = 0x400454d2
	2237	TUNGETSNDBUF = 0x400454d3
	2238	TUNGETVNETBE = 0x400454df
	2239	TUNGETVNETHDRSZ = 0x400454d7
	2240	TUNGETVNETLE = 0x400454dd
	2241	TUNSETDEBUG = 0x800454c9
	2242	TUNSETFILTEREBPF = 0x400454e1
	2243	TUNSETGROUP = 0x800454ce
	2244	TUNSETIFF = 0x800454ca
	2245	TUNSETIFINDEX = 0x800454da
	2246	TUNSETLINK = 0x800454cd
	2247	TUNSETNOCSUM = 0x800454c8
	2248	TUNSETOFFLOAD = 0x800454d0
	2249	TUNSETOWNER = 0x800454cc
	2250	TUNSETPERSIST = 0x800454cb
	2251	TUNSETQUEUE = 0x800454d9
	2252	TUNSETSNDBUF = 0x800454d4
	2253	TUNSETSTEERINGEBPF = 0x400454e0
	2254	TUNSETTXFILTER = 0x800454d1
	2255	TUNSETVNETBE = 0x800454de
	2256	TUNSETVNETHDRSZ = 0x800454d8
	2257	TUNSETVNETLE = 0x800454dc
	2258	UBI_IOCATT = 0x80186f40
	2259	UBI_IOCDET = 0x80046f41
	2260	UBI_IOCEBCH = 0x80044f02
	2261	UBI_IOCEBER = 0x80044f01
	2262	UBI_IOCEBISMAP = 0x40044f05
	2263	UBI_IOCEBMAP = 0x80084f03
	2264	UBI_IOCEBUNMAP = 0x80044f04
	2265	UBI_IOCMKVOL = 0x80986f00
	2266	UBI_IOCRMVOL = 0x80046f01
	2267	UBI_IOCRNVOL = 0x91106f03
	2268	UBI_IOCRSVOL = 0x800c6f02
	2269	UBI_IOCSETVOLPROP = 0x80104f06
	2270	UBI_IOCVOLCRBLK = 0x80804f07
	2271	UBI_IOCVOLRMBLK = 0x20004f08
	2272	UBI_IOCVOLUP = 0x80084f00
	2273	UDF_SUPER_MAGIC = 0x15013346
	2274	UMOUNT_NOFOLLOW = 0x8
	2275	USBDEVICE_SUPER_MAGIC = 0x9fa2
	2276	UTIME_NOW = 0x3fffffff
	2277	UTIME_OMIT = 0x3ffffffe
	2278	V9FS_MAGIC = 0x1021997
	2279	VDISCARD = 0xd
	2280	VEOF = 0x4
	2281	VEOL = 0xb
	2282	VEOL2 = 0x10
	2283	VERASE = 0x2
	2284	VINTR = 0x0
	2285	VKILL = 0x3
	2286	VLNEXT = 0xf
	2287	VMADDR_CID_ANY = 0xffffffff
	2288	VMADDR_CID_HOST = 0x2
	2289	VMADDR_CID_HYPERVISOR = 0x0
	2290	VMADDR_CID_RESERVED = 0x1
	2291	VMADDR_PORT_ANY = 0xffffffff
	2292	VMIN = 0x6
	2293	VM_SOCKETS_INVALID_VERSION = 0xffffffff
	2294	VQUIT = 0x1
	2295	VREPRINT = 0xc
	2296	VSTART = 0x8
	2297	VSTOP = 0x9
	2298	VSUSP = 0xa
	2299	VSWTC = 0x7
	2300	VT0 = 0x0
	2301	VT1 = 0x4000
	2302	VTDLY = 0x4000
	2303	VTIME = 0x5
	2304	VWERASE = 0xe
	2305	WALL = 0x40000000
	2306	WCLONE = 0x80000000
	2307	WCONTINUED = 0x8
	2308	WDIOC_GETBOOTSTATUS = 0x40045702
	2309	WDIOC_GETPRETIMEOUT = 0x40045709
	2310	WDIOC_GETSTATUS = 0x40045701
	2311	WDIOC_GETSUPPORT = 0x40285700
	2312	WDIOC_GETTEMP = 0x40045703
	2313	WDIOC_GETTIMELEFT = 0x4004570a
	2314	WDIOC_GETTIMEOUT = 0x40045707
	2315	WDIOC_KEEPALIVE = 0x40045705
	2316	WDIOC_SETOPTIONS = 0x40045704
	2317	WDIOC_SETPRETIMEOUT = 0xc0045708
	2318	WDIOC_SETTIMEOUT = 0xc0045706
	2319	WEXITED = 0x4
	2320	WIN_ACKMEDIACHANGE = 0xdb
	2321	WIN_CHECKPOWERMODE1 = 0xe5
	2322	WIN_CHECKPOWERMODE2 = 0x98
	2323	WIN_DEVICE_RESET = 0x8
	2324	WIN_DIAGNOSE = 0x90
	2325	WIN_DOORLOCK = 0xde
	2326	WIN_DOORUNLOCK = 0xdf
	2327	WIN_DOWNLOAD_MICROCODE = 0x92
	2328	WIN_FLUSH_CACHE = 0xe7
	2329	WIN_FLUSH_CACHE_EXT = 0xea
	2330	WIN_FORMAT = 0x50
	2331	WIN_GETMEDIASTATUS = 0xda
	2332	WIN_IDENTIFY = 0xec
	2333	WIN_IDENTIFY_DMA = 0xee
	2334	WIN_IDLEIMMEDIATE = 0xe1
	2335	WIN_INIT = 0x60
	2336	WIN_MEDIAEJECT = 0xed
	2337	WIN_MULTREAD = 0xc4
	2338	WIN_MULTREAD_EXT = 0x29
	2339	WIN_MULTWRITE = 0xc5
	2340	WIN_MULTWRITE_EXT = 0x39
	2341	WIN_NOP = 0x0
	2342	WIN_PACKETCMD = 0xa0
	2343	WIN_PIDENTIFY = 0xa1
	2344	WIN_POSTBOOT = 0xdc
	2345	WIN_PREBOOT = 0xdd
	2346	WIN_QUEUED_SERVICE = 0xa2
	2347	WIN_READ = 0x20
	2348	WIN_READDMA = 0xc8
	2349	WIN_READDMA_EXT = 0x25
	2350	WIN_READDMA_ONCE = 0xc9
	2351	WIN_READDMA_QUEUED = 0xc7
	2352	WIN_READDMA_QUEUED_EXT = 0x26
	2353	WIN_READ_BUFFER = 0xe4
	2354	WIN_READ_EXT = 0x24
	2355	WIN_READ_LONG = 0x22
	2356	WIN_READ_LONG_ONCE = 0x23
	2357	WIN_READ_NATIVE_MAX = 0xf8
	2358	WIN_READ_NATIVE_MAX_EXT = 0x27
	2359	WIN_READ_ONCE = 0x21
	2360	WIN_RECAL = 0x10
	2361	WIN_RESTORE = 0x10
	2362	WIN_SECURITY_DISABLE = 0xf6
	2363	WIN_SECURITY_ERASE_PREPARE = 0xf3
	2364	WIN_SECURITY_ERASE_UNIT = 0xf4
	2365	WIN_SECURITY_FREEZE_LOCK = 0xf5
	2366	WIN_SECURITY_SET_PASS = 0xf1
	2367	WIN_SECURITY_UNLOCK = 0xf2
	2368	WIN_SEEK = 0x70
	2369	WIN_SETFEATURES = 0xef
	2370	WIN_SETIDLE1 = 0xe3
	2371	WIN_SETIDLE2 = 0x97
	2372	WIN_SETMULT = 0xc6
	2373	WIN_SET_MAX = 0xf9
	2374	WIN_SET_MAX_EXT = 0x37
	2375	WIN_SLEEPNOW1 = 0xe6
	2376	WIN_SLEEPNOW2 = 0x99
	2377	WIN_SMART = 0xb0
	2378	WIN_SPECIFY = 0x91
	2379	WIN_SRST = 0x8
	2380	WIN_STANDBY = 0xe2
	2381	WIN_STANDBY2 = 0x96
	2382	WIN_STANDBYNOW1 = 0xe0
	2383	WIN_STANDBYNOW2 = 0x94
	2384	WIN_VERIFY = 0x40
	2385	WIN_VERIFY_EXT = 0x42
	2386	WIN_VERIFY_ONCE = 0x41
	2387	WIN_WRITE = 0x30
	2388	WIN_WRITEDMA = 0xca
	2389	WIN_WRITEDMA_EXT = 0x35
	2390	WIN_WRITEDMA_ONCE = 0xcb
	2391	WIN_WRITEDMA_QUEUED = 0xcc
	2392	WIN_WRITEDMA_QUEUED_EXT = 0x36
	2393	WIN_WRITE_BUFFER = 0xe8
	2394	WIN_WRITE_EXT = 0x34
	2395	WIN_WRITE_LONG = 0x32
	2396	WIN_WRITE_LONG_ONCE = 0x33
	2397	WIN_WRITE_ONCE = 0x31
	2398	WIN_WRITE_SAME = 0xe9
	2399	WIN_WRITE_VERIFY = 0x3c
	2400	WNOHANG = 0x1
	2401	WNOTHREAD = 0x20000000
	2402	WNOWAIT = 0x1000000
	2403	WORDSIZE = 0x40
	2404	WSTOPPED = 0x2
	2405	WUNTRACED = 0x2
	2406	XATTR_CREATE = 0x1
	2407	XATTR_REPLACE = 0x2
	2408	XCASE = 0x4
	2409	XDP_COPY = 0x2
	2410	XDP_FLAGS_DRV_MODE = 0x4
	2411	XDP_FLAGS_HW_MODE = 0x8
	2412	XDP_FLAGS_MASK = 0xf
	2413	XDP_FLAGS_MODES = 0xe
	2414	XDP_FLAGS_SKB_MODE = 0x2
	2415	XDP_FLAGS_UPDATE_IF_NOEXIST = 0x1
	2416	XDP_MMAP_OFFSETS = 0x1
	2417	XDP_PGOFF_RX_RING = 0x0
	2418	XDP_PGOFF_TX_RING = 0x80000000
	2419	XDP_RX_RING = 0x2
	2420	XDP_SHARED_UMEM = 0x1
	2421	XDP_STATISTICS = 0x7
	2422	XDP_TX_RING = 0x3
	2423	XDP_UMEM_COMPLETION_RING = 0x6
	2424	XDP_UMEM_FILL_RING = 0x5
	2425	XDP_UMEM_PGOFF_COMPLETION_RING = 0x180000000
	2426	XDP_UMEM_PGOFF_FILL_RING = 0x100000000
	2427	XDP_UMEM_REG = 0x4
	2428	XDP_ZEROCOPY = 0x4
	2429	XENFS_SUPER_MAGIC = 0xabba1974
	2430	XTABS = 0x1800
	2431	ZSMALLOC_MAGIC = 0x58295829
	2432	__TIOCFLUSH = 0x80047410
1789	2433	)
1790	2434
1791	2435	// Errors

+1810

-0

unix/zsyscall_darwin_386.1_11.go less more

	0	// go run mksyscall.go -l32 -tags darwin,386,!go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_386.go
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
	2
	3	// +build darwin,386,!go1.12
	4
	5	package unix
	6
	7	import (
	8	"syscall"
	9	"unsafe"
	10	)
	11
	12	var _ syscall.Errno
	13
	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	15
	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
	17	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	18	n = int(r0)
	19	if e1 != 0 {
	20	err = errnoErr(e1)
	21	}
	22	return
	23	}
	24
	25	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	26
	27	func setgroups(ngid int, gid *_Gid_t) (err error) {
	28	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	29	if e1 != 0 {
	30	err = errnoErr(e1)
	31	}
	32	return
	33	}
	34
	35	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	36
	37	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
	38	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	39	wpid = int(r0)
	40	if e1 != 0 {
	41	err = errnoErr(e1)
	42	}
	43	return
	44	}
	45
	46	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	47
	48	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
	49	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	50	fd = int(r0)
	51	if e1 != 0 {
	52	err = errnoErr(e1)
	53	}
	54	return
	55	}
	56
	57	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	58
	59	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	60	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
	61	if e1 != 0 {
	62	err = errnoErr(e1)
	63	}
	64	return
	65	}
	66
	67	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	68
	69	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	70	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
	71	if e1 != 0 {
	72	err = errnoErr(e1)
	73	}
	74	return
	75	}
	76
	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	78
	79	func socket(domain int, typ int, proto int) (fd int, err error) {
	80	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	81	fd = int(r0)
	82	if e1 != 0 {
	83	err = errnoErr(e1)
	84	}
	85	return
	86	}
	87
	88	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	89
	90	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
	91	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	92	if e1 != 0 {
	93	err = errnoErr(e1)
	94	}
	95	return
	96	}
	97
	98	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	99
	100	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
	101	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	102	if e1 != 0 {
	103	err = errnoErr(e1)
	104	}
	105	return
	106	}
	107
	108	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	109
	110	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	111	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	112	if e1 != 0 {
	113	err = errnoErr(e1)
	114	}
	115	return
	116	}
	117
	118	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	119
	120	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	121	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	122	if e1 != 0 {
	123	err = errnoErr(e1)
	124	}
	125	return
	126	}
	127
	128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	129
	130	func Shutdown(s int, how int) (err error) {
	131	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
	132	if e1 != 0 {
	133	err = errnoErr(e1)
	134	}
	135	return
	136	}
	137
	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	139
	140	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
	141	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	149
	150	func recvfrom(fd int, p []byte, flags int, from RawSockaddrAny, fromlen _Socklen) (n int, err error) {
	151	var _p0 unsafe.Pointer
	152	if len(p) > 0 {
	153	_p0 = unsafe.Pointer(&p[0])
	154	} else {
	155	_p0 = unsafe.Pointer(&_zero)
	156	}
	157	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	158	n = int(r0)
	159	if e1 != 0 {
	160	err = errnoErr(e1)
	161	}
	162	return
	163	}
	164
	165	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	166
	167	func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
	168	var _p0 unsafe.Pointer
	169	if len(buf) > 0 {
	170	_p0 = unsafe.Pointer(&buf[0])
	171	} else {
	172	_p0 = unsafe.Pointer(&_zero)
	173	}
	174	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	175	if e1 != 0 {
	176	err = errnoErr(e1)
	177	}
	178	return
	179	}
	180
	181	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	182
	183	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	184	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	185	n = int(r0)
	186	if e1 != 0 {
	187	err = errnoErr(e1)
	188	}
	189	return
	190	}
	191
	192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	193
	194	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	195	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	196	n = int(r0)
	197	if e1 != 0 {
	198	err = errnoErr(e1)
	199	}
	200	return
	201	}
	202
	203	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	204
	205	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
	206	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	207	n = int(r0)
	208	if e1 != 0 {
	209	err = errnoErr(e1)
	210	}
	211	return
	212	}
	213
	214	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	215
	216	func sysctl(mib []_C_int, old byte, oldlen uintptr, new *byte, newlen uintptr) (err error) {
	217	var _p0 unsafe.Pointer
	218	if len(mib) > 0 {
	219	_p0 = unsafe.Pointer(&mib[0])
	220	} else {
	221	_p0 = unsafe.Pointer(&_zero)
	222	}
	223	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
	224	if e1 != 0 {
	225	err = errnoErr(e1)
	226	}
	227	return
	228	}
	229
	230	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	231
	232	func utimes(path string, timeval *[2]Timeval) (err error) {
	233	var _p0 *byte
	234	_p0, err = BytePtrFromString(path)
	235	if err != nil {
	236	return
	237	}
	238	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	239	if e1 != 0 {
	240	err = errnoErr(e1)
	241	}
	242	return
	243	}
	244
	245	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	246
	247	func futimes(fd int, timeval *[2]Timeval) (err error) {
	248	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	249	if e1 != 0 {
	250	err = errnoErr(e1)
	251	}
	252	return
	253	}
	254
	255	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	256
	257	func fcntl(fd int, cmd int, arg int) (val int, err error) {
	258	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	259	val = int(r0)
	260	if e1 != 0 {
	261	err = errnoErr(e1)
	262	}
	263	return
	264	}
	265
	266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	267
	268	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
	269	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	270	n = int(r0)
	271	if e1 != 0 {
	272	err = errnoErr(e1)
	273	}
	274	return
	275	}
	276
	277	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	278
	279	func Madvise(b []byte, behav int) (err error) {
	280	var _p0 unsafe.Pointer
	281	if len(b) > 0 {
	282	_p0 = unsafe.Pointer(&b[0])
	283	} else {
	284	_p0 = unsafe.Pointer(&_zero)
	285	}
	286	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
	287	if e1 != 0 {
	288	err = errnoErr(e1)
	289	}
	290	return
	291	}
	292
	293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	294
	295	func Mlock(b []byte) (err error) {
	296	var _p0 unsafe.Pointer
	297	if len(b) > 0 {
	298	_p0 = unsafe.Pointer(&b[0])
	299	} else {
	300	_p0 = unsafe.Pointer(&_zero)
	301	}
	302	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
	303	if e1 != 0 {
	304	err = errnoErr(e1)
	305	}
	306	return
	307	}
	308
	309	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	310
	311	func Mlockall(flags int) (err error) {
	312	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
	313	if e1 != 0 {
	314	err = errnoErr(e1)
	315	}
	316	return
	317	}
	318
	319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	320
	321	func Mprotect(b []byte, prot int) (err error) {
	322	var _p0 unsafe.Pointer
	323	if len(b) > 0 {
	324	_p0 = unsafe.Pointer(&b[0])
	325	} else {
	326	_p0 = unsafe.Pointer(&_zero)
	327	}
	328	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
	329	if e1 != 0 {
	330	err = errnoErr(e1)
	331	}
	332	return
	333	}
	334
	335	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	336
	337	func Msync(b []byte, flags int) (err error) {
	338	var _p0 unsafe.Pointer
	339	if len(b) > 0 {
	340	_p0 = unsafe.Pointer(&b[0])
	341	} else {
	342	_p0 = unsafe.Pointer(&_zero)
	343	}
	344	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
	345	if e1 != 0 {
	346	err = errnoErr(e1)
	347	}
	348	return
	349	}
	350
	351	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	352
	353	func Munlock(b []byte) (err error) {
	354	var _p0 unsafe.Pointer
	355	if len(b) > 0 {
	356	_p0 = unsafe.Pointer(&b[0])
	357	} else {
	358	_p0 = unsafe.Pointer(&_zero)
	359	}
	360	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
	361	if e1 != 0 {
	362	err = errnoErr(e1)
	363	}
	364	return
	365	}
	366
	367	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	368
	369	func Munlockall() (err error) {
	370	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
	371	if e1 != 0 {
	372	err = errnoErr(e1)
	373	}
	374	return
	375	}
	376
	377	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	378
	379	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
	380	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	381	if e1 != 0 {
	382	err = errnoErr(e1)
	383	}
	384	return
	385	}
	386
	387	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	388
	389	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	390	_, _, e1 := Syscall6(SYS_GETATTRLIST, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	391	if e1 != 0 {
	392	err = errnoErr(e1)
	393	}
	394	return
	395	}
	396
	397	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	398
	399	func pipe() (r int, w int, err error) {
	400	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	401	r = int(r0)
	402	w = int(r1)
	403	if e1 != 0 {
	404	err = errnoErr(e1)
	405	}
	406	return
	407	}
	408
	409	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	410
	411	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	412	var _p0 *byte
	413	_p0, err = BytePtrFromString(path)
	414	if err != nil {
	415	return
	416	}
	417	var _p1 *byte
	418	_p1, err = BytePtrFromString(attr)
	419	if err != nil {
	420	return
	421	}
	422	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	423	sz = int(r0)
	424	if e1 != 0 {
	425	err = errnoErr(e1)
	426	}
	427	return
	428	}
	429
	430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	431
	432	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	433	var _p0 *byte
	434	_p0, err = BytePtrFromString(attr)
	435	if err != nil {
	436	return
	437	}
	438	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	439	sz = int(r0)
	440	if e1 != 0 {
	441	err = errnoErr(e1)
	442	}
	443	return
	444	}
	445
	446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	447
	448	func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
	449	var _p0 *byte
	450	_p0, err = BytePtrFromString(path)
	451	if err != nil {
	452	return
	453	}
	454	var _p1 *byte
	455	_p1, err = BytePtrFromString(attr)
	456	if err != nil {
	457	return
	458	}
	459	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	460	if e1 != 0 {
	461	err = errnoErr(e1)
	462	}
	463	return
	464	}
	465
	466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	467
	468	func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
	469	var _p0 *byte
	470	_p0, err = BytePtrFromString(attr)
	471	if err != nil {
	472	return
	473	}
	474	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	475	if e1 != 0 {
	476	err = errnoErr(e1)
	477	}
	478	return
	479	}
	480
	481	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	482
	483	func removexattr(path string, attr string, options int) (err error) {
	484	var _p0 *byte
	485	_p0, err = BytePtrFromString(path)
	486	if err != nil {
	487	return
	488	}
	489	var _p1 *byte
	490	_p1, err = BytePtrFromString(attr)
	491	if err != nil {
	492	return
	493	}
	494	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	495	if e1 != 0 {
	496	err = errnoErr(e1)
	497	}
	498	return
	499	}
	500
	501	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	502
	503	func fremovexattr(fd int, attr string, options int) (err error) {
	504	var _p0 *byte
	505	_p0, err = BytePtrFromString(attr)
	506	if err != nil {
	507	return
	508	}
	509	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	510	if e1 != 0 {
	511	err = errnoErr(e1)
	512	}
	513	return
	514	}
	515
	516	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	517
	518	func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
	519	var _p0 *byte
	520	_p0, err = BytePtrFromString(path)
	521	if err != nil {
	522	return
	523	}
	524	r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	525	sz = int(r0)
	526	if e1 != 0 {
	527	err = errnoErr(e1)
	528	}
	529	return
	530	}
	531
	532	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	533
	534	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
	535	r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	536	sz = int(r0)
	537	if e1 != 0 {
	538	err = errnoErr(e1)
	539	}
	540	return
	541	}
	542
	543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	544
	545	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	546	_, _, e1 := Syscall6(SYS_SETATTRLIST, 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	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	554
	555	func kill(pid int, signum int, posix int) (err error) {
	556	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
	557	if e1 != 0 {
	558	err = errnoErr(e1)
	559	}
	560	return
	561	}
	562
	563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	564
	565	func ioctl(fd int, req uint, arg uintptr) (err error) {
	566	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
	567	if e1 != 0 {
	568	err = errnoErr(e1)
	569	}
	570	return
	571	}
	572
	573	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	574
	575	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	576	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
	577	if e1 != 0 {
	578	err = errnoErr(e1)
	579	}
	580	return
	581	}
	582
	583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	584
	585	func Access(path string, mode uint32) (err error) {
	586	var _p0 *byte
	587	_p0, err = BytePtrFromString(path)
	588	if err != nil {
	589	return
	590	}
	591	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	592	if e1 != 0 {
	593	err = errnoErr(e1)
	594	}
	595	return
	596	}
	597
	598	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	599
	600	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
	601	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	602	if e1 != 0 {
	603	err = errnoErr(e1)
	604	}
	605	return
	606	}
	607
	608	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	609
	610	func Chdir(path string) (err error) {
	611	var _p0 *byte
	612	_p0, err = BytePtrFromString(path)
	613	if err != nil {
	614	return
	615	}
	616	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	617	if e1 != 0 {
	618	err = errnoErr(e1)
	619	}
	620	return
	621	}
	622
	623	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	624
	625	func Chflags(path string, flags int) (err error) {
	626	var _p0 *byte
	627	_p0, err = BytePtrFromString(path)
	628	if err != nil {
	629	return
	630	}
	631	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	632	if e1 != 0 {
	633	err = errnoErr(e1)
	634	}
	635	return
	636	}
	637
	638	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	639
	640	func Chmod(path string, mode uint32) (err error) {
	641	var _p0 *byte
	642	_p0, err = BytePtrFromString(path)
	643	if err != nil {
	644	return
	645	}
	646	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	647	if e1 != 0 {
	648	err = errnoErr(e1)
	649	}
	650	return
	651	}
	652
	653	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	654
	655	func Chown(path string, uid int, gid int) (err error) {
	656	var _p0 *byte
	657	_p0, err = BytePtrFromString(path)
	658	if err != nil {
	659	return
	660	}
	661	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	662	if e1 != 0 {
	663	err = errnoErr(e1)
	664	}
	665	return
	666	}
	667
	668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	669
	670	func Chroot(path string) (err error) {
	671	var _p0 *byte
	672	_p0, err = BytePtrFromString(path)
	673	if err != nil {
	674	return
	675	}
	676	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
	677	if e1 != 0 {
	678	err = errnoErr(e1)
	679	}
	680	return
	681	}
	682
	683	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	684
	685	func Close(fd int) (err error) {
	686	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
	687	if e1 != 0 {
	688	err = errnoErr(e1)
	689	}
	690	return
	691	}
	692
	693	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	694
	695	func Dup(fd int) (nfd int, err error) {
	696	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	697	nfd = int(r0)
	698	if e1 != 0 {
	699	err = errnoErr(e1)
	700	}
	701	return
	702	}
	703
	704	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	705
	706	func Dup2(from int, to int) (err error) {
	707	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
	708	if e1 != 0 {
	709	err = errnoErr(e1)
	710	}
	711	return
	712	}
	713
	714	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	715
	716	func Exchangedata(path1 string, path2 string, options int) (err error) {
	717	var _p0 *byte
	718	_p0, err = BytePtrFromString(path1)
	719	if err != nil {
	720	return
	721	}
	722	var _p1 *byte
	723	_p1, err = BytePtrFromString(path2)
	724	if err != nil {
	725	return
	726	}
	727	_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	728	if e1 != 0 {
	729	err = errnoErr(e1)
	730	}
	731	return
	732	}
	733
	734	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	735
	736	func Exit(code int) {
	737	Syscall(SYS_EXIT, uintptr(code), 0, 0)
	738	return
	739	}
	740
	741	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	742
	743	func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
	744	var _p0 *byte
	745	_p0, err = BytePtrFromString(path)
	746	if err != nil {
	747	return
	748	}
	749	_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	750	if e1 != 0 {
	751	err = errnoErr(e1)
	752	}
	753	return
	754	}
	755
	756	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	757
	758	func Fchdir(fd int) (err error) {
	759	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
	760	if e1 != 0 {
	761	err = errnoErr(e1)
	762	}
	763	return
	764	}
	765
	766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	767
	768	func Fchflags(fd int, flags int) (err error) {
	769	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
	770	if e1 != 0 {
	771	err = errnoErr(e1)
	772	}
	773	return
	774	}
	775
	776	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	777
	778	func Fchmod(fd int, mode uint32) (err error) {
	779	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
	780	if e1 != 0 {
	781	err = errnoErr(e1)
	782	}
	783	return
	784	}
	785
	786	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	787
	788	func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
	789	var _p0 *byte
	790	_p0, err = BytePtrFromString(path)
	791	if err != nil {
	792	return
	793	}
	794	_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	795	if e1 != 0 {
	796	err = errnoErr(e1)
	797	}
	798	return
	799	}
	800
	801	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	802
	803	func Fchown(fd int, uid int, gid int) (err error) {
	804	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
	805	if e1 != 0 {
	806	err = errnoErr(e1)
	807	}
	808	return
	809	}
	810
	811	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	812
	813	func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
	814	var _p0 *byte
	815	_p0, err = BytePtrFromString(path)
	816	if err != nil {
	817	return
	818	}
	819	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	820	if e1 != 0 {
	821	err = errnoErr(e1)
	822	}
	823	return
	824	}
	825
	826	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	827
	828	func Flock(fd int, how int) (err error) {
	829	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
	830	if e1 != 0 {
	831	err = errnoErr(e1)
	832	}
	833	return
	834	}
	835
	836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	837
	838	func Fpathconf(fd int, name int) (val int, err error) {
	839	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	840	val = int(r0)
	841	if e1 != 0 {
	842	err = errnoErr(e1)
	843	}
	844	return
	845	}
	846
	847	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	848
	849	func Fsync(fd int) (err error) {
	850	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
	851	if e1 != 0 {
	852	err = errnoErr(e1)
	853	}
	854	return
	855	}
	856
	857	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	858
	859	func Ftruncate(fd int, length int64) (err error) {
	860	_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), uintptr(length>>32))
	861	if e1 != 0 {
	862	err = errnoErr(e1)
	863	}
	864	return
	865	}
	866
	867	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	868
	869	func Getdtablesize() (size int) {
	870	r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	871	size = int(r0)
	872	return
	873	}
	874
	875	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	876
	877	func Getegid() (egid int) {
	878	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	879	egid = int(r0)
	880	return
	881	}
	882
	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	884
	885	func Geteuid() (uid int) {
	886	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	887	uid = int(r0)
	888	return
	889	}
	890
	891	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	892
	893	func Getgid() (gid int) {
	894	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	895	gid = int(r0)
	896	return
	897	}
	898
	899	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	900
	901	func Getpgid(pid int) (pgid int, err error) {
	902	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	903	pgid = int(r0)
	904	if e1 != 0 {
	905	err = errnoErr(e1)
	906	}
	907	return
	908	}
	909
	910	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	911
	912	func Getpgrp() (pgrp int) {
	913	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	914	pgrp = int(r0)
	915	return
	916	}
	917
	918	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	919
	920	func Getpid() (pid int) {
	921	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	922	pid = int(r0)
	923	return
	924	}
	925
	926	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	927
	928	func Getppid() (ppid int) {
	929	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	930	ppid = int(r0)
	931	return
	932	}
	933
	934	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	935
	936	func Getpriority(which int, who int) (prio int, err error) {
	937	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	938	prio = int(r0)
	939	if e1 != 0 {
	940	err = errnoErr(e1)
	941	}
	942	return
	943	}
	944
	945	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	946
	947	func Getrlimit(which int, lim *Rlimit) (err error) {
	948	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	949	if e1 != 0 {
	950	err = errnoErr(e1)
	951	}
	952	return
	953	}
	954
	955	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	956
	957	func Getrusage(who int, rusage *Rusage) (err error) {
	958	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	959	if e1 != 0 {
	960	err = errnoErr(e1)
	961	}
	962	return
	963	}
	964
	965	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	966
	967	func Getsid(pid int) (sid int, err error) {
	968	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	969	sid = int(r0)
	970	if e1 != 0 {
	971	err = errnoErr(e1)
	972	}
	973	return
	974	}
	975
	976	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	977
	978	func Getuid() (uid int) {
	979	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	980	uid = int(r0)
	981	return
	982	}
	983
	984	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	985
	986	func Issetugid() (tainted bool) {
	987	r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	988	tainted = bool(r0 != 0)
	989	return
	990	}
	991
	992	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	993
	994	func Kqueue() (fd int, err error) {
	995	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	996	fd = int(r0)
	997	if e1 != 0 {
	998	err = errnoErr(e1)
	999	}
	1000	return
	1001	}
	1002
	1003	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1004
	1005	func Lchown(path string, uid int, gid int) (err error) {
	1006	var _p0 *byte
	1007	_p0, err = BytePtrFromString(path)
	1008	if err != nil {
	1009	return
	1010	}
	1011	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1012	if e1 != 0 {
	1013	err = errnoErr(e1)
	1014	}
	1015	return
	1016	}
	1017
	1018	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1019
	1020	func Link(path string, link string) (err error) {
	1021	var _p0 *byte
	1022	_p0, err = BytePtrFromString(path)
	1023	if err != nil {
	1024	return
	1025	}
	1026	var _p1 *byte
	1027	_p1, err = BytePtrFromString(link)
	1028	if err != nil {
	1029	return
	1030	}
	1031	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1032	if e1 != 0 {
	1033	err = errnoErr(e1)
	1034	}
	1035	return
	1036	}
	1037
	1038	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1039
	1040	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1041	var _p0 *byte
	1042	_p0, err = BytePtrFromString(path)
	1043	if err != nil {
	1044	return
	1045	}
	1046	var _p1 *byte
	1047	_p1, err = BytePtrFromString(link)
	1048	if err != nil {
	1049	return
	1050	}
	1051	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1052	if e1 != 0 {
	1053	err = errnoErr(e1)
	1054	}
	1055	return
	1056	}
	1057
	1058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1059
	1060	func Listen(s int, backlog int) (err error) {
	1061	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
	1062	if e1 != 0 {
	1063	err = errnoErr(e1)
	1064	}
	1065	return
	1066	}
	1067
	1068	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1069
	1070	func Mkdir(path string, mode uint32) (err error) {
	1071	var _p0 *byte
	1072	_p0, err = BytePtrFromString(path)
	1073	if err != nil {
	1074	return
	1075	}
	1076	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1077	if e1 != 0 {
	1078	err = errnoErr(e1)
	1079	}
	1080	return
	1081	}
	1082
	1083	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1084
	1085	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1086	var _p0 *byte
	1087	_p0, err = BytePtrFromString(path)
	1088	if err != nil {
	1089	return
	1090	}
	1091	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1092	if e1 != 0 {
	1093	err = errnoErr(e1)
	1094	}
	1095	return
	1096	}
	1097
	1098	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1099
	1100	func Mkfifo(path string, mode uint32) (err error) {
	1101	var _p0 *byte
	1102	_p0, err = BytePtrFromString(path)
	1103	if err != nil {
	1104	return
	1105	}
	1106	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1107	if e1 != 0 {
	1108	err = errnoErr(e1)
	1109	}
	1110	return
	1111	}
	1112
	1113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1114
	1115	func Mknod(path string, mode uint32, dev int) (err error) {
	1116	var _p0 *byte
	1117	_p0, err = BytePtrFromString(path)
	1118	if err != nil {
	1119	return
	1120	}
	1121	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1122	if e1 != 0 {
	1123	err = errnoErr(e1)
	1124	}
	1125	return
	1126	}
	1127
	1128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1129
	1130	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1131	var _p0 *byte
	1132	_p0, err = BytePtrFromString(path)
	1133	if err != nil {
	1134	return
	1135	}
	1136	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1137	fd = int(r0)
	1138	if e1 != 0 {
	1139	err = errnoErr(e1)
	1140	}
	1141	return
	1142	}
	1143
	1144	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1145
	1146	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1147	var _p0 *byte
	1148	_p0, err = BytePtrFromString(path)
	1149	if err != nil {
	1150	return
	1151	}
	1152	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1153	fd = int(r0)
	1154	if e1 != 0 {
	1155	err = errnoErr(e1)
	1156	}
	1157	return
	1158	}
	1159
	1160	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1161
	1162	func Pathconf(path string, name int) (val int, err error) {
	1163	var _p0 *byte
	1164	_p0, err = BytePtrFromString(path)
	1165	if err != nil {
	1166	return
	1167	}
	1168	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1169	val = int(r0)
	1170	if e1 != 0 {
	1171	err = errnoErr(e1)
	1172	}
	1173	return
	1174	}
	1175
	1176	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1177
	1178	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1179	var _p0 unsafe.Pointer
	1180	if len(p) > 0 {
	1181	_p0 = unsafe.Pointer(&p[0])
	1182	} else {
	1183	_p0 = unsafe.Pointer(&_zero)
	1184	}
	1185	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1186	n = int(r0)
	1187	if e1 != 0 {
	1188	err = errnoErr(e1)
	1189	}
	1190	return
	1191	}
	1192
	1193	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1194
	1195	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1196	var _p0 unsafe.Pointer
	1197	if len(p) > 0 {
	1198	_p0 = unsafe.Pointer(&p[0])
	1199	} else {
	1200	_p0 = unsafe.Pointer(&_zero)
	1201	}
	1202	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1203	n = int(r0)
	1204	if e1 != 0 {
	1205	err = errnoErr(e1)
	1206	}
	1207	return
	1208	}
	1209
	1210	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1211
	1212	func read(fd int, p []byte) (n int, err error) {
	1213	var _p0 unsafe.Pointer
	1214	if len(p) > 0 {
	1215	_p0 = unsafe.Pointer(&p[0])
	1216	} else {
	1217	_p0 = unsafe.Pointer(&_zero)
	1218	}
	1219	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1220	n = int(r0)
	1221	if e1 != 0 {
	1222	err = errnoErr(e1)
	1223	}
	1224	return
	1225	}
	1226
	1227	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1228
	1229	func Readlink(path string, buf []byte) (n int, err error) {
	1230	var _p0 *byte
	1231	_p0, err = BytePtrFromString(path)
	1232	if err != nil {
	1233	return
	1234	}
	1235	var _p1 unsafe.Pointer
	1236	if len(buf) > 0 {
	1237	_p1 = unsafe.Pointer(&buf[0])
	1238	} else {
	1239	_p1 = unsafe.Pointer(&_zero)
	1240	}
	1241	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1242	n = int(r0)
	1243	if e1 != 0 {
	1244	err = errnoErr(e1)
	1245	}
	1246	return
	1247	}
	1248
	1249	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1250
	1251	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1252	var _p0 *byte
	1253	_p0, err = BytePtrFromString(path)
	1254	if err != nil {
	1255	return
	1256	}
	1257	var _p1 unsafe.Pointer
	1258	if len(buf) > 0 {
	1259	_p1 = unsafe.Pointer(&buf[0])
	1260	} else {
	1261	_p1 = unsafe.Pointer(&_zero)
	1262	}
	1263	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1264	n = int(r0)
	1265	if e1 != 0 {
	1266	err = errnoErr(e1)
	1267	}
	1268	return
	1269	}
	1270
	1271	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1272
	1273	func Rename(from string, to string) (err error) {
	1274	var _p0 *byte
	1275	_p0, err = BytePtrFromString(from)
	1276	if err != nil {
	1277	return
	1278	}
	1279	var _p1 *byte
	1280	_p1, err = BytePtrFromString(to)
	1281	if err != nil {
	1282	return
	1283	}
	1284	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1285	if e1 != 0 {
	1286	err = errnoErr(e1)
	1287	}
	1288	return
	1289	}
	1290
	1291	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1292
	1293	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1294	var _p0 *byte
	1295	_p0, err = BytePtrFromString(from)
	1296	if err != nil {
	1297	return
	1298	}
	1299	var _p1 *byte
	1300	_p1, err = BytePtrFromString(to)
	1301	if err != nil {
	1302	return
	1303	}
	1304	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1305	if e1 != 0 {
	1306	err = errnoErr(e1)
	1307	}
	1308	return
	1309	}
	1310
	1311	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1312
	1313	func Revoke(path string) (err error) {
	1314	var _p0 *byte
	1315	_p0, err = BytePtrFromString(path)
	1316	if err != nil {
	1317	return
	1318	}
	1319	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1320	if e1 != 0 {
	1321	err = errnoErr(e1)
	1322	}
	1323	return
	1324	}
	1325
	1326	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1327
	1328	func Rmdir(path string) (err error) {
	1329	var _p0 *byte
	1330	_p0, err = BytePtrFromString(path)
	1331	if err != nil {
	1332	return
	1333	}
	1334	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1335	if e1 != 0 {
	1336	err = errnoErr(e1)
	1337	}
	1338	return
	1339	}
	1340
	1341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1342
	1343	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1344	r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
	1345	newoffset = int64(int64(r1)<<32 \| int64(r0))
	1346	if e1 != 0 {
	1347	err = errnoErr(e1)
	1348	}
	1349	return
	1350	}
	1351
	1352	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1353
	1354	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1355	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
	1356	if e1 != 0 {
	1357	err = errnoErr(e1)
	1358	}
	1359	return
	1360	}
	1361
	1362	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1363
	1364	func Setegid(egid int) (err error) {
	1365	_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
	1366	if e1 != 0 {
	1367	err = errnoErr(e1)
	1368	}
	1369	return
	1370	}
	1371
	1372	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1373
	1374	func Seteuid(euid int) (err error) {
	1375	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
	1376	if e1 != 0 {
	1377	err = errnoErr(e1)
	1378	}
	1379	return
	1380	}
	1381
	1382	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1383
	1384	func Setgid(gid int) (err error) {
	1385	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
	1386	if e1 != 0 {
	1387	err = errnoErr(e1)
	1388	}
	1389	return
	1390	}
	1391
	1392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1393
	1394	func Setlogin(name string) (err error) {
	1395	var _p0 *byte
	1396	_p0, err = BytePtrFromString(name)
	1397	if err != nil {
	1398	return
	1399	}
	1400	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1401	if e1 != 0 {
	1402	err = errnoErr(e1)
	1403	}
	1404	return
	1405	}
	1406
	1407	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1408
	1409	func Setpgid(pid int, pgid int) (err error) {
	1410	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
	1411	if e1 != 0 {
	1412	err = errnoErr(e1)
	1413	}
	1414	return
	1415	}
	1416
	1417	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1418
	1419	func Setpriority(which int, who int, prio int) (err error) {
	1420	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
	1421	if e1 != 0 {
	1422	err = errnoErr(e1)
	1423	}
	1424	return
	1425	}
	1426
	1427	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1428
	1429	func Setprivexec(flag int) (err error) {
	1430	_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
	1431	if e1 != 0 {
	1432	err = errnoErr(e1)
	1433	}
	1434	return
	1435	}
	1436
	1437	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1438
	1439	func Setregid(rgid int, egid int) (err error) {
	1440	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
	1441	if e1 != 0 {
	1442	err = errnoErr(e1)
	1443	}
	1444	return
	1445	}
	1446
	1447	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1448
	1449	func Setreuid(ruid int, euid int) (err error) {
	1450	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
	1451	if e1 != 0 {
	1452	err = errnoErr(e1)
	1453	}
	1454	return
	1455	}
	1456
	1457	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1458
	1459	func Setrlimit(which int, lim *Rlimit) (err error) {
	1460	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1461	if e1 != 0 {
	1462	err = errnoErr(e1)
	1463	}
	1464	return
	1465	}
	1466
	1467	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1468
	1469	func Setsid() (pid int, err error) {
	1470	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	1471	pid = int(r0)
	1472	if e1 != 0 {
	1473	err = errnoErr(e1)
	1474	}
	1475	return
	1476	}
	1477
	1478	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1479
	1480	func Settimeofday(tp *Timeval) (err error) {
	1481	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1482	if e1 != 0 {
	1483	err = errnoErr(e1)
	1484	}
	1485	return
	1486	}
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Setuid(uid int) (err error) {
	1491	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1499
	1500	func Symlink(path string, link string) (err error) {
	1501	var _p0 *byte
	1502	_p0, err = BytePtrFromString(path)
	1503	if err != nil {
	1504	return
	1505	}
	1506	var _p1 *byte
	1507	_p1, err = BytePtrFromString(link)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1519
	1520	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	1521	var _p0 *byte
	1522	_p0, err = BytePtrFromString(oldpath)
	1523	if err != nil {
	1524	return
	1525	}
	1526	var _p1 *byte
	1527	_p1, err = BytePtrFromString(newpath)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1539
	1540	func Sync() (err error) {
	1541	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
	1542	if e1 != 0 {
	1543	err = errnoErr(e1)
	1544	}
	1545	return
	1546	}
	1547
	1548	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1549
	1550	func Truncate(path string, length int64) (err error) {
	1551	var _p0 *byte
	1552	_p0, err = BytePtrFromString(path)
	1553	if err != nil {
	1554	return
	1555	}
	1556	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
	1557	if e1 != 0 {
	1558	err = errnoErr(e1)
	1559	}
	1560	return
	1561	}
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Umask(newmask int) (oldmask int) {
	1566	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	1567	oldmask = int(r0)
	1568	return
	1569	}
	1570
	1571	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1572
	1573	func Undelete(path string) (err error) {
	1574	var _p0 *byte
	1575	_p0, err = BytePtrFromString(path)
	1576	if err != nil {
	1577	return
	1578	}
	1579	_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1580	if e1 != 0 {
	1581	err = errnoErr(e1)
	1582	}
	1583	return
	1584	}
	1585
	1586	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1587
	1588	func Unlink(path string) (err error) {
	1589	var _p0 *byte
	1590	_p0, err = BytePtrFromString(path)
	1591	if err != nil {
	1592	return
	1593	}
	1594	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1595	if e1 != 0 {
	1596	err = errnoErr(e1)
	1597	}
	1598	return
	1599	}
	1600
	1601	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1602
	1603	func Unlinkat(dirfd int, path string, flags int) (err error) {
	1604	var _p0 *byte
	1605	_p0, err = BytePtrFromString(path)
	1606	if err != nil {
	1607	return
	1608	}
	1609	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	1610	if e1 != 0 {
	1611	err = errnoErr(e1)
	1612	}
	1613	return
	1614	}
	1615
	1616	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1617
	1618	func Unmount(path string, flags int) (err error) {
	1619	var _p0 *byte
	1620	_p0, err = BytePtrFromString(path)
	1621	if err != nil {
	1622	return
	1623	}
	1624	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	1625	if e1 != 0 {
	1626	err = errnoErr(e1)
	1627	}
	1628	return
	1629	}
	1630
	1631	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1632
	1633	func write(fd int, p []byte) (n int, err error) {
	1634	var _p0 unsafe.Pointer
	1635	if len(p) > 0 {
	1636	_p0 = unsafe.Pointer(&p[0])
	1637	} else {
	1638	_p0 = unsafe.Pointer(&_zero)
	1639	}
	1640	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1641	n = int(r0)
	1642	if e1 != 0 {
	1643	err = errnoErr(e1)
	1644	}
	1645	return
	1646	}
	1647
	1648	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1649
	1650	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	1651	r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
	1652	ret = uintptr(r0)
	1653	if e1 != 0 {
	1654	err = errnoErr(e1)
	1655	}
	1656	return
	1657	}
	1658
	1659	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1660
	1661	func munmap(addr uintptr, length uintptr) (err error) {
	1662	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
	1663	if e1 != 0 {
	1664	err = errnoErr(e1)
	1665	}
	1666	return
	1667	}
	1668
	1669	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1670
	1671	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	1672	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1673	n = int(r0)
	1674	if e1 != 0 {
	1675	err = errnoErr(e1)
	1676	}
	1677	return
	1678	}
	1679
	1680	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1681
	1682	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	1683	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1684	n = int(r0)
	1685	if e1 != 0 {
	1686	err = errnoErr(e1)
	1687	}
	1688	return
	1689	}
	1690
	1691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1692
	1693	func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	1694	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1695	sec = int32(r0)
	1696	usec = int32(r1)
	1697	if e1 != 0 {
	1698	err = errnoErr(e1)
	1699	}
	1700	return
	1701	}
	1702
	1703	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1704
	1705	func Fstat(fd int, stat *Stat_t) (err error) {
	1706	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1707	if e1 != 0 {
	1708	err = errnoErr(e1)
	1709	}
	1710	return
	1711	}
	1712
	1713	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1714
	1715	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	1716	var _p0 *byte
	1717	_p0, err = BytePtrFromString(path)
	1718	if err != nil {
	1719	return
	1720	}
	1721	_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	1722	if e1 != 0 {
	1723	err = errnoErr(e1)
	1724	}
	1725	return
	1726	}
	1727
	1728	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1729
	1730	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	1731	_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1732	if e1 != 0 {
	1733	err = errnoErr(e1)
	1734	}
	1735	return
	1736	}
	1737
	1738	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1739
	1740	func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
	1741	var _p0 unsafe.Pointer
	1742	if len(buf) > 0 {
	1743	_p0 = unsafe.Pointer(&buf[0])
	1744	} else {
	1745	_p0 = unsafe.Pointer(&_zero)
	1746	}
	1747	r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
	1748	n = int(r0)
	1749	if e1 != 0 {
	1750	err = errnoErr(e1)
	1751	}
	1752	return
	1753	}
	1754
	1755	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1756
	1757	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	1758	r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(buf), uintptr(size), uintptr(flags))
	1759	n = int(r0)
	1760	if e1 != 0 {
	1761	err = errnoErr(e1)
	1762	}
	1763	return
	1764	}
	1765
	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1767
	1768	func Lstat(path string, stat *Stat_t) (err error) {
	1769	var _p0 *byte
	1770	_p0, err = BytePtrFromString(path)
	1771	if err != nil {
	1772	return
	1773	}
	1774	_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1775	if e1 != 0 {
	1776	err = errnoErr(e1)
	1777	}
	1778	return
	1779	}
	1780
	1781	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1782
	1783	func Stat(path string, stat *Stat_t) (err error) {
	1784	var _p0 *byte
	1785	_p0, err = BytePtrFromString(path)
	1786	if err != nil {
	1787	return
	1788	}
	1789	_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1790	if e1 != 0 {
	1791	err = errnoErr(e1)
	1792	}
	1793	return
	1794	}
	1795
	1796	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1797
	1798	func Statfs(path string, stat *Statfs_t) (err error) {
	1799	var _p0 *byte
	1800	_p0, err = BytePtrFromString(path)
	1801	if err != nil {
	1802	return
	1803	}
	1804	_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}

+1920

-1184

unix/zsyscall_darwin_386.go less more

0		// go run mksyscall.go -l32 -tags darwin,386 syscall_bsd.go syscall_darwin.go syscall_darwin_386.go
	0	// go run mksyscall.go -l32 -tags darwin,386,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_386.go
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3		// +build darwin,386
	3	// +build darwin,386,go1.12
4	4
5	5	package unix
6	6

14	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
15	15
16	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
17		r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	17	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
18	18	n = int(r0)
19	19	if e1 != 0 {
20	20	err = errnoErr(e1)

22	22	return
23	23	}
24	24
	25	func libc_getgroups_trampoline()
	26
	27	//go:linkname libc_getgroups libc_getgroups
	28	//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
	29
25	30	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
26	31
27	32	func setgroups(ngid int, gid *_Gid_t) (err error) {
28		_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
29		if e1 != 0 {
30		err = errnoErr(e1)
31		}
32		return
33		}
	33	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	34	if e1 != 0 {
	35	err = errnoErr(e1)
	36	}
	37	return
	38	}
	39
	40	func libc_setgroups_trampoline()
	41
	42	//go:linkname libc_setgroups libc_setgroups
	43	//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
34	44
35	45	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
36	46
37	47	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
38		r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	48	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
39	49	wpid = int(r0)
40	50	if e1 != 0 {
41	51	err = errnoErr(e1)

43	53	return
44	54	}
45	55
	56	func libc_wait4_trampoline()
	57
	58	//go:linkname libc_wait4 libc_wait4
	59	//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
	60
46	61	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
47	62
48	63	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
49		r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	64	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
50	65	fd = int(r0)
51	66	if e1 != 0 {
52	67	err = errnoErr(e1)

54	69	return
55	70	}
56	71
	72	func libc_accept_trampoline()
	73
	74	//go:linkname libc_accept libc_accept
	75	//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
	76
57	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
58	78
59	79	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
60		_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
61		if e1 != 0 {
62		err = errnoErr(e1)
63		}
64		return
65		}
	80	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	81	if e1 != 0 {
	82	err = errnoErr(e1)
	83	}
	84	return
	85	}
	86
	87	func libc_bind_trampoline()
	88
	89	//go:linkname libc_bind libc_bind
	90	//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
66	91
67	92	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
68	93
69	94	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
70		_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
71		if e1 != 0 {
72		err = errnoErr(e1)
73		}
74		return
75		}
	95	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	96	if e1 != 0 {
	97	err = errnoErr(e1)
	98	}
	99	return
	100	}
	101
	102	func libc_connect_trampoline()
	103
	104	//go:linkname libc_connect libc_connect
	105	//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
76	106
77	107	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
78	108
79	109	func socket(domain int, typ int, proto int) (fd int, err error) {
80		r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	110	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
81	111	fd = int(r0)
82	112	if e1 != 0 {
83	113	err = errnoErr(e1)

85	115	return
86	116	}
87	117
	118	func libc_socket_trampoline()
	119
	120	//go:linkname libc_socket libc_socket
	121	//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
	122
88	123	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
89	124
90	125	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
91		_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
92		if e1 != 0 {
93		err = errnoErr(e1)
94		}
95		return
96		}
	126	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	127	if e1 != 0 {
	128	err = errnoErr(e1)
	129	}
	130	return
	131	}
	132
	133	func libc_getsockopt_trampoline()
	134
	135	//go:linkname libc_getsockopt libc_getsockopt
	136	//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
97	137
98	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
99	139
100	140	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
101		_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
102		if e1 != 0 {
103		err = errnoErr(e1)
104		}
105		return
106		}
	141	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	func libc_setsockopt_trampoline()
	149
	150	//go:linkname libc_setsockopt libc_setsockopt
	151	//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
107	152
108	153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
109	154
110	155	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
111		_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
112		if e1 != 0 {
113		err = errnoErr(e1)
114		}
115		return
116		}
	156	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	157	if e1 != 0 {
	158	err = errnoErr(e1)
	159	}
	160	return
	161	}
	162
	163	func libc_getpeername_trampoline()
	164
	165	//go:linkname libc_getpeername libc_getpeername
	166	//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
117	167
118	168	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
119	169
120	170	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
121		_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
122		if e1 != 0 {
123		err = errnoErr(e1)
124		}
125		return
126		}
	171	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	172	if e1 != 0 {
	173	err = errnoErr(e1)
	174	}
	175	return
	176	}
	177
	178	func libc_getsockname_trampoline()
	179
	180	//go:linkname libc_getsockname libc_getsockname
	181	//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
127	182
128	183	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
129	184
130	185	func Shutdown(s int, how int) (err error) {
131		_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
132		if e1 != 0 {
133		err = errnoErr(e1)
134		}
135		return
136		}
	186	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
	187	if e1 != 0 {
	188	err = errnoErr(e1)
	189	}
	190	return
	191	}
	192
	193	func libc_shutdown_trampoline()
	194
	195	//go:linkname libc_shutdown libc_shutdown
	196	//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
137	197
138	198	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
139	199
140	200	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
141		_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
142		if e1 != 0 {
143		err = errnoErr(e1)
144		}
145		return
146		}
	201	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	202	if e1 != 0 {
	203	err = errnoErr(e1)
	204	}
	205	return
	206	}
	207
	208	func libc_socketpair_trampoline()
	209
	210	//go:linkname libc_socketpair libc_socketpair
	211	//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
147	212
148	213	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
149	214

154	219	} else {
155	220	_p0 = unsafe.Pointer(&_zero)
156	221	}
157		r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	222	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)))
158	223	n = int(r0)
159	224	if e1 != 0 {
160	225	err = errnoErr(e1)
161	226	}
162	227	return
163	228	}
	229
	230	func libc_recvfrom_trampoline()
	231
	232	//go:linkname libc_recvfrom libc_recvfrom
	233	//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
164	234
165	235	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
166	236

171	241	} else {
172	242	_p0 = unsafe.Pointer(&_zero)
173	243	}
174		_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
175		if e1 != 0 {
176		err = errnoErr(e1)
177		}
178		return
179		}
	244	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	245	if e1 != 0 {
	246	err = errnoErr(e1)
	247	}
	248	return
	249	}
	250
	251	func libc_sendto_trampoline()
	252
	253	//go:linkname libc_sendto libc_sendto
	254	//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
180	255
181	256	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
182	257
183	258	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
184		r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	259	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
185	260	n = int(r0)
186	261	if e1 != 0 {
187	262	err = errnoErr(e1)

189	264	return
190	265	}
191	266
	267	func libc_recvmsg_trampoline()
	268
	269	//go:linkname libc_recvmsg libc_recvmsg
	270	//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
	271
192	272	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
193	273
194	274	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
195		r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	275	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
196	276	n = int(r0)
197	277	if e1 != 0 {
198	278	err = errnoErr(e1)

200	280	return
201	281	}
202	282
	283	func libc_sendmsg_trampoline()
	284
	285	//go:linkname libc_sendmsg libc_sendmsg
	286	//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
	287
203	288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
204	289
205	290	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
206		r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	291	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
207	292	n = int(r0)
208	293	if e1 != 0 {
209	294	err = errnoErr(e1)
210	295	}
211	296	return
212	297	}
	298
	299	func libc_kevent_trampoline()
	300
	301	//go:linkname libc_kevent libc_kevent
	302	//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
213	303
214	304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
215	305

220	310	} else {
221	311	_p0 = unsafe.Pointer(&_zero)
222	312	}
223		_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
224		if e1 != 0 {
225		err = errnoErr(e1)
226		}
227		return
228		}
	313	_, _, 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))
	314	if e1 != 0 {
	315	err = errnoErr(e1)
	316	}
	317	return
	318	}
	319
	320	func libc___sysctl_trampoline()
	321
	322	//go:linkname libc___sysctl libc___sysctl
	323	//go:cgo_import_dynamic libc___sysctl __sysctl "/usr/lib/libSystem.B.dylib"
229	324
230	325	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
231	326

235	330	if err != nil {
236	331	return
237	332	}
238		_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
239		if e1 != 0 {
240		err = errnoErr(e1)
241		}
242		return
243		}
	333	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	334	if e1 != 0 {
	335	err = errnoErr(e1)
	336	}
	337	return
	338	}
	339
	340	func libc_utimes_trampoline()
	341
	342	//go:linkname libc_utimes libc_utimes
	343	//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
244	344
245	345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
246	346
247	347	func futimes(fd int, timeval *[2]Timeval) (err error) {
248		_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
249		if e1 != 0 {
250		err = errnoErr(e1)
251		}
252		return
253		}
	348	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	349	if e1 != 0 {
	350	err = errnoErr(e1)
	351	}
	352	return
	353	}
	354
	355	func libc_futimes_trampoline()
	356
	357	//go:linkname libc_futimes libc_futimes
	358	//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
254	359
255	360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
256	361
257	362	func fcntl(fd int, cmd int, arg int) (val int, err error) {
258		r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	363	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
259	364	val = int(r0)
260	365	if e1 != 0 {
261	366	err = errnoErr(e1)

263	368	return
264	369	}
265	370
	371	func libc_fcntl_trampoline()
	372
	373	//go:linkname libc_fcntl libc_fcntl
	374	//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
	375
266	376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
267	377
268	378	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
269		r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	379	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
270	380	n = int(r0)
271	381	if e1 != 0 {
272	382	err = errnoErr(e1)
273	383	}
274	384	return
275	385	}
	386
	387	func libc_poll_trampoline()
	388
	389	//go:linkname libc_poll libc_poll
	390	//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
276	391
277	392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
278	393

283	398	} else {
284	399	_p0 = unsafe.Pointer(&_zero)
285	400	}
286		_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
287		if e1 != 0 {
288		err = errnoErr(e1)
289		}
290		return
291		}
	401	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
	402	if e1 != 0 {
	403	err = errnoErr(e1)
	404	}
	405	return
	406	}
	407
	408	func libc_madvise_trampoline()
	409
	410	//go:linkname libc_madvise libc_madvise
	411	//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
292	412
293	413	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
294	414

299	419	} else {
300	420	_p0 = unsafe.Pointer(&_zero)
301	421	}
302		_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
303		if e1 != 0 {
304		err = errnoErr(e1)
305		}
306		return
307		}
	422	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	423	if e1 != 0 {
	424	err = errnoErr(e1)
	425	}
	426	return
	427	}
	428
	429	func libc_mlock_trampoline()
	430
	431	//go:linkname libc_mlock libc_mlock
	432	//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
308	433
309	434	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
310	435
311	436	func Mlockall(flags int) (err error) {
312		_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
313		if e1 != 0 {
314		err = errnoErr(e1)
315		}
316		return
317		}
	437	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
	438	if e1 != 0 {
	439	err = errnoErr(e1)
	440	}
	441	return
	442	}
	443
	444	func libc_mlockall_trampoline()
	445
	446	//go:linkname libc_mlockall libc_mlockall
	447	//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
318	448
319	449	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
320	450

325	455	} else {
326	456	_p0 = unsafe.Pointer(&_zero)
327	457	}
328		_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
329		if e1 != 0 {
330		err = errnoErr(e1)
331		}
332		return
333		}
	458	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
	459	if e1 != 0 {
	460	err = errnoErr(e1)
	461	}
	462	return
	463	}
	464
	465	func libc_mprotect_trampoline()
	466
	467	//go:linkname libc_mprotect libc_mprotect
	468	//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
334	469
335	470	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
336	471

341	476	} else {
342	477	_p0 = unsafe.Pointer(&_zero)
343	478	}
344		_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
345		if e1 != 0 {
346		err = errnoErr(e1)
347		}
348		return
349		}
	479	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
	480	if e1 != 0 {
	481	err = errnoErr(e1)
	482	}
	483	return
	484	}
	485
	486	func libc_msync_trampoline()
	487
	488	//go:linkname libc_msync libc_msync
	489	//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
350	490
351	491	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
352	492

357	497	} else {
358	498	_p0 = unsafe.Pointer(&_zero)
359	499	}
360		_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
361		if e1 != 0 {
362		err = errnoErr(e1)
363		}
364		return
365		}
	500	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	501	if e1 != 0 {
	502	err = errnoErr(e1)
	503	}
	504	return
	505	}
	506
	507	func libc_munlock_trampoline()
	508
	509	//go:linkname libc_munlock libc_munlock
	510	//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
366	511
367	512	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
368	513
369	514	func Munlockall() (err error) {
370		_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
371		if e1 != 0 {
372		err = errnoErr(e1)
373		}
374		return
375		}
	515	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
	516	if e1 != 0 {
	517	err = errnoErr(e1)
	518	}
	519	return
	520	}
	521
	522	func libc_munlockall_trampoline()
	523
	524	//go:linkname libc_munlockall libc_munlockall
	525	//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
376	526
377	527	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
378	528
379	529	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
380		_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
381		if e1 != 0 {
382		err = errnoErr(e1)
383		}
384		return
385		}
	530	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	531	if e1 != 0 {
	532	err = errnoErr(e1)
	533	}
	534	return
	535	}
	536
	537	func libc_ptrace_trampoline()
	538
	539	//go:linkname libc_ptrace libc_ptrace
	540	//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
	541
	542	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	543
	544	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	545	_, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	546	if e1 != 0 {
	547	err = errnoErr(e1)
	548	}
	549	return
	550	}
	551
	552	func libc_getattrlist_trampoline()
	553
	554	//go:linkname libc_getattrlist libc_getattrlist
	555	//go:cgo_import_dynamic libc_getattrlist getattrlist "/usr/lib/libSystem.B.dylib"
386	556
387	557	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
388	558
389	559	func pipe() (r int, w int, err error) {
390		r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	560	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
391	561	r = int(r0)
392	562	w = int(r1)
393	563	if e1 != 0 {

396	566	return
397	567	}
398	568
	569	func libc_pipe_trampoline()
	570
	571	//go:linkname libc_pipe libc_pipe
	572	//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
	573
399	574	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
400	575
401	576	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

409	584	if err != nil {
410	585	return
411	586	}
412		r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	587	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))
413	588	sz = int(r0)
414	589	if e1 != 0 {
415	590	err = errnoErr(e1)

417	592	return
418	593	}
419	594
	595	func libc_getxattr_trampoline()
	596
	597	//go:linkname libc_getxattr libc_getxattr
	598	//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
	599
420	600	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
421	601
422	602	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

425	605	if err != nil {
426	606	return
427	607	}
428		r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	608	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
429	609	sz = int(r0)
430	610	if e1 != 0 {
431	611	err = errnoErr(e1)
432	612	}
433	613	return
434	614	}
	615
	616	func libc_fgetxattr_trampoline()
	617
	618	//go:linkname libc_fgetxattr libc_fgetxattr
	619	//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
435	620
436	621	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
437	622

446	631	if err != nil {
447	632	return
448	633	}
449		_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
450		if e1 != 0 {
451		err = errnoErr(e1)
452		}
453		return
454		}
	634	_, _, 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))
	635	if e1 != 0 {
	636	err = errnoErr(e1)
	637	}
	638	return
	639	}
	640
	641	func libc_setxattr_trampoline()
	642
	643	//go:linkname libc_setxattr libc_setxattr
	644	//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
455	645
456	646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
457	647

461	651	if err != nil {
462	652	return
463	653	}
464		_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
465		if e1 != 0 {
466		err = errnoErr(e1)
467		}
468		return
469		}
	654	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	655	if e1 != 0 {
	656	err = errnoErr(e1)
	657	}
	658	return
	659	}
	660
	661	func libc_fsetxattr_trampoline()
	662
	663	//go:linkname libc_fsetxattr libc_fsetxattr
	664	//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
470	665
471	666	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
472	667

481	676	if err != nil {
482	677	return
483	678	}
484		_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
485		if e1 != 0 {
486		err = errnoErr(e1)
487		}
488		return
489		}
	679	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	680	if e1 != 0 {
	681	err = errnoErr(e1)
	682	}
	683	return
	684	}
	685
	686	func libc_removexattr_trampoline()
	687
	688	//go:linkname libc_removexattr libc_removexattr
	689	//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
490	690
491	691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
492	692

496	696	if err != nil {
497	697	return
498	698	}
499		_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
500		if e1 != 0 {
501		err = errnoErr(e1)
502		}
503		return
504		}
	699	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	700	if e1 != 0 {
	701	err = errnoErr(e1)
	702	}
	703	return
	704	}
	705
	706	func libc_fremovexattr_trampoline()
	707
	708	//go:linkname libc_fremovexattr libc_fremovexattr
	709	//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
505	710
506	711	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
507	712

511	716	if err != nil {
512	717	return
513	718	}
514		r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	719	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
515	720	sz = int(r0)
516	721	if e1 != 0 {
517	722	err = errnoErr(e1)

519	724	return
520	725	}
521	726
	727	func libc_listxattr_trampoline()
	728
	729	//go:linkname libc_listxattr libc_listxattr
	730	//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
	731
522	732	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
523	733
524	734	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
525		r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	735	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
526	736	sz = int(r0)
527	737	if e1 != 0 {
528	738	err = errnoErr(e1)

530	740	return
531	741	}
532	742
	743	func libc_flistxattr_trampoline()
	744
	745	//go:linkname libc_flistxattr libc_flistxattr
	746	//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
	747
	748	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	749
	750	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	751	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	752	if e1 != 0 {
	753	err = errnoErr(e1)
	754	}
	755	return
	756	}
	757
	758	func libc_setattrlist_trampoline()
	759
	760	//go:linkname libc_setattrlist libc_setattrlist
	761	//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
	762
533	763	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
534	764
535	765	func kill(pid int, signum int, posix int) (err error) {
536		_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
537		if e1 != 0 {
538		err = errnoErr(e1)
539		}
540		return
541		}
	766	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
	767	if e1 != 0 {
	768	err = errnoErr(e1)
	769	}
	770	return
	771	}
	772
	773	func libc_kill_trampoline()
	774
	775	//go:linkname libc_kill libc_kill
	776	//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
542	777
543	778	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
544	779
545	780	func ioctl(fd int, req uint, arg uintptr) (err error) {
546		_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
547		if e1 != 0 {
548		err = errnoErr(e1)
549		}
550		return
551		}
	781	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
	782	if e1 != 0 {
	783	err = errnoErr(e1)
	784	}
	785	return
	786	}
	787
	788	func libc_ioctl_trampoline()
	789
	790	//go:linkname libc_ioctl libc_ioctl
	791	//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
	792
	793	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	794
	795	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	796	_, _, e1 := syscall_syscall9(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
	797	if e1 != 0 {
	798	err = errnoErr(e1)
	799	}
	800	return
	801	}
	802
	803	func libc_sendfile_trampoline()
	804
	805	//go:linkname libc_sendfile libc_sendfile
	806	//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
552	807
553	808	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
554	809

558	813	if err != nil {
559	814	return
560	815	}
561		_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
562		if e1 != 0 {
563		err = errnoErr(e1)
564		}
565		return
566		}
	816	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	817	if e1 != 0 {
	818	err = errnoErr(e1)
	819	}
	820	return
	821	}
	822
	823	func libc_access_trampoline()
	824
	825	//go:linkname libc_access libc_access
	826	//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
567	827
568	828	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
569	829
570	830	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
571		_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
572		if e1 != 0 {
573		err = errnoErr(e1)
574		}
575		return
576		}
	831	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	832	if e1 != 0 {
	833	err = errnoErr(e1)
	834	}
	835	return
	836	}
	837
	838	func libc_adjtime_trampoline()
	839
	840	//go:linkname libc_adjtime libc_adjtime
	841	//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
577	842
578	843	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
579	844

583	848	if err != nil {
584	849	return
585	850	}
586		_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
587		if e1 != 0 {
588		err = errnoErr(e1)
589		}
590		return
591		}
	851	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	852	if e1 != 0 {
	853	err = errnoErr(e1)
	854	}
	855	return
	856	}
	857
	858	func libc_chdir_trampoline()
	859
	860	//go:linkname libc_chdir libc_chdir
	861	//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
592	862
593	863	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
594	864

598	868	if err != nil {
599	869	return
600	870	}
601		_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
602		if e1 != 0 {
603		err = errnoErr(e1)
604		}
605		return
606		}
	871	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	872	if e1 != 0 {
	873	err = errnoErr(e1)
	874	}
	875	return
	876	}
	877
	878	func libc_chflags_trampoline()
	879
	880	//go:linkname libc_chflags libc_chflags
	881	//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
607	882
608	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
609	884

613	888	if err != nil {
614	889	return
615	890	}
616		_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
617		if e1 != 0 {
618		err = errnoErr(e1)
619		}
620		return
621		}
	891	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	892	if e1 != 0 {
	893	err = errnoErr(e1)
	894	}
	895	return
	896	}
	897
	898	func libc_chmod_trampoline()
	899
	900	//go:linkname libc_chmod libc_chmod
	901	//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
622	902
623	903	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
624	904

628	908	if err != nil {
629	909	return
630	910	}
631		_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
632		if e1 != 0 {
633		err = errnoErr(e1)
634		}
635		return
636		}
	911	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	912	if e1 != 0 {
	913	err = errnoErr(e1)
	914	}
	915	return
	916	}
	917
	918	func libc_chown_trampoline()
	919
	920	//go:linkname libc_chown libc_chown
	921	//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
637	922
638	923	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
639	924

643	928	if err != nil {
644	929	return
645	930	}
646		_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
647		if e1 != 0 {
648		err = errnoErr(e1)
649		}
650		return
651		}
	931	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	932	if e1 != 0 {
	933	err = errnoErr(e1)
	934	}
	935	return
	936	}
	937
	938	func libc_chroot_trampoline()
	939
	940	//go:linkname libc_chroot libc_chroot
	941	//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
652	942
653	943	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
654	944
655	945	func Close(fd int) (err error) {
656		_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
657		if e1 != 0 {
658		err = errnoErr(e1)
659		}
660		return
661		}
	946	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
	947	if e1 != 0 {
	948	err = errnoErr(e1)
	949	}
	950	return
	951	}
	952
	953	func libc_close_trampoline()
	954
	955	//go:linkname libc_close libc_close
	956	//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
662	957
663	958	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664	959
665	960	func Dup(fd int) (nfd int, err error) {
666		r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	961	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
667	962	nfd = int(r0)
668	963	if e1 != 0 {
669	964	err = errnoErr(e1)

671	966	return
672	967	}
673	968
	969	func libc_dup_trampoline()
	970
	971	//go:linkname libc_dup libc_dup
	972	//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
	973
674	974	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
675	975
676	976	func Dup2(from int, to int) (err error) {
677		_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
678		if e1 != 0 {
679		err = errnoErr(e1)
680		}
681		return
682		}
	977	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
	978	if e1 != 0 {
	979	err = errnoErr(e1)
	980	}
	981	return
	982	}
	983
	984	func libc_dup2_trampoline()
	985
	986	//go:linkname libc_dup2 libc_dup2
	987	//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
683	988
684	989	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
685	990

694	999	if err != nil {
695	1000	return
696	1001	}
697		_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
698		if e1 != 0 {
699		err = errnoErr(e1)
700		}
701		return
702		}
	1002	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	1003	if e1 != 0 {
	1004	err = errnoErr(e1)
	1005	}
	1006	return
	1007	}
	1008
	1009	func libc_exchangedata_trampoline()
	1010
	1011	//go:linkname libc_exchangedata libc_exchangedata
	1012	//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
703	1013
704	1014	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
705	1015
706	1016	func Exit(code int) {
707		Syscall(SYS_EXIT, uintptr(code), 0, 0)
708		return
709		}
	1017	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
	1018	return
	1019	}
	1020
	1021	func libc_exit_trampoline()
	1022
	1023	//go:linkname libc_exit libc_exit
	1024	//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
710	1025
711	1026	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
712	1027

716	1031	if err != nil {
717	1032	return
718	1033	}
719		_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
720		if e1 != 0 {
721		err = errnoErr(e1)
722		}
723		return
724		}
	1034	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1035	if e1 != 0 {
	1036	err = errnoErr(e1)
	1037	}
	1038	return
	1039	}
	1040
	1041	func libc_faccessat_trampoline()
	1042
	1043	//go:linkname libc_faccessat libc_faccessat
	1044	//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
725	1045
726	1046	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
727	1047
728	1048	func Fchdir(fd int) (err error) {
729		_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
730		if e1 != 0 {
731		err = errnoErr(e1)
732		}
733		return
734		}
	1049	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
	1050	if e1 != 0 {
	1051	err = errnoErr(e1)
	1052	}
	1053	return
	1054	}
	1055
	1056	func libc_fchdir_trampoline()
	1057
	1058	//go:linkname libc_fchdir libc_fchdir
	1059	//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
735	1060
736	1061	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
737	1062
738	1063	func Fchflags(fd int, flags int) (err error) {
739		_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
740		if e1 != 0 {
741		err = errnoErr(e1)
742		}
743		return
744		}
	1064	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
	1065	if e1 != 0 {
	1066	err = errnoErr(e1)
	1067	}
	1068	return
	1069	}
	1070
	1071	func libc_fchflags_trampoline()
	1072
	1073	//go:linkname libc_fchflags libc_fchflags
	1074	//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
745	1075
746	1076	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
747	1077
748	1078	func Fchmod(fd int, mode uint32) (err error) {
749		_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
750		if e1 != 0 {
751		err = errnoErr(e1)
752		}
753		return
754		}
	1079	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
	1080	if e1 != 0 {
	1081	err = errnoErr(e1)
	1082	}
	1083	return
	1084	}
	1085
	1086	func libc_fchmod_trampoline()
	1087
	1088	//go:linkname libc_fchmod libc_fchmod
	1089	//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
755	1090
756	1091	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
757	1092

761	1096	if err != nil {
762	1097	return
763	1098	}
764		_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
765		if e1 != 0 {
766		err = errnoErr(e1)
767		}
768		return
769		}
	1099	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1100	if e1 != 0 {
	1101	err = errnoErr(e1)
	1102	}
	1103	return
	1104	}
	1105
	1106	func libc_fchmodat_trampoline()
	1107
	1108	//go:linkname libc_fchmodat libc_fchmodat
	1109	//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
770	1110
771	1111	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
772	1112
773	1113	func Fchown(fd int, uid int, gid int) (err error) {
774		_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
775		if e1 != 0 {
776		err = errnoErr(e1)
777		}
778		return
779		}
	1114	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
	1115	if e1 != 0 {
	1116	err = errnoErr(e1)
	1117	}
	1118	return
	1119	}
	1120
	1121	func libc_fchown_trampoline()
	1122
	1123	//go:linkname libc_fchown libc_fchown
	1124	//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
780	1125
781	1126	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
782	1127

786	1131	if err != nil {
787	1132	return
788	1133	}
789		_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
790		if e1 != 0 {
791		err = errnoErr(e1)
792		}
793		return
794		}
	1134	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	1135	if e1 != 0 {
	1136	err = errnoErr(e1)
	1137	}
	1138	return
	1139	}
	1140
	1141	func libc_fchownat_trampoline()
	1142
	1143	//go:linkname libc_fchownat libc_fchownat
	1144	//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
795	1145
796	1146	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
797	1147
798	1148	func Flock(fd int, how int) (err error) {
799		_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
800		if e1 != 0 {
801		err = errnoErr(e1)
802		}
803		return
804		}
	1149	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
	1150	if e1 != 0 {
	1151	err = errnoErr(e1)
	1152	}
	1153	return
	1154	}
	1155
	1156	func libc_flock_trampoline()
	1157
	1158	//go:linkname libc_flock libc_flock
	1159	//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
805	1160
806	1161	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
807	1162
808	1163	func Fpathconf(fd int, name int) (val int, err error) {
809		r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	1164	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
810	1165	val = int(r0)
811	1166	if e1 != 0 {
812	1167	err = errnoErr(e1)

814	1169	return
815	1170	}
816	1171
	1172	func libc_fpathconf_trampoline()
	1173
	1174	//go:linkname libc_fpathconf libc_fpathconf
	1175	//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
	1176
	1177	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1178
	1179	func Fsync(fd int) (err error) {
	1180	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
	1181	if e1 != 0 {
	1182	err = errnoErr(e1)
	1183	}
	1184	return
	1185	}
	1186
	1187	func libc_fsync_trampoline()
	1188
	1189	//go:linkname libc_fsync libc_fsync
	1190	//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
	1191
	1192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1193
	1194	func Ftruncate(fd int, length int64) (err error) {
	1195	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
	1196	if e1 != 0 {
	1197	err = errnoErr(e1)
	1198	}
	1199	return
	1200	}
	1201
	1202	func libc_ftruncate_trampoline()
	1203
	1204	//go:linkname libc_ftruncate libc_ftruncate
	1205	//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
	1206
	1207	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1208
	1209	func Getdtablesize() (size int) {
	1210	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
	1211	size = int(r0)
	1212	return
	1213	}
	1214
	1215	func libc_getdtablesize_trampoline()
	1216
	1217	//go:linkname libc_getdtablesize libc_getdtablesize
	1218	//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
	1219
	1220	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1221
	1222	func Getegid() (egid int) {
	1223	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
	1224	egid = int(r0)
	1225	return
	1226	}
	1227
	1228	func libc_getegid_trampoline()
	1229
	1230	//go:linkname libc_getegid libc_getegid
	1231	//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
	1232
	1233	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1234
	1235	func Geteuid() (uid int) {
	1236	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
	1237	uid = int(r0)
	1238	return
	1239	}
	1240
	1241	func libc_geteuid_trampoline()
	1242
	1243	//go:linkname libc_geteuid libc_geteuid
	1244	//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
	1245
	1246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1247
	1248	func Getgid() (gid int) {
	1249	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
	1250	gid = int(r0)
	1251	return
	1252	}
	1253
	1254	func libc_getgid_trampoline()
	1255
	1256	//go:linkname libc_getgid libc_getgid
	1257	//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
	1258
	1259	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1260
	1261	func Getpgid(pid int) (pgid int, err error) {
	1262	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
	1263	pgid = int(r0)
	1264	if e1 != 0 {
	1265	err = errnoErr(e1)
	1266	}
	1267	return
	1268	}
	1269
	1270	func libc_getpgid_trampoline()
	1271
	1272	//go:linkname libc_getpgid libc_getpgid
	1273	//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
	1274
	1275	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1276
	1277	func Getpgrp() (pgrp int) {
	1278	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
	1279	pgrp = int(r0)
	1280	return
	1281	}
	1282
	1283	func libc_getpgrp_trampoline()
	1284
	1285	//go:linkname libc_getpgrp libc_getpgrp
	1286	//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
	1287
	1288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1289
	1290	func Getpid() (pid int) {
	1291	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
	1292	pid = int(r0)
	1293	return
	1294	}
	1295
	1296	func libc_getpid_trampoline()
	1297
	1298	//go:linkname libc_getpid libc_getpid
	1299	//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
	1300
	1301	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1302
	1303	func Getppid() (ppid int) {
	1304	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
	1305	ppid = int(r0)
	1306	return
	1307	}
	1308
	1309	func libc_getppid_trampoline()
	1310
	1311	//go:linkname libc_getppid libc_getppid
	1312	//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
	1313
	1314	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1315
	1316	func Getpriority(which int, who int) (prio int, err error) {
	1317	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
	1318	prio = int(r0)
	1319	if e1 != 0 {
	1320	err = errnoErr(e1)
	1321	}
	1322	return
	1323	}
	1324
	1325	func libc_getpriority_trampoline()
	1326
	1327	//go:linkname libc_getpriority libc_getpriority
	1328	//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
	1329
	1330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1331
	1332	func Getrlimit(which int, lim *Rlimit) (err error) {
	1333	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1334	if e1 != 0 {
	1335	err = errnoErr(e1)
	1336	}
	1337	return
	1338	}
	1339
	1340	func libc_getrlimit_trampoline()
	1341
	1342	//go:linkname libc_getrlimit libc_getrlimit
	1343	//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
	1344
	1345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1346
	1347	func Getrusage(who int, rusage *Rusage) (err error) {
	1348	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	1349	if e1 != 0 {
	1350	err = errnoErr(e1)
	1351	}
	1352	return
	1353	}
	1354
	1355	func libc_getrusage_trampoline()
	1356
	1357	//go:linkname libc_getrusage libc_getrusage
	1358	//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
	1359
	1360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1361
	1362	func Getsid(pid int) (sid int, err error) {
	1363	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
	1364	sid = int(r0)
	1365	if e1 != 0 {
	1366	err = errnoErr(e1)
	1367	}
	1368	return
	1369	}
	1370
	1371	func libc_getsid_trampoline()
	1372
	1373	//go:linkname libc_getsid libc_getsid
	1374	//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
	1375
	1376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1377
	1378	func Getuid() (uid int) {
	1379	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	1380	uid = int(r0)
	1381	return
	1382	}
	1383
	1384	func libc_getuid_trampoline()
	1385
	1386	//go:linkname libc_getuid libc_getuid
	1387	//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
	1388
	1389	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1390
	1391	func Issetugid() (tainted bool) {
	1392	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
	1393	tainted = bool(r0 != 0)
	1394	return
	1395	}
	1396
	1397	func libc_issetugid_trampoline()
	1398
	1399	//go:linkname libc_issetugid libc_issetugid
	1400	//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
	1401
	1402	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1403
	1404	func Kqueue() (fd int, err error) {
	1405	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
	1406	fd = int(r0)
	1407	if e1 != 0 {
	1408	err = errnoErr(e1)
	1409	}
	1410	return
	1411	}
	1412
	1413	func libc_kqueue_trampoline()
	1414
	1415	//go:linkname libc_kqueue libc_kqueue
	1416	//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
	1417
	1418	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1419
	1420	func Lchown(path string, uid int, gid int) (err error) {
	1421	var _p0 *byte
	1422	_p0, err = BytePtrFromString(path)
	1423	if err != nil {
	1424	return
	1425	}
	1426	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1427	if e1 != 0 {
	1428	err = errnoErr(e1)
	1429	}
	1430	return
	1431	}
	1432
	1433	func libc_lchown_trampoline()
	1434
	1435	//go:linkname libc_lchown libc_lchown
	1436	//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
	1437
	1438	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1439
	1440	func Link(path string, link string) (err error) {
	1441	var _p0 *byte
	1442	_p0, err = BytePtrFromString(path)
	1443	if err != nil {
	1444	return
	1445	}
	1446	var _p1 *byte
	1447	_p1, err = BytePtrFromString(link)
	1448	if err != nil {
	1449	return
	1450	}
	1451	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1452	if e1 != 0 {
	1453	err = errnoErr(e1)
	1454	}
	1455	return
	1456	}
	1457
	1458	func libc_link_trampoline()
	1459
	1460	//go:linkname libc_link libc_link
	1461	//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
	1462
	1463	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1464
	1465	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1466	var _p0 *byte
	1467	_p0, err = BytePtrFromString(path)
	1468	if err != nil {
	1469	return
	1470	}
	1471	var _p1 *byte
	1472	_p1, err = BytePtrFromString(link)
	1473	if err != nil {
	1474	return
	1475	}
	1476	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1477	if e1 != 0 {
	1478	err = errnoErr(e1)
	1479	}
	1480	return
	1481	}
	1482
	1483	func libc_linkat_trampoline()
	1484
	1485	//go:linkname libc_linkat libc_linkat
	1486	//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Listen(s int, backlog int) (err error) {
	1491	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	func libc_listen_trampoline()
	1499
	1500	//go:linkname libc_listen libc_listen
	1501	//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
	1502
	1503	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1504
	1505	func Mkdir(path string, mode uint32) (err error) {
	1506	var _p0 *byte
	1507	_p0, err = BytePtrFromString(path)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	func libc_mkdir_trampoline()
	1519
	1520	//go:linkname libc_mkdir libc_mkdir
	1521	//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
	1522
	1523	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1524
	1525	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1526	var _p0 *byte
	1527	_p0, err = BytePtrFromString(path)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	func libc_mkdirat_trampoline()
	1539
	1540	//go:linkname libc_mkdirat libc_mkdirat
	1541	//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
	1542
	1543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1544
	1545	func Mkfifo(path string, mode uint32) (err error) {
	1546	var _p0 *byte
	1547	_p0, err = BytePtrFromString(path)
	1548	if err != nil {
	1549	return
	1550	}
	1551	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1552	if e1 != 0 {
	1553	err = errnoErr(e1)
	1554	}
	1555	return
	1556	}
	1557
	1558	func libc_mkfifo_trampoline()
	1559
	1560	//go:linkname libc_mkfifo libc_mkfifo
	1561	//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Mknod(path string, mode uint32, dev int) (err error) {
	1566	var _p0 *byte
	1567	_p0, err = BytePtrFromString(path)
	1568	if err != nil {
	1569	return
	1570	}
	1571	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1572	if e1 != 0 {
	1573	err = errnoErr(e1)
	1574	}
	1575	return
	1576	}
	1577
	1578	func libc_mknod_trampoline()
	1579
	1580	//go:linkname libc_mknod libc_mknod
	1581	//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
	1582
	1583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1584
	1585	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1586	var _p0 *byte
	1587	_p0, err = BytePtrFromString(path)
	1588	if err != nil {
	1589	return
	1590	}
	1591	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1592	fd = int(r0)
	1593	if e1 != 0 {
	1594	err = errnoErr(e1)
	1595	}
	1596	return
	1597	}
	1598
	1599	func libc_open_trampoline()
	1600
	1601	//go:linkname libc_open libc_open
	1602	//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
	1603
	1604	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1605
	1606	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1607	var _p0 *byte
	1608	_p0, err = BytePtrFromString(path)
	1609	if err != nil {
	1610	return
	1611	}
	1612	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1613	fd = int(r0)
	1614	if e1 != 0 {
	1615	err = errnoErr(e1)
	1616	}
	1617	return
	1618	}
	1619
	1620	func libc_openat_trampoline()
	1621
	1622	//go:linkname libc_openat libc_openat
	1623	//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
	1624
	1625	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1626
	1627	func Pathconf(path string, name int) (val int, err error) {
	1628	var _p0 *byte
	1629	_p0, err = BytePtrFromString(path)
	1630	if err != nil {
	1631	return
	1632	}
	1633	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1634	val = int(r0)
	1635	if e1 != 0 {
	1636	err = errnoErr(e1)
	1637	}
	1638	return
	1639	}
	1640
	1641	func libc_pathconf_trampoline()
	1642
	1643	//go:linkname libc_pathconf libc_pathconf
	1644	//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
	1645
	1646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1647
	1648	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1649	var _p0 unsafe.Pointer
	1650	if len(p) > 0 {
	1651	_p0 = unsafe.Pointer(&p[0])
	1652	} else {
	1653	_p0 = unsafe.Pointer(&_zero)
	1654	}
	1655	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1656	n = int(r0)
	1657	if e1 != 0 {
	1658	err = errnoErr(e1)
	1659	}
	1660	return
	1661	}
	1662
	1663	func libc_pread_trampoline()
	1664
	1665	//go:linkname libc_pread libc_pread
	1666	//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
	1667
	1668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1669
	1670	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1671	var _p0 unsafe.Pointer
	1672	if len(p) > 0 {
	1673	_p0 = unsafe.Pointer(&p[0])
	1674	} else {
	1675	_p0 = unsafe.Pointer(&_zero)
	1676	}
	1677	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1678	n = int(r0)
	1679	if e1 != 0 {
	1680	err = errnoErr(e1)
	1681	}
	1682	return
	1683	}
	1684
	1685	func libc_pwrite_trampoline()
	1686
	1687	//go:linkname libc_pwrite libc_pwrite
	1688	//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
	1689
	1690	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1691
	1692	func read(fd int, p []byte) (n int, err error) {
	1693	var _p0 unsafe.Pointer
	1694	if len(p) > 0 {
	1695	_p0 = unsafe.Pointer(&p[0])
	1696	} else {
	1697	_p0 = unsafe.Pointer(&_zero)
	1698	}
	1699	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1700	n = int(r0)
	1701	if e1 != 0 {
	1702	err = errnoErr(e1)
	1703	}
	1704	return
	1705	}
	1706
	1707	func libc_read_trampoline()
	1708
	1709	//go:linkname libc_read libc_read
	1710	//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
	1711
	1712	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1713
	1714	func Readlink(path string, buf []byte) (n int, err error) {
	1715	var _p0 *byte
	1716	_p0, err = BytePtrFromString(path)
	1717	if err != nil {
	1718	return
	1719	}
	1720	var _p1 unsafe.Pointer
	1721	if len(buf) > 0 {
	1722	_p1 = unsafe.Pointer(&buf[0])
	1723	} else {
	1724	_p1 = unsafe.Pointer(&_zero)
	1725	}
	1726	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1727	n = int(r0)
	1728	if e1 != 0 {
	1729	err = errnoErr(e1)
	1730	}
	1731	return
	1732	}
	1733
	1734	func libc_readlink_trampoline()
	1735
	1736	//go:linkname libc_readlink libc_readlink
	1737	//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
	1738
	1739	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1740
	1741	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1742	var _p0 *byte
	1743	_p0, err = BytePtrFromString(path)
	1744	if err != nil {
	1745	return
	1746	}
	1747	var _p1 unsafe.Pointer
	1748	if len(buf) > 0 {
	1749	_p1 = unsafe.Pointer(&buf[0])
	1750	} else {
	1751	_p1 = unsafe.Pointer(&_zero)
	1752	}
	1753	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1754	n = int(r0)
	1755	if e1 != 0 {
	1756	err = errnoErr(e1)
	1757	}
	1758	return
	1759	}
	1760
	1761	func libc_readlinkat_trampoline()
	1762
	1763	//go:linkname libc_readlinkat libc_readlinkat
	1764	//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
	1765
	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1767
	1768	func Rename(from string, to string) (err error) {
	1769	var _p0 *byte
	1770	_p0, err = BytePtrFromString(from)
	1771	if err != nil {
	1772	return
	1773	}
	1774	var _p1 *byte
	1775	_p1, err = BytePtrFromString(to)
	1776	if err != nil {
	1777	return
	1778	}
	1779	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1780	if e1 != 0 {
	1781	err = errnoErr(e1)
	1782	}
	1783	return
	1784	}
	1785
	1786	func libc_rename_trampoline()
	1787
	1788	//go:linkname libc_rename libc_rename
	1789	//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
	1790
	1791	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1792
	1793	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1794	var _p0 *byte
	1795	_p0, err = BytePtrFromString(from)
	1796	if err != nil {
	1797	return
	1798	}
	1799	var _p1 *byte
	1800	_p1, err = BytePtrFromString(to)
	1801	if err != nil {
	1802	return
	1803	}
	1804	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}
	1810
	1811	func libc_renameat_trampoline()
	1812
	1813	//go:linkname libc_renameat libc_renameat
	1814	//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
	1815
	1816	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1817
	1818	func Revoke(path string) (err error) {
	1819	var _p0 *byte
	1820	_p0, err = BytePtrFromString(path)
	1821	if err != nil {
	1822	return
	1823	}
	1824	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1825	if e1 != 0 {
	1826	err = errnoErr(e1)
	1827	}
	1828	return
	1829	}
	1830
	1831	func libc_revoke_trampoline()
	1832
	1833	//go:linkname libc_revoke libc_revoke
	1834	//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
	1835
	1836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1837
	1838	func Rmdir(path string) (err error) {
	1839	var _p0 *byte
	1840	_p0, err = BytePtrFromString(path)
	1841	if err != nil {
	1842	return
	1843	}
	1844	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1845	if e1 != 0 {
	1846	err = errnoErr(e1)
	1847	}
	1848	return
	1849	}
	1850
	1851	func libc_rmdir_trampoline()
	1852
	1853	//go:linkname libc_rmdir libc_rmdir
	1854	//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
	1855
	1856	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1857
	1858	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1859	r0, r1, e1 := syscall_syscall6(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
	1860	newoffset = int64(int64(r1)<<32 \| int64(r0))
	1861	if e1 != 0 {
	1862	err = errnoErr(e1)
	1863	}
	1864	return
	1865	}
	1866
	1867	func libc_lseek_trampoline()
	1868
	1869	//go:linkname libc_lseek libc_lseek
	1870	//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
	1871
	1872	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1873
	1874	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1875	_, _, 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)
	1876	if e1 != 0 {
	1877	err = errnoErr(e1)
	1878	}
	1879	return
	1880	}
	1881
	1882	func libc_select_trampoline()
	1883
	1884	//go:linkname libc_select libc_select
	1885	//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
	1886
	1887	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1888
	1889	func Setegid(egid int) (err error) {
	1890	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
	1891	if e1 != 0 {
	1892	err = errnoErr(e1)
	1893	}
	1894	return
	1895	}
	1896
	1897	func libc_setegid_trampoline()
	1898
	1899	//go:linkname libc_setegid libc_setegid
	1900	//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
	1901
	1902	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1903
	1904	func Seteuid(euid int) (err error) {
	1905	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
	1906	if e1 != 0 {
	1907	err = errnoErr(e1)
	1908	}
	1909	return
	1910	}
	1911
	1912	func libc_seteuid_trampoline()
	1913
	1914	//go:linkname libc_seteuid libc_seteuid
	1915	//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
	1916
	1917	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1918
	1919	func Setgid(gid int) (err error) {
	1920	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
	1921	if e1 != 0 {
	1922	err = errnoErr(e1)
	1923	}
	1924	return
	1925	}
	1926
	1927	func libc_setgid_trampoline()
	1928
	1929	//go:linkname libc_setgid libc_setgid
	1930	//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
	1931
	1932	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1933
	1934	func Setlogin(name string) (err error) {
	1935	var _p0 *byte
	1936	_p0, err = BytePtrFromString(name)
	1937	if err != nil {
	1938	return
	1939	}
	1940	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1941	if e1 != 0 {
	1942	err = errnoErr(e1)
	1943	}
	1944	return
	1945	}
	1946
	1947	func libc_setlogin_trampoline()
	1948
	1949	//go:linkname libc_setlogin libc_setlogin
	1950	//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
	1951
	1952	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1953
	1954	func Setpgid(pid int, pgid int) (err error) {
	1955	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
	1956	if e1 != 0 {
	1957	err = errnoErr(e1)
	1958	}
	1959	return
	1960	}
	1961
	1962	func libc_setpgid_trampoline()
	1963
	1964	//go:linkname libc_setpgid libc_setpgid
	1965	//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
	1966
	1967	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1968
	1969	func Setpriority(which int, who int, prio int) (err error) {
	1970	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
	1971	if e1 != 0 {
	1972	err = errnoErr(e1)
	1973	}
	1974	return
	1975	}
	1976
	1977	func libc_setpriority_trampoline()
	1978
	1979	//go:linkname libc_setpriority libc_setpriority
	1980	//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
	1981
	1982	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1983
	1984	func Setprivexec(flag int) (err error) {
	1985	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
	1986	if e1 != 0 {
	1987	err = errnoErr(e1)
	1988	}
	1989	return
	1990	}
	1991
	1992	func libc_setprivexec_trampoline()
	1993
	1994	//go:linkname libc_setprivexec libc_setprivexec
	1995	//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
	1996
	1997	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1998
	1999	func Setregid(rgid int, egid int) (err error) {
	2000	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
	2001	if e1 != 0 {
	2002	err = errnoErr(e1)
	2003	}
	2004	return
	2005	}
	2006
	2007	func libc_setregid_trampoline()
	2008
	2009	//go:linkname libc_setregid libc_setregid
	2010	//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
	2011
	2012	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2013
	2014	func Setreuid(ruid int, euid int) (err error) {
	2015	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
	2016	if e1 != 0 {
	2017	err = errnoErr(e1)
	2018	}
	2019	return
	2020	}
	2021
	2022	func libc_setreuid_trampoline()
	2023
	2024	//go:linkname libc_setreuid libc_setreuid
	2025	//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
	2026
	2027	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2028
	2029	func Setrlimit(which int, lim *Rlimit) (err error) {
	2030	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	2031	if e1 != 0 {
	2032	err = errnoErr(e1)
	2033	}
	2034	return
	2035	}
	2036
	2037	func libc_setrlimit_trampoline()
	2038
	2039	//go:linkname libc_setrlimit libc_setrlimit
	2040	//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
	2041
	2042	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2043
	2044	func Setsid() (pid int, err error) {
	2045	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
	2046	pid = int(r0)
	2047	if e1 != 0 {
	2048	err = errnoErr(e1)
	2049	}
	2050	return
	2051	}
	2052
	2053	func libc_setsid_trampoline()
	2054
	2055	//go:linkname libc_setsid libc_setsid
	2056	//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
	2057
	2058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2059
	2060	func Settimeofday(tp *Timeval) (err error) {
	2061	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2062	if e1 != 0 {
	2063	err = errnoErr(e1)
	2064	}
	2065	return
	2066	}
	2067
	2068	func libc_settimeofday_trampoline()
	2069
	2070	//go:linkname libc_settimeofday libc_settimeofday
	2071	//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
	2072
	2073	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2074
	2075	func Setuid(uid int) (err error) {
	2076	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
	2077	if e1 != 0 {
	2078	err = errnoErr(e1)
	2079	}
	2080	return
	2081	}
	2082
	2083	func libc_setuid_trampoline()
	2084
	2085	//go:linkname libc_setuid libc_setuid
	2086	//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
	2087
	2088	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2089
	2090	func Symlink(path string, link string) (err error) {
	2091	var _p0 *byte
	2092	_p0, err = BytePtrFromString(path)
	2093	if err != nil {
	2094	return
	2095	}
	2096	var _p1 *byte
	2097	_p1, err = BytePtrFromString(link)
	2098	if err != nil {
	2099	return
	2100	}
	2101	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	2102	if e1 != 0 {
	2103	err = errnoErr(e1)
	2104	}
	2105	return
	2106	}
	2107
	2108	func libc_symlink_trampoline()
	2109
	2110	//go:linkname libc_symlink libc_symlink
	2111	//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
	2112
	2113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2114
	2115	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	2116	var _p0 *byte
	2117	_p0, err = BytePtrFromString(oldpath)
	2118	if err != nil {
	2119	return
	2120	}
	2121	var _p1 *byte
	2122	_p1, err = BytePtrFromString(newpath)
	2123	if err != nil {
	2124	return
	2125	}
	2126	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	2127	if e1 != 0 {
	2128	err = errnoErr(e1)
	2129	}
	2130	return
	2131	}
	2132
	2133	func libc_symlinkat_trampoline()
	2134
	2135	//go:linkname libc_symlinkat libc_symlinkat
	2136	//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
	2137
	2138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2139
	2140	func Sync() (err error) {
	2141	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
	2142	if e1 != 0 {
	2143	err = errnoErr(e1)
	2144	}
	2145	return
	2146	}
	2147
	2148	func libc_sync_trampoline()
	2149
	2150	//go:linkname libc_sync libc_sync
	2151	//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
	2152
	2153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2154
	2155	func Truncate(path string, length int64) (err error) {
	2156	var _p0 *byte
	2157	_p0, err = BytePtrFromString(path)
	2158	if err != nil {
	2159	return
	2160	}
	2161	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
	2162	if e1 != 0 {
	2163	err = errnoErr(e1)
	2164	}
	2165	return
	2166	}
	2167
	2168	func libc_truncate_trampoline()
	2169
	2170	//go:linkname libc_truncate libc_truncate
	2171	//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
	2172
	2173	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2174
	2175	func Umask(newmask int) (oldmask int) {
	2176	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
	2177	oldmask = int(r0)
	2178	return
	2179	}
	2180
	2181	func libc_umask_trampoline()
	2182
	2183	//go:linkname libc_umask libc_umask
	2184	//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
	2185
	2186	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2187
	2188	func Undelete(path string) (err error) {
	2189	var _p0 *byte
	2190	_p0, err = BytePtrFromString(path)
	2191	if err != nil {
	2192	return
	2193	}
	2194	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2195	if e1 != 0 {
	2196	err = errnoErr(e1)
	2197	}
	2198	return
	2199	}
	2200
	2201	func libc_undelete_trampoline()
	2202
	2203	//go:linkname libc_undelete libc_undelete
	2204	//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
	2205
	2206	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2207
	2208	func Unlink(path string) (err error) {
	2209	var _p0 *byte
	2210	_p0, err = BytePtrFromString(path)
	2211	if err != nil {
	2212	return
	2213	}
	2214	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2215	if e1 != 0 {
	2216	err = errnoErr(e1)
	2217	}
	2218	return
	2219	}
	2220
	2221	func libc_unlink_trampoline()
	2222
	2223	//go:linkname libc_unlink libc_unlink
	2224	//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
	2225
	2226	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2227
	2228	func Unlinkat(dirfd int, path string, flags int) (err error) {
	2229	var _p0 *byte
	2230	_p0, err = BytePtrFromString(path)
	2231	if err != nil {
	2232	return
	2233	}
	2234	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	2235	if e1 != 0 {
	2236	err = errnoErr(e1)
	2237	}
	2238	return
	2239	}
	2240
	2241	func libc_unlinkat_trampoline()
	2242
	2243	//go:linkname libc_unlinkat libc_unlinkat
	2244	//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
	2245
	2246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2247
	2248	func Unmount(path string, flags int) (err error) {
	2249	var _p0 *byte
	2250	_p0, err = BytePtrFromString(path)
	2251	if err != nil {
	2252	return
	2253	}
	2254	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	2255	if e1 != 0 {
	2256	err = errnoErr(e1)
	2257	}
	2258	return
	2259	}
	2260
	2261	func libc_unmount_trampoline()
	2262
	2263	//go:linkname libc_unmount libc_unmount
	2264	//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
	2265
	2266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2267
	2268	func write(fd int, p []byte) (n int, err error) {
	2269	var _p0 unsafe.Pointer
	2270	if len(p) > 0 {
	2271	_p0 = unsafe.Pointer(&p[0])
	2272	} else {
	2273	_p0 = unsafe.Pointer(&_zero)
	2274	}
	2275	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
	2276	n = int(r0)
	2277	if e1 != 0 {
	2278	err = errnoErr(e1)
	2279	}
	2280	return
	2281	}
	2282
	2283	func libc_write_trampoline()
	2284
	2285	//go:linkname libc_write libc_write
	2286	//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
	2287
	2288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2289
	2290	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	2291	r0, _, e1 := syscall_syscall9(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
	2292	ret = uintptr(r0)
	2293	if e1 != 0 {
	2294	err = errnoErr(e1)
	2295	}
	2296	return
	2297	}
	2298
	2299	func libc_mmap_trampoline()
	2300
	2301	//go:linkname libc_mmap libc_mmap
	2302	//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
	2303
	2304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2305
	2306	func munmap(addr uintptr, length uintptr) (err error) {
	2307	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
	2308	if e1 != 0 {
	2309	err = errnoErr(e1)
	2310	}
	2311	return
	2312	}
	2313
	2314	func libc_munmap_trampoline()
	2315
	2316	//go:linkname libc_munmap libc_munmap
	2317	//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
	2318
	2319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2320
	2321	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	2322	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2323	n = int(r0)
	2324	if e1 != 0 {
	2325	err = errnoErr(e1)
	2326	}
	2327	return
	2328	}
	2329
	2330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2331
	2332	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	2333	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2334	n = int(r0)
	2335	if e1 != 0 {
	2336	err = errnoErr(e1)
	2337	}
	2338	return
	2339	}
	2340
	2341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2342
	2343	func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	2344	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2345	sec = int32(r0)
	2346	usec = int32(r1)
	2347	if e1 != 0 {
	2348	err = errnoErr(e1)
	2349	}
	2350	return
	2351	}
	2352
	2353	func libc_gettimeofday_trampoline()
	2354
	2355	//go:linkname libc_gettimeofday libc_gettimeofday
	2356	//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
	2357
817	2358	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
818	2359
819	2360	func Fstat(fd int, stat *Stat_t) (err error) {
820		_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
821		if e1 != 0 {
822		err = errnoErr(e1)
823		}
824		return
825		}
	2361	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2362	if e1 != 0 {
	2363	err = errnoErr(e1)
	2364	}
	2365	return
	2366	}
	2367
	2368	func libc_fstat64_trampoline()
	2369
	2370	//go:linkname libc_fstat64 libc_fstat64
	2371	//go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
826	2372
827	2373	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
828	2374

832	2378	if err != nil {
833	2379	return
834	2380	}
835		_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
836		if e1 != 0 {
837		err = errnoErr(e1)
838		}
839		return
840		}
	2381	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	2382	if e1 != 0 {
	2383	err = errnoErr(e1)
	2384	}
	2385	return
	2386	}
	2387
	2388	func libc_fstatat64_trampoline()
	2389
	2390	//go:linkname libc_fstatat64 libc_fstatat64
	2391	//go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
841	2392
842	2393	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
843	2394
844	2395	func Fstatfs(fd int, stat *Statfs_t) (err error) {
845		_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
846		if e1 != 0 {
847		err = errnoErr(e1)
848		}
849		return
850		}
851
852		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
853
854		func Fsync(fd int) (err error) {
855		_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
856		if e1 != 0 {
857		err = errnoErr(e1)
858		}
859		return
860		}
861
862		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
863
864		func Ftruncate(fd int, length int64) (err error) {
865		_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), uintptr(length>>32))
866		if e1 != 0 {
867		err = errnoErr(e1)
868		}
869		return
870		}
	2396	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2397	if e1 != 0 {
	2398	err = errnoErr(e1)
	2399	}
	2400	return
	2401	}
	2402
	2403	func libc_fstatfs64_trampoline()
	2404
	2405	//go:linkname libc_fstatfs64 libc_fstatfs64
	2406	//go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
871	2407
872	2408	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
873	2409

878	2414	} else {
879	2415	_p0 = unsafe.Pointer(&_zero)
880	2416	}
881		r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
	2417	r0, _, e1 := syscall_syscall6(funcPC(libc___getdirentries64_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
882	2418	n = int(r0)
883	2419	if e1 != 0 {
884	2420	err = errnoErr(e1)

886	2422	return
887	2423	}
888	2424
889		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
890
891		func Getdtablesize() (size int) {
892		r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
893		size = int(r0)
894		return
895		}
896
897		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
898
899		func Getegid() (egid int) {
900		r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
901		egid = int(r0)
902		return
903		}
904
905		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
906
907		func Geteuid() (uid int) {
908		r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
909		uid = int(r0)
910		return
911		}
912
913		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
914
915		func Getgid() (gid int) {
916		r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
917		gid = int(r0)
918		return
919		}
920
921		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
922
923		func Getpgid(pid int) (pgid int, err error) {
924		r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
925		pgid = int(r0)
926		if e1 != 0 {
927		err = errnoErr(e1)
928		}
929		return
930		}
931
932		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
933
934		func Getpgrp() (pgrp int) {
935		r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
936		pgrp = int(r0)
937		return
938		}
939
940		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
941
942		func Getpid() (pid int) {
943		r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
944		pid = int(r0)
945		return
946		}
947
948		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
949
950		func Getppid() (ppid int) {
951		r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
952		ppid = int(r0)
953		return
954		}
955
956		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
957
958		func Getpriority(which int, who int) (prio int, err error) {
959		r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
960		prio = int(r0)
961		if e1 != 0 {
962		err = errnoErr(e1)
963		}
964		return
965		}
966
967		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
968
969		func Getrlimit(which int, lim *Rlimit) (err error) {
970		_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
971		if e1 != 0 {
972		err = errnoErr(e1)
973		}
974		return
975		}
976
977		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
978
979		func Getrusage(who int, rusage *Rusage) (err error) {
980		_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
981		if e1 != 0 {
982		err = errnoErr(e1)
983		}
984		return
985		}
986
987		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
988
989		func Getsid(pid int) (sid int, err error) {
990		r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
991		sid = int(r0)
992		if e1 != 0 {
993		err = errnoErr(e1)
994		}
995		return
996		}
997
998		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
999
1000		func Getuid() (uid int) {
1001		r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
1002		uid = int(r0)
1003		return
1004		}
1005
1006		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1007
1008		func Issetugid() (tainted bool) {
1009		r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
1010		tainted = bool(r0 != 0)
1011		return
1012		}
1013
1014		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1015
1016		func Kqueue() (fd int, err error) {
1017		r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
1018		fd = int(r0)
1019		if e1 != 0 {
1020		err = errnoErr(e1)
1021		}
1022		return
1023		}
1024
1025		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1026
1027		func Lchown(path string, uid int, gid int) (err error) {
1028		var _p0 *byte
1029		_p0, err = BytePtrFromString(path)
1030		if err != nil {
1031		return
1032		}
1033		_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1034		if e1 != 0 {
1035		err = errnoErr(e1)
1036		}
1037		return
1038		}
1039
1040		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1041
1042		func Link(path string, link string) (err error) {
1043		var _p0 *byte
1044		_p0, err = BytePtrFromString(path)
1045		if err != nil {
1046		return
1047		}
1048		var _p1 *byte
1049		_p1, err = BytePtrFromString(link)
1050		if err != nil {
1051		return
1052		}
1053		_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1054		if e1 != 0 {
1055		err = errnoErr(e1)
1056		}
1057		return
1058		}
1059
1060		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1061
1062		func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
1063		var _p0 *byte
1064		_p0, err = BytePtrFromString(path)
1065		if err != nil {
1066		return
1067		}
1068		var _p1 *byte
1069		_p1, err = BytePtrFromString(link)
1070		if err != nil {
1071		return
1072		}
1073		_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1074		if e1 != 0 {
1075		err = errnoErr(e1)
1076		}
1077		return
1078		}
1079
1080		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1081
1082		func Listen(s int, backlog int) (err error) {
1083		_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
1084		if e1 != 0 {
1085		err = errnoErr(e1)
1086		}
1087		return
1088		}
	2425	func libc___getdirentries64_trampoline()
	2426
	2427	//go:linkname libc___getdirentries64 libc___getdirentries64
	2428	//go:cgo_import_dynamic libc___getdirentries64 __getdirentries64 "/usr/lib/libSystem.B.dylib"
	2429
	2430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2431
	2432	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	2433	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
	2434	n = int(r0)
	2435	if e1 != 0 {
	2436	err = errnoErr(e1)
	2437	}
	2438	return
	2439	}
	2440
	2441	func libc_getfsstat64_trampoline()
	2442
	2443	//go:linkname libc_getfsstat64 libc_getfsstat64
	2444	//go:cgo_import_dynamic libc_getfsstat64 getfsstat64 "/usr/lib/libSystem.B.dylib"
1089	2445
1090	2446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1091	2447

1095	2451	if err != nil {
1096	2452	return
1097	2453	}
1098		_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1099		if e1 != 0 {
1100		err = errnoErr(e1)
1101		}
1102		return
1103		}
1104
1105		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1106
1107		func Mkdir(path string, mode uint32) (err error) {
1108		var _p0 *byte
1109		_p0, err = BytePtrFromString(path)
1110		if err != nil {
1111		return
1112		}
1113		_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1114		if e1 != 0 {
1115		err = errnoErr(e1)
1116		}
1117		return
1118		}
1119
1120		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1121
1122		func Mkdirat(dirfd int, path string, mode uint32) (err error) {
1123		var _p0 *byte
1124		_p0, err = BytePtrFromString(path)
1125		if err != nil {
1126		return
1127		}
1128		_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1129		if e1 != 0 {
1130		err = errnoErr(e1)
1131		}
1132		return
1133		}
1134
1135		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1136
1137		func Mkfifo(path string, mode uint32) (err error) {
1138		var _p0 *byte
1139		_p0, err = BytePtrFromString(path)
1140		if err != nil {
1141		return
1142		}
1143		_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1144		if e1 != 0 {
1145		err = errnoErr(e1)
1146		}
1147		return
1148		}
1149
1150		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1151
1152		func Mknod(path string, mode uint32, dev int) (err error) {
1153		var _p0 *byte
1154		_p0, err = BytePtrFromString(path)
1155		if err != nil {
1156		return
1157		}
1158		_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1159		if e1 != 0 {
1160		err = errnoErr(e1)
1161		}
1162		return
1163		}
1164
1165		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1166
1167		func Open(path string, mode int, perm uint32) (fd int, err error) {
1168		var _p0 *byte
1169		_p0, err = BytePtrFromString(path)
1170		if err != nil {
1171		return
1172		}
1173		r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1174		fd = int(r0)
1175		if e1 != 0 {
1176		err = errnoErr(e1)
1177		}
1178		return
1179		}
1180
1181		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1182
1183		func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
1184		var _p0 *byte
1185		_p0, err = BytePtrFromString(path)
1186		if err != nil {
1187		return
1188		}
1189		r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1190		fd = int(r0)
1191		if e1 != 0 {
1192		err = errnoErr(e1)
1193		}
1194		return
1195		}
1196
1197		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1198
1199		func Pathconf(path string, name int) (val int, err error) {
1200		var _p0 *byte
1201		_p0, err = BytePtrFromString(path)
1202		if err != nil {
1203		return
1204		}
1205		r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1206		val = int(r0)
1207		if e1 != 0 {
1208		err = errnoErr(e1)
1209		}
1210		return
1211		}
1212
1213		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1214
1215		func Pread(fd int, p []byte, offset int64) (n int, err error) {
1216		var _p0 unsafe.Pointer
1217		if len(p) > 0 {
1218		_p0 = unsafe.Pointer(&p[0])
1219		} else {
1220		_p0 = unsafe.Pointer(&_zero)
1221		}
1222		r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1223		n = int(r0)
1224		if e1 != 0 {
1225		err = errnoErr(e1)
1226		}
1227		return
1228		}
1229
1230		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1231
1232		func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
1233		var _p0 unsafe.Pointer
1234		if len(p) > 0 {
1235		_p0 = unsafe.Pointer(&p[0])
1236		} else {
1237		_p0 = unsafe.Pointer(&_zero)
1238		}
1239		r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1240		n = int(r0)
1241		if e1 != 0 {
1242		err = errnoErr(e1)
1243		}
1244		return
1245		}
1246
1247		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1248
1249		func read(fd int, p []byte) (n int, err error) {
1250		var _p0 unsafe.Pointer
1251		if len(p) > 0 {
1252		_p0 = unsafe.Pointer(&p[0])
1253		} else {
1254		_p0 = unsafe.Pointer(&_zero)
1255		}
1256		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
1257		n = int(r0)
1258		if e1 != 0 {
1259		err = errnoErr(e1)
1260		}
1261		return
1262		}
1263
1264		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1265
1266		func Readlink(path string, buf []byte) (n int, err error) {
1267		var _p0 *byte
1268		_p0, err = BytePtrFromString(path)
1269		if err != nil {
1270		return
1271		}
1272		var _p1 unsafe.Pointer
1273		if len(buf) > 0 {
1274		_p1 = unsafe.Pointer(&buf[0])
1275		} else {
1276		_p1 = unsafe.Pointer(&_zero)
1277		}
1278		r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1279		n = int(r0)
1280		if e1 != 0 {
1281		err = errnoErr(e1)
1282		}
1283		return
1284		}
1285
1286		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1287
1288		func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
1289		var _p0 *byte
1290		_p0, err = BytePtrFromString(path)
1291		if err != nil {
1292		return
1293		}
1294		var _p1 unsafe.Pointer
1295		if len(buf) > 0 {
1296		_p1 = unsafe.Pointer(&buf[0])
1297		} else {
1298		_p1 = unsafe.Pointer(&_zero)
1299		}
1300		r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1301		n = int(r0)
1302		if e1 != 0 {
1303		err = errnoErr(e1)
1304		}
1305		return
1306		}
1307
1308		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1309
1310		func Rename(from string, to string) (err error) {
1311		var _p0 *byte
1312		_p0, err = BytePtrFromString(from)
1313		if err != nil {
1314		return
1315		}
1316		var _p1 *byte
1317		_p1, err = BytePtrFromString(to)
1318		if err != nil {
1319		return
1320		}
1321		_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1322		if e1 != 0 {
1323		err = errnoErr(e1)
1324		}
1325		return
1326		}
1327
1328		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1329
1330		func Renameat(fromfd int, from string, tofd int, to string) (err error) {
1331		var _p0 *byte
1332		_p0, err = BytePtrFromString(from)
1333		if err != nil {
1334		return
1335		}
1336		var _p1 *byte
1337		_p1, err = BytePtrFromString(to)
1338		if err != nil {
1339		return
1340		}
1341		_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1342		if e1 != 0 {
1343		err = errnoErr(e1)
1344		}
1345		return
1346		}
1347
1348		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1349
1350		func Revoke(path string) (err error) {
1351		var _p0 *byte
1352		_p0, err = BytePtrFromString(path)
1353		if err != nil {
1354		return
1355		}
1356		_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1357		if e1 != 0 {
1358		err = errnoErr(e1)
1359		}
1360		return
1361		}
1362
1363		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1364
1365		func Rmdir(path string) (err error) {
1366		var _p0 *byte
1367		_p0, err = BytePtrFromString(path)
1368		if err != nil {
1369		return
1370		}
1371		_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
1372		if e1 != 0 {
1373		err = errnoErr(e1)
1374		}
1375		return
1376		}
1377
1378		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1379
1380		func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1381		r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
1382		newoffset = int64(int64(r1)<<32 \| int64(r0))
1383		if e1 != 0 {
1384		err = errnoErr(e1)
1385		}
1386		return
1387		}
1388
1389		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1390
1391		func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
1392		_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1393		if e1 != 0 {
1394		err = errnoErr(e1)
1395		}
1396		return
1397		}
1398
1399		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1400
1401		func Setegid(egid int) (err error) {
1402		_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
1403		if e1 != 0 {
1404		err = errnoErr(e1)
1405		}
1406		return
1407		}
1408
1409		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1410
1411		func Seteuid(euid int) (err error) {
1412		_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
1413		if e1 != 0 {
1414		err = errnoErr(e1)
1415		}
1416		return
1417		}
1418
1419		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1420
1421		func Setgid(gid int) (err error) {
1422		_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
1423		if e1 != 0 {
1424		err = errnoErr(e1)
1425		}
1426		return
1427		}
1428
1429		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1430
1431		func Setlogin(name string) (err error) {
1432		var _p0 *byte
1433		_p0, err = BytePtrFromString(name)
1434		if err != nil {
1435		return
1436		}
1437		_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
1438		if e1 != 0 {
1439		err = errnoErr(e1)
1440		}
1441		return
1442		}
1443
1444		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1445
1446		func Setpgid(pid int, pgid int) (err error) {
1447		_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
1448		if e1 != 0 {
1449		err = errnoErr(e1)
1450		}
1451		return
1452		}
1453
1454		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1455
1456		func Setpriority(which int, who int, prio int) (err error) {
1457		_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
1458		if e1 != 0 {
1459		err = errnoErr(e1)
1460		}
1461		return
1462		}
1463
1464		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1465
1466		func Setprivexec(flag int) (err error) {
1467		_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
1468		if e1 != 0 {
1469		err = errnoErr(e1)
1470		}
1471		return
1472		}
1473
1474		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1475
1476		func Setregid(rgid int, egid int) (err error) {
1477		_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
1478		if e1 != 0 {
1479		err = errnoErr(e1)
1480		}
1481		return
1482		}
1483
1484		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1485
1486		func Setreuid(ruid int, euid int) (err error) {
1487		_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1488		if e1 != 0 {
1489		err = errnoErr(e1)
1490		}
1491		return
1492		}
1493
1494		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1495
1496		func Setrlimit(which int, lim *Rlimit) (err error) {
1497		_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1498		if e1 != 0 {
1499		err = errnoErr(e1)
1500		}
1501		return
1502		}
1503
1504		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1505
1506		func Setsid() (pid int, err error) {
1507		r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
1508		pid = int(r0)
1509		if e1 != 0 {
1510		err = errnoErr(e1)
1511		}
1512		return
1513		}
1514
1515		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1516
1517		func Settimeofday(tp *Timeval) (err error) {
1518		_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1519		if e1 != 0 {
1520		err = errnoErr(e1)
1521		}
1522		return
1523		}
1524
1525		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1526
1527		func Setuid(uid int) (err error) {
1528		_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1529		if e1 != 0 {
1530		err = errnoErr(e1)
1531		}
1532		return
1533		}
	2454	_, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2455	if e1 != 0 {
	2456	err = errnoErr(e1)
	2457	}
	2458	return
	2459	}
	2460
	2461	func libc_lstat64_trampoline()
	2462
	2463	//go:linkname libc_lstat64 libc_lstat64
	2464	//go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
1534	2465
1535	2466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1536	2467

1540	2471	if err != nil {
1541	2472	return
1542	2473	}
1543		_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1544		if e1 != 0 {
1545		err = errnoErr(e1)
1546		}
1547		return
1548		}
	2474	_, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2475	if e1 != 0 {
	2476	err = errnoErr(e1)
	2477	}
	2478	return
	2479	}
	2480
	2481	func libc_stat64_trampoline()
	2482
	2483	//go:linkname libc_stat64 libc_stat64
	2484	//go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
1549	2485
1550	2486	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1551	2487

1555	2491	if err != nil {
1556	2492	return
1557	2493	}
1558		_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1559		if e1 != 0 {
1560		err = errnoErr(e1)
1561		}
1562		return
1563		}
1564
1565		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1566
1567		func Symlink(path string, link string) (err error) {
1568		var _p0 *byte
1569		_p0, err = BytePtrFromString(path)
1570		if err != nil {
1571		return
1572		}
1573		var _p1 *byte
1574		_p1, err = BytePtrFromString(link)
1575		if err != nil {
1576		return
1577		}
1578		_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1579		if e1 != 0 {
1580		err = errnoErr(e1)
1581		}
1582		return
1583		}
1584
1585		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1586
1587		func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
1588		var _p0 *byte
1589		_p0, err = BytePtrFromString(oldpath)
1590		if err != nil {
1591		return
1592		}
1593		var _p1 *byte
1594		_p1, err = BytePtrFromString(newpath)
1595		if err != nil {
1596		return
1597		}
1598		_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
1599		if e1 != 0 {
1600		err = errnoErr(e1)
1601		}
1602		return
1603		}
1604
1605		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1606
1607		func Sync() (err error) {
1608		_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
1609		if e1 != 0 {
1610		err = errnoErr(e1)
1611		}
1612		return
1613		}
1614
1615		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1616
1617		func Truncate(path string, length int64) (err error) {
1618		var _p0 *byte
1619		_p0, err = BytePtrFromString(path)
1620		if err != nil {
1621		return
1622		}
1623		_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
1624		if e1 != 0 {
1625		err = errnoErr(e1)
1626		}
1627		return
1628		}
1629
1630		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1631
1632		func Umask(newmask int) (oldmask int) {
1633		r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
1634		oldmask = int(r0)
1635		return
1636		}
1637
1638		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1639
1640		func Undelete(path string) (err error) {
1641		var _p0 *byte
1642		_p0, err = BytePtrFromString(path)
1643		if err != nil {
1644		return
1645		}
1646		_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1647		if e1 != 0 {
1648		err = errnoErr(e1)
1649		}
1650		return
1651		}
1652
1653		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1654
1655		func Unlink(path string) (err error) {
1656		var _p0 *byte
1657		_p0, err = BytePtrFromString(path)
1658		if err != nil {
1659		return
1660		}
1661		_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
1662		if e1 != 0 {
1663		err = errnoErr(e1)
1664		}
1665		return
1666		}
1667
1668		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1669
1670		func Unlinkat(dirfd int, path string, flags int) (err error) {
1671		var _p0 *byte
1672		_p0, err = BytePtrFromString(path)
1673		if err != nil {
1674		return
1675		}
1676		_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
1677		if e1 != 0 {
1678		err = errnoErr(e1)
1679		}
1680		return
1681		}
1682
1683		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1684
1685		func Unmount(path string, flags int) (err error) {
1686		var _p0 *byte
1687		_p0, err = BytePtrFromString(path)
1688		if err != nil {
1689		return
1690		}
1691		_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1692		if e1 != 0 {
1693		err = errnoErr(e1)
1694		}
1695		return
1696		}
1697
1698		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1699
1700		func write(fd int, p []byte) (n int, err error) {
1701		var _p0 unsafe.Pointer
1702		if len(p) > 0 {
1703		_p0 = unsafe.Pointer(&p[0])
1704		} else {
1705		_p0 = unsafe.Pointer(&_zero)
1706		}
1707		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
1708		n = int(r0)
1709		if e1 != 0 {
1710		err = errnoErr(e1)
1711		}
1712		return
1713		}
1714
1715		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1716
1717		func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1718		r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
1719		ret = uintptr(r0)
1720		if e1 != 0 {
1721		err = errnoErr(e1)
1722		}
1723		return
1724		}
1725
1726		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1727
1728		func munmap(addr uintptr, length uintptr) (err error) {
1729		_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
1730		if e1 != 0 {
1731		err = errnoErr(e1)
1732		}
1733		return
1734		}
1735
1736		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1737
1738		func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1739		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1740		n = int(r0)
1741		if e1 != 0 {
1742		err = errnoErr(e1)
1743		}
1744		return
1745		}
1746
1747		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1748
1749		func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1750		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1751		n = int(r0)
1752		if e1 != 0 {
1753		err = errnoErr(e1)
1754		}
1755		return
1756		}
1757
1758		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1759
1760		func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
1761		r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1762		sec = int32(r0)
1763		usec = int32(r1)
1764		if e1 != 0 {
1765		err = errnoErr(e1)
1766		}
1767		return
1768		}
	2494	_, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2495	if e1 != 0 {
	2496	err = errnoErr(e1)
	2497	}
	2498	return
	2499	}
	2500
	2501	func libc_statfs64_trampoline()
	2502
	2503	//go:linkname libc_statfs64 libc_statfs64
	2504	//go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"

+284

-0

unix/zsyscall_darwin_386.s less more

	0	// go run mkasm_darwin.go 386
	1	// Code generated by the command above; DO NOT EDIT.
	2
	3	// +build go1.12
	4
	5	#include "textflag.h"
	6	TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
	7	JMP libc_getgroups(SB)
	8	TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
	9	JMP libc_setgroups(SB)
	10	TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
	11	JMP libc_wait4(SB)
	12	TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
	13	JMP libc_accept(SB)
	14	TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
	15	JMP libc_bind(SB)
	16	TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
	17	JMP libc_connect(SB)
	18	TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
	19	JMP libc_socket(SB)
	20	TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
	21	JMP libc_getsockopt(SB)
	22	TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
	23	JMP libc_setsockopt(SB)
	24	TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
	25	JMP libc_getpeername(SB)
	26	TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
	27	JMP libc_getsockname(SB)
	28	TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
	29	JMP libc_shutdown(SB)
	30	TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
	31	JMP libc_socketpair(SB)
	32	TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
	33	JMP libc_recvfrom(SB)
	34	TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
	35	JMP libc_sendto(SB)
	36	TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
	37	JMP libc_recvmsg(SB)
	38	TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
	39	JMP libc_sendmsg(SB)
	40	TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
	41	JMP libc_kevent(SB)
	42	TEXT ·libc___sysctl_trampoline(SB),NOSPLIT,$0-0
	43	JMP libc___sysctl(SB)
	44	TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
	45	JMP libc_utimes(SB)
	46	TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
	47	JMP libc_futimes(SB)
	48	TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
	49	JMP libc_fcntl(SB)
	50	TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
	51	JMP libc_poll(SB)
	52	TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
	53	JMP libc_madvise(SB)
	54	TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
	55	JMP libc_mlock(SB)
	56	TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
	57	JMP libc_mlockall(SB)
	58	TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
	59	JMP libc_mprotect(SB)
	60	TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
	61	JMP libc_msync(SB)
	62	TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
	63	JMP libc_munlock(SB)
	64	TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
	65	JMP libc_munlockall(SB)
	66	TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
	67	JMP libc_ptrace(SB)
	68	TEXT ·libc_getattrlist_trampoline(SB),NOSPLIT,$0-0
	69	JMP libc_getattrlist(SB)
	70	TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
	71	JMP libc_pipe(SB)
	72	TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
	73	JMP libc_getxattr(SB)
	74	TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
	75	JMP libc_fgetxattr(SB)
	76	TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
	77	JMP libc_setxattr(SB)
	78	TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
	79	JMP libc_fsetxattr(SB)
	80	TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
	81	JMP libc_removexattr(SB)
	82	TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
	83	JMP libc_fremovexattr(SB)
	84	TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
	85	JMP libc_listxattr(SB)
	86	TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
	87	JMP libc_flistxattr(SB)
	88	TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
	89	JMP libc_setattrlist(SB)
	90	TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
	91	JMP libc_kill(SB)
	92	TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
	93	JMP libc_ioctl(SB)
	94	TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
	95	JMP libc_sendfile(SB)
	96	TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
	97	JMP libc_access(SB)
	98	TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
	99	JMP libc_adjtime(SB)
	100	TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
	101	JMP libc_chdir(SB)
	102	TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
	103	JMP libc_chflags(SB)
	104	TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
	105	JMP libc_chmod(SB)
	106	TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
	107	JMP libc_chown(SB)
	108	TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
	109	JMP libc_chroot(SB)
	110	TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
	111	JMP libc_close(SB)
	112	TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
	113	JMP libc_dup(SB)
	114	TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
	115	JMP libc_dup2(SB)
	116	TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
	117	JMP libc_exchangedata(SB)
	118	TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
	119	JMP libc_exit(SB)
	120	TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
	121	JMP libc_faccessat(SB)
	122	TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
	123	JMP libc_fchdir(SB)
	124	TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
	125	JMP libc_fchflags(SB)
	126	TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
	127	JMP libc_fchmod(SB)
	128	TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
	129	JMP libc_fchmodat(SB)
	130	TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
	131	JMP libc_fchown(SB)
	132	TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
	133	JMP libc_fchownat(SB)
	134	TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
	135	JMP libc_flock(SB)
	136	TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
	137	JMP libc_fpathconf(SB)
	138	TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
	139	JMP libc_fsync(SB)
	140	TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
	141	JMP libc_ftruncate(SB)
	142	TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
	143	JMP libc_getdtablesize(SB)
	144	TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
	145	JMP libc_getegid(SB)
	146	TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
	147	JMP libc_geteuid(SB)
	148	TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
	149	JMP libc_getgid(SB)
	150	TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
	151	JMP libc_getpgid(SB)
	152	TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
	153	JMP libc_getpgrp(SB)
	154	TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
	155	JMP libc_getpid(SB)
	156	TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
	157	JMP libc_getppid(SB)
	158	TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
	159	JMP libc_getpriority(SB)
	160	TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
	161	JMP libc_getrlimit(SB)
	162	TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
	163	JMP libc_getrusage(SB)
	164	TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
	165	JMP libc_getsid(SB)
	166	TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
	167	JMP libc_getuid(SB)
	168	TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
	169	JMP libc_issetugid(SB)
	170	TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
	171	JMP libc_kqueue(SB)
	172	TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
	173	JMP libc_lchown(SB)
	174	TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
	175	JMP libc_link(SB)
	176	TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
	177	JMP libc_linkat(SB)
	178	TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
	179	JMP libc_listen(SB)
	180	TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
	181	JMP libc_mkdir(SB)
	182	TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
	183	JMP libc_mkdirat(SB)
	184	TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
	185	JMP libc_mkfifo(SB)
	186	TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
	187	JMP libc_mknod(SB)
	188	TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
	189	JMP libc_open(SB)
	190	TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
	191	JMP libc_openat(SB)
	192	TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
	193	JMP libc_pathconf(SB)
	194	TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
	195	JMP libc_pread(SB)
	196	TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
	197	JMP libc_pwrite(SB)
	198	TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
	199	JMP libc_read(SB)
	200	TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
	201	JMP libc_readlink(SB)
	202	TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
	203	JMP libc_readlinkat(SB)
	204	TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
	205	JMP libc_rename(SB)
	206	TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
	207	JMP libc_renameat(SB)
	208	TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
	209	JMP libc_revoke(SB)
	210	TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
	211	JMP libc_rmdir(SB)
	212	TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
	213	JMP libc_lseek(SB)
	214	TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
	215	JMP libc_select(SB)
	216	TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
	217	JMP libc_setegid(SB)
	218	TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
	219	JMP libc_seteuid(SB)
	220	TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
	221	JMP libc_setgid(SB)
	222	TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
	223	JMP libc_setlogin(SB)
	224	TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
	225	JMP libc_setpgid(SB)
	226	TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
	227	JMP libc_setpriority(SB)
	228	TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
	229	JMP libc_setprivexec(SB)
	230	TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
	231	JMP libc_setregid(SB)
	232	TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
	233	JMP libc_setreuid(SB)
	234	TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
	235	JMP libc_setrlimit(SB)
	236	TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
	237	JMP libc_setsid(SB)
	238	TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
	239	JMP libc_settimeofday(SB)
	240	TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
	241	JMP libc_setuid(SB)
	242	TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
	243	JMP libc_symlink(SB)
	244	TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
	245	JMP libc_symlinkat(SB)
	246	TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
	247	JMP libc_sync(SB)
	248	TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
	249	JMP libc_truncate(SB)
	250	TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
	251	JMP libc_umask(SB)
	252	TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
	253	JMP libc_undelete(SB)
	254	TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
	255	JMP libc_unlink(SB)
	256	TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
	257	JMP libc_unlinkat(SB)
	258	TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
	259	JMP libc_unmount(SB)
	260	TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
	261	JMP libc_write(SB)
	262	TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
	263	JMP libc_mmap(SB)
	264	TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
	265	JMP libc_munmap(SB)
	266	TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
	267	JMP libc_gettimeofday(SB)
	268	TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
	269	JMP libc_fstat64(SB)
	270	TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
	271	JMP libc_fstatat64(SB)
	272	TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
	273	JMP libc_fstatfs64(SB)
	274	TEXT ·libc___getdirentries64_trampoline(SB),NOSPLIT,$0-0
	275	JMP libc___getdirentries64(SB)
	276	TEXT ·libc_getfsstat64_trampoline(SB),NOSPLIT,$0-0
	277	JMP libc_getfsstat64(SB)
	278	TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
	279	JMP libc_lstat64(SB)
	280	TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
	281	JMP libc_stat64(SB)
	282	TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
	283	JMP libc_statfs64(SB)

+1810

-0

unix/zsyscall_darwin_amd64.1_11.go less more

	0	// go run mksyscall.go -tags darwin,amd64,!go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
	2
	3	// +build darwin,amd64,!go1.12
	4
	5	package unix
	6
	7	import (
	8	"syscall"
	9	"unsafe"
	10	)
	11
	12	var _ syscall.Errno
	13
	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	15
	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
	17	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	18	n = int(r0)
	19	if e1 != 0 {
	20	err = errnoErr(e1)
	21	}
	22	return
	23	}
	24
	25	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	26
	27	func setgroups(ngid int, gid *_Gid_t) (err error) {
	28	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	29	if e1 != 0 {
	30	err = errnoErr(e1)
	31	}
	32	return
	33	}
	34
	35	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	36
	37	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
	38	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	39	wpid = int(r0)
	40	if e1 != 0 {
	41	err = errnoErr(e1)
	42	}
	43	return
	44	}
	45
	46	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	47
	48	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
	49	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	50	fd = int(r0)
	51	if e1 != 0 {
	52	err = errnoErr(e1)
	53	}
	54	return
	55	}
	56
	57	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	58
	59	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	60	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
	61	if e1 != 0 {
	62	err = errnoErr(e1)
	63	}
	64	return
	65	}
	66
	67	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	68
	69	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	70	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
	71	if e1 != 0 {
	72	err = errnoErr(e1)
	73	}
	74	return
	75	}
	76
	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	78
	79	func socket(domain int, typ int, proto int) (fd int, err error) {
	80	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	81	fd = int(r0)
	82	if e1 != 0 {
	83	err = errnoErr(e1)
	84	}
	85	return
	86	}
	87
	88	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	89
	90	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
	91	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	92	if e1 != 0 {
	93	err = errnoErr(e1)
	94	}
	95	return
	96	}
	97
	98	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	99
	100	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
	101	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	102	if e1 != 0 {
	103	err = errnoErr(e1)
	104	}
	105	return
	106	}
	107
	108	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	109
	110	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	111	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	112	if e1 != 0 {
	113	err = errnoErr(e1)
	114	}
	115	return
	116	}
	117
	118	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	119
	120	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	121	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	122	if e1 != 0 {
	123	err = errnoErr(e1)
	124	}
	125	return
	126	}
	127
	128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	129
	130	func Shutdown(s int, how int) (err error) {
	131	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
	132	if e1 != 0 {
	133	err = errnoErr(e1)
	134	}
	135	return
	136	}
	137
	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	139
	140	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
	141	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	149
	150	func recvfrom(fd int, p []byte, flags int, from RawSockaddrAny, fromlen _Socklen) (n int, err error) {
	151	var _p0 unsafe.Pointer
	152	if len(p) > 0 {
	153	_p0 = unsafe.Pointer(&p[0])
	154	} else {
	155	_p0 = unsafe.Pointer(&_zero)
	156	}
	157	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	158	n = int(r0)
	159	if e1 != 0 {
	160	err = errnoErr(e1)
	161	}
	162	return
	163	}
	164
	165	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	166
	167	func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
	168	var _p0 unsafe.Pointer
	169	if len(buf) > 0 {
	170	_p0 = unsafe.Pointer(&buf[0])
	171	} else {
	172	_p0 = unsafe.Pointer(&_zero)
	173	}
	174	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	175	if e1 != 0 {
	176	err = errnoErr(e1)
	177	}
	178	return
	179	}
	180
	181	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	182
	183	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	184	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	185	n = int(r0)
	186	if e1 != 0 {
	187	err = errnoErr(e1)
	188	}
	189	return
	190	}
	191
	192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	193
	194	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	195	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	196	n = int(r0)
	197	if e1 != 0 {
	198	err = errnoErr(e1)
	199	}
	200	return
	201	}
	202
	203	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	204
	205	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
	206	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	207	n = int(r0)
	208	if e1 != 0 {
	209	err = errnoErr(e1)
	210	}
	211	return
	212	}
	213
	214	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	215
	216	func sysctl(mib []_C_int, old byte, oldlen uintptr, new *byte, newlen uintptr) (err error) {
	217	var _p0 unsafe.Pointer
	218	if len(mib) > 0 {
	219	_p0 = unsafe.Pointer(&mib[0])
	220	} else {
	221	_p0 = unsafe.Pointer(&_zero)
	222	}
	223	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
	224	if e1 != 0 {
	225	err = errnoErr(e1)
	226	}
	227	return
	228	}
	229
	230	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	231
	232	func utimes(path string, timeval *[2]Timeval) (err error) {
	233	var _p0 *byte
	234	_p0, err = BytePtrFromString(path)
	235	if err != nil {
	236	return
	237	}
	238	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	239	if e1 != 0 {
	240	err = errnoErr(e1)
	241	}
	242	return
	243	}
	244
	245	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	246
	247	func futimes(fd int, timeval *[2]Timeval) (err error) {
	248	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	249	if e1 != 0 {
	250	err = errnoErr(e1)
	251	}
	252	return
	253	}
	254
	255	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	256
	257	func fcntl(fd int, cmd int, arg int) (val int, err error) {
	258	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	259	val = int(r0)
	260	if e1 != 0 {
	261	err = errnoErr(e1)
	262	}
	263	return
	264	}
	265
	266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	267
	268	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
	269	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	270	n = int(r0)
	271	if e1 != 0 {
	272	err = errnoErr(e1)
	273	}
	274	return
	275	}
	276
	277	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	278
	279	func Madvise(b []byte, behav int) (err error) {
	280	var _p0 unsafe.Pointer
	281	if len(b) > 0 {
	282	_p0 = unsafe.Pointer(&b[0])
	283	} else {
	284	_p0 = unsafe.Pointer(&_zero)
	285	}
	286	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
	287	if e1 != 0 {
	288	err = errnoErr(e1)
	289	}
	290	return
	291	}
	292
	293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	294
	295	func Mlock(b []byte) (err error) {
	296	var _p0 unsafe.Pointer
	297	if len(b) > 0 {
	298	_p0 = unsafe.Pointer(&b[0])
	299	} else {
	300	_p0 = unsafe.Pointer(&_zero)
	301	}
	302	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
	303	if e1 != 0 {
	304	err = errnoErr(e1)
	305	}
	306	return
	307	}
	308
	309	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	310
	311	func Mlockall(flags int) (err error) {
	312	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
	313	if e1 != 0 {
	314	err = errnoErr(e1)
	315	}
	316	return
	317	}
	318
	319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	320
	321	func Mprotect(b []byte, prot int) (err error) {
	322	var _p0 unsafe.Pointer
	323	if len(b) > 0 {
	324	_p0 = unsafe.Pointer(&b[0])
	325	} else {
	326	_p0 = unsafe.Pointer(&_zero)
	327	}
	328	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
	329	if e1 != 0 {
	330	err = errnoErr(e1)
	331	}
	332	return
	333	}
	334
	335	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	336
	337	func Msync(b []byte, flags int) (err error) {
	338	var _p0 unsafe.Pointer
	339	if len(b) > 0 {
	340	_p0 = unsafe.Pointer(&b[0])
	341	} else {
	342	_p0 = unsafe.Pointer(&_zero)
	343	}
	344	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
	345	if e1 != 0 {
	346	err = errnoErr(e1)
	347	}
	348	return
	349	}
	350
	351	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	352
	353	func Munlock(b []byte) (err error) {
	354	var _p0 unsafe.Pointer
	355	if len(b) > 0 {
	356	_p0 = unsafe.Pointer(&b[0])
	357	} else {
	358	_p0 = unsafe.Pointer(&_zero)
	359	}
	360	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
	361	if e1 != 0 {
	362	err = errnoErr(e1)
	363	}
	364	return
	365	}
	366
	367	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	368
	369	func Munlockall() (err error) {
	370	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
	371	if e1 != 0 {
	372	err = errnoErr(e1)
	373	}
	374	return
	375	}
	376
	377	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	378
	379	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
	380	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	381	if e1 != 0 {
	382	err = errnoErr(e1)
	383	}
	384	return
	385	}
	386
	387	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	388
	389	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	390	_, _, e1 := Syscall6(SYS_GETATTRLIST, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	391	if e1 != 0 {
	392	err = errnoErr(e1)
	393	}
	394	return
	395	}
	396
	397	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	398
	399	func pipe() (r int, w int, err error) {
	400	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	401	r = int(r0)
	402	w = int(r1)
	403	if e1 != 0 {
	404	err = errnoErr(e1)
	405	}
	406	return
	407	}
	408
	409	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	410
	411	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	412	var _p0 *byte
	413	_p0, err = BytePtrFromString(path)
	414	if err != nil {
	415	return
	416	}
	417	var _p1 *byte
	418	_p1, err = BytePtrFromString(attr)
	419	if err != nil {
	420	return
	421	}
	422	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	423	sz = int(r0)
	424	if e1 != 0 {
	425	err = errnoErr(e1)
	426	}
	427	return
	428	}
	429
	430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	431
	432	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	433	var _p0 *byte
	434	_p0, err = BytePtrFromString(attr)
	435	if err != nil {
	436	return
	437	}
	438	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	439	sz = int(r0)
	440	if e1 != 0 {
	441	err = errnoErr(e1)
	442	}
	443	return
	444	}
	445
	446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	447
	448	func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
	449	var _p0 *byte
	450	_p0, err = BytePtrFromString(path)
	451	if err != nil {
	452	return
	453	}
	454	var _p1 *byte
	455	_p1, err = BytePtrFromString(attr)
	456	if err != nil {
	457	return
	458	}
	459	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	460	if e1 != 0 {
	461	err = errnoErr(e1)
	462	}
	463	return
	464	}
	465
	466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	467
	468	func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
	469	var _p0 *byte
	470	_p0, err = BytePtrFromString(attr)
	471	if err != nil {
	472	return
	473	}
	474	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	475	if e1 != 0 {
	476	err = errnoErr(e1)
	477	}
	478	return
	479	}
	480
	481	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	482
	483	func removexattr(path string, attr string, options int) (err error) {
	484	var _p0 *byte
	485	_p0, err = BytePtrFromString(path)
	486	if err != nil {
	487	return
	488	}
	489	var _p1 *byte
	490	_p1, err = BytePtrFromString(attr)
	491	if err != nil {
	492	return
	493	}
	494	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	495	if e1 != 0 {
	496	err = errnoErr(e1)
	497	}
	498	return
	499	}
	500
	501	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	502
	503	func fremovexattr(fd int, attr string, options int) (err error) {
	504	var _p0 *byte
	505	_p0, err = BytePtrFromString(attr)
	506	if err != nil {
	507	return
	508	}
	509	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	510	if e1 != 0 {
	511	err = errnoErr(e1)
	512	}
	513	return
	514	}
	515
	516	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	517
	518	func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
	519	var _p0 *byte
	520	_p0, err = BytePtrFromString(path)
	521	if err != nil {
	522	return
	523	}
	524	r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	525	sz = int(r0)
	526	if e1 != 0 {
	527	err = errnoErr(e1)
	528	}
	529	return
	530	}
	531
	532	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	533
	534	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
	535	r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	536	sz = int(r0)
	537	if e1 != 0 {
	538	err = errnoErr(e1)
	539	}
	540	return
	541	}
	542
	543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	544
	545	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	546	_, _, e1 := Syscall6(SYS_SETATTRLIST, 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	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	554
	555	func kill(pid int, signum int, posix int) (err error) {
	556	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
	557	if e1 != 0 {
	558	err = errnoErr(e1)
	559	}
	560	return
	561	}
	562
	563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	564
	565	func ioctl(fd int, req uint, arg uintptr) (err error) {
	566	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
	567	if e1 != 0 {
	568	err = errnoErr(e1)
	569	}
	570	return
	571	}
	572
	573	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	574
	575	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	576	_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
	577	if e1 != 0 {
	578	err = errnoErr(e1)
	579	}
	580	return
	581	}
	582
	583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	584
	585	func Access(path string, mode uint32) (err error) {
	586	var _p0 *byte
	587	_p0, err = BytePtrFromString(path)
	588	if err != nil {
	589	return
	590	}
	591	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	592	if e1 != 0 {
	593	err = errnoErr(e1)
	594	}
	595	return
	596	}
	597
	598	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	599
	600	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
	601	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	602	if e1 != 0 {
	603	err = errnoErr(e1)
	604	}
	605	return
	606	}
	607
	608	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	609
	610	func Chdir(path string) (err error) {
	611	var _p0 *byte
	612	_p0, err = BytePtrFromString(path)
	613	if err != nil {
	614	return
	615	}
	616	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	617	if e1 != 0 {
	618	err = errnoErr(e1)
	619	}
	620	return
	621	}
	622
	623	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	624
	625	func Chflags(path string, flags int) (err error) {
	626	var _p0 *byte
	627	_p0, err = BytePtrFromString(path)
	628	if err != nil {
	629	return
	630	}
	631	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	632	if e1 != 0 {
	633	err = errnoErr(e1)
	634	}
	635	return
	636	}
	637
	638	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	639
	640	func Chmod(path string, mode uint32) (err error) {
	641	var _p0 *byte
	642	_p0, err = BytePtrFromString(path)
	643	if err != nil {
	644	return
	645	}
	646	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	647	if e1 != 0 {
	648	err = errnoErr(e1)
	649	}
	650	return
	651	}
	652
	653	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	654
	655	func Chown(path string, uid int, gid int) (err error) {
	656	var _p0 *byte
	657	_p0, err = BytePtrFromString(path)
	658	if err != nil {
	659	return
	660	}
	661	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	662	if e1 != 0 {
	663	err = errnoErr(e1)
	664	}
	665	return
	666	}
	667
	668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	669
	670	func Chroot(path string) (err error) {
	671	var _p0 *byte
	672	_p0, err = BytePtrFromString(path)
	673	if err != nil {
	674	return
	675	}
	676	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
	677	if e1 != 0 {
	678	err = errnoErr(e1)
	679	}
	680	return
	681	}
	682
	683	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	684
	685	func Close(fd int) (err error) {
	686	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
	687	if e1 != 0 {
	688	err = errnoErr(e1)
	689	}
	690	return
	691	}
	692
	693	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	694
	695	func Dup(fd int) (nfd int, err error) {
	696	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	697	nfd = int(r0)
	698	if e1 != 0 {
	699	err = errnoErr(e1)
	700	}
	701	return
	702	}
	703
	704	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	705
	706	func Dup2(from int, to int) (err error) {
	707	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
	708	if e1 != 0 {
	709	err = errnoErr(e1)
	710	}
	711	return
	712	}
	713
	714	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	715
	716	func Exchangedata(path1 string, path2 string, options int) (err error) {
	717	var _p0 *byte
	718	_p0, err = BytePtrFromString(path1)
	719	if err != nil {
	720	return
	721	}
	722	var _p1 *byte
	723	_p1, err = BytePtrFromString(path2)
	724	if err != nil {
	725	return
	726	}
	727	_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	728	if e1 != 0 {
	729	err = errnoErr(e1)
	730	}
	731	return
	732	}
	733
	734	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	735
	736	func Exit(code int) {
	737	Syscall(SYS_EXIT, uintptr(code), 0, 0)
	738	return
	739	}
	740
	741	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	742
	743	func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
	744	var _p0 *byte
	745	_p0, err = BytePtrFromString(path)
	746	if err != nil {
	747	return
	748	}
	749	_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	750	if e1 != 0 {
	751	err = errnoErr(e1)
	752	}
	753	return
	754	}
	755
	756	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	757
	758	func Fchdir(fd int) (err error) {
	759	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
	760	if e1 != 0 {
	761	err = errnoErr(e1)
	762	}
	763	return
	764	}
	765
	766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	767
	768	func Fchflags(fd int, flags int) (err error) {
	769	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
	770	if e1 != 0 {
	771	err = errnoErr(e1)
	772	}
	773	return
	774	}
	775
	776	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	777
	778	func Fchmod(fd int, mode uint32) (err error) {
	779	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
	780	if e1 != 0 {
	781	err = errnoErr(e1)
	782	}
	783	return
	784	}
	785
	786	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	787
	788	func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
	789	var _p0 *byte
	790	_p0, err = BytePtrFromString(path)
	791	if err != nil {
	792	return
	793	}
	794	_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	795	if e1 != 0 {
	796	err = errnoErr(e1)
	797	}
	798	return
	799	}
	800
	801	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	802
	803	func Fchown(fd int, uid int, gid int) (err error) {
	804	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
	805	if e1 != 0 {
	806	err = errnoErr(e1)
	807	}
	808	return
	809	}
	810
	811	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	812
	813	func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
	814	var _p0 *byte
	815	_p0, err = BytePtrFromString(path)
	816	if err != nil {
	817	return
	818	}
	819	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	820	if e1 != 0 {
	821	err = errnoErr(e1)
	822	}
	823	return
	824	}
	825
	826	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	827
	828	func Flock(fd int, how int) (err error) {
	829	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
	830	if e1 != 0 {
	831	err = errnoErr(e1)
	832	}
	833	return
	834	}
	835
	836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	837
	838	func Fpathconf(fd int, name int) (val int, err error) {
	839	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	840	val = int(r0)
	841	if e1 != 0 {
	842	err = errnoErr(e1)
	843	}
	844	return
	845	}
	846
	847	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	848
	849	func Fsync(fd int) (err error) {
	850	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
	851	if e1 != 0 {
	852	err = errnoErr(e1)
	853	}
	854	return
	855	}
	856
	857	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	858
	859	func Ftruncate(fd int, length int64) (err error) {
	860	_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
	861	if e1 != 0 {
	862	err = errnoErr(e1)
	863	}
	864	return
	865	}
	866
	867	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	868
	869	func Getdtablesize() (size int) {
	870	r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	871	size = int(r0)
	872	return
	873	}
	874
	875	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	876
	877	func Getegid() (egid int) {
	878	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	879	egid = int(r0)
	880	return
	881	}
	882
	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	884
	885	func Geteuid() (uid int) {
	886	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	887	uid = int(r0)
	888	return
	889	}
	890
	891	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	892
	893	func Getgid() (gid int) {
	894	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	895	gid = int(r0)
	896	return
	897	}
	898
	899	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	900
	901	func Getpgid(pid int) (pgid int, err error) {
	902	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	903	pgid = int(r0)
	904	if e1 != 0 {
	905	err = errnoErr(e1)
	906	}
	907	return
	908	}
	909
	910	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	911
	912	func Getpgrp() (pgrp int) {
	913	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	914	pgrp = int(r0)
	915	return
	916	}
	917
	918	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	919
	920	func Getpid() (pid int) {
	921	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	922	pid = int(r0)
	923	return
	924	}
	925
	926	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	927
	928	func Getppid() (ppid int) {
	929	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	930	ppid = int(r0)
	931	return
	932	}
	933
	934	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	935
	936	func Getpriority(which int, who int) (prio int, err error) {
	937	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	938	prio = int(r0)
	939	if e1 != 0 {
	940	err = errnoErr(e1)
	941	}
	942	return
	943	}
	944
	945	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	946
	947	func Getrlimit(which int, lim *Rlimit) (err error) {
	948	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	949	if e1 != 0 {
	950	err = errnoErr(e1)
	951	}
	952	return
	953	}
	954
	955	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	956
	957	func Getrusage(who int, rusage *Rusage) (err error) {
	958	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	959	if e1 != 0 {
	960	err = errnoErr(e1)
	961	}
	962	return
	963	}
	964
	965	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	966
	967	func Getsid(pid int) (sid int, err error) {
	968	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	969	sid = int(r0)
	970	if e1 != 0 {
	971	err = errnoErr(e1)
	972	}
	973	return
	974	}
	975
	976	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	977
	978	func Getuid() (uid int) {
	979	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	980	uid = int(r0)
	981	return
	982	}
	983
	984	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	985
	986	func Issetugid() (tainted bool) {
	987	r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	988	tainted = bool(r0 != 0)
	989	return
	990	}
	991
	992	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	993
	994	func Kqueue() (fd int, err error) {
	995	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	996	fd = int(r0)
	997	if e1 != 0 {
	998	err = errnoErr(e1)
	999	}
	1000	return
	1001	}
	1002
	1003	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1004
	1005	func Lchown(path string, uid int, gid int) (err error) {
	1006	var _p0 *byte
	1007	_p0, err = BytePtrFromString(path)
	1008	if err != nil {
	1009	return
	1010	}
	1011	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1012	if e1 != 0 {
	1013	err = errnoErr(e1)
	1014	}
	1015	return
	1016	}
	1017
	1018	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1019
	1020	func Link(path string, link string) (err error) {
	1021	var _p0 *byte
	1022	_p0, err = BytePtrFromString(path)
	1023	if err != nil {
	1024	return
	1025	}
	1026	var _p1 *byte
	1027	_p1, err = BytePtrFromString(link)
	1028	if err != nil {
	1029	return
	1030	}
	1031	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1032	if e1 != 0 {
	1033	err = errnoErr(e1)
	1034	}
	1035	return
	1036	}
	1037
	1038	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1039
	1040	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1041	var _p0 *byte
	1042	_p0, err = BytePtrFromString(path)
	1043	if err != nil {
	1044	return
	1045	}
	1046	var _p1 *byte
	1047	_p1, err = BytePtrFromString(link)
	1048	if err != nil {
	1049	return
	1050	}
	1051	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1052	if e1 != 0 {
	1053	err = errnoErr(e1)
	1054	}
	1055	return
	1056	}
	1057
	1058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1059
	1060	func Listen(s int, backlog int) (err error) {
	1061	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
	1062	if e1 != 0 {
	1063	err = errnoErr(e1)
	1064	}
	1065	return
	1066	}
	1067
	1068	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1069
	1070	func Mkdir(path string, mode uint32) (err error) {
	1071	var _p0 *byte
	1072	_p0, err = BytePtrFromString(path)
	1073	if err != nil {
	1074	return
	1075	}
	1076	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1077	if e1 != 0 {
	1078	err = errnoErr(e1)
	1079	}
	1080	return
	1081	}
	1082
	1083	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1084
	1085	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1086	var _p0 *byte
	1087	_p0, err = BytePtrFromString(path)
	1088	if err != nil {
	1089	return
	1090	}
	1091	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1092	if e1 != 0 {
	1093	err = errnoErr(e1)
	1094	}
	1095	return
	1096	}
	1097
	1098	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1099
	1100	func Mkfifo(path string, mode uint32) (err error) {
	1101	var _p0 *byte
	1102	_p0, err = BytePtrFromString(path)
	1103	if err != nil {
	1104	return
	1105	}
	1106	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1107	if e1 != 0 {
	1108	err = errnoErr(e1)
	1109	}
	1110	return
	1111	}
	1112
	1113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1114
	1115	func Mknod(path string, mode uint32, dev int) (err error) {
	1116	var _p0 *byte
	1117	_p0, err = BytePtrFromString(path)
	1118	if err != nil {
	1119	return
	1120	}
	1121	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1122	if e1 != 0 {
	1123	err = errnoErr(e1)
	1124	}
	1125	return
	1126	}
	1127
	1128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1129
	1130	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1131	var _p0 *byte
	1132	_p0, err = BytePtrFromString(path)
	1133	if err != nil {
	1134	return
	1135	}
	1136	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1137	fd = int(r0)
	1138	if e1 != 0 {
	1139	err = errnoErr(e1)
	1140	}
	1141	return
	1142	}
	1143
	1144	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1145
	1146	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1147	var _p0 *byte
	1148	_p0, err = BytePtrFromString(path)
	1149	if err != nil {
	1150	return
	1151	}
	1152	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1153	fd = int(r0)
	1154	if e1 != 0 {
	1155	err = errnoErr(e1)
	1156	}
	1157	return
	1158	}
	1159
	1160	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1161
	1162	func Pathconf(path string, name int) (val int, err error) {
	1163	var _p0 *byte
	1164	_p0, err = BytePtrFromString(path)
	1165	if err != nil {
	1166	return
	1167	}
	1168	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1169	val = int(r0)
	1170	if e1 != 0 {
	1171	err = errnoErr(e1)
	1172	}
	1173	return
	1174	}
	1175
	1176	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1177
	1178	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1179	var _p0 unsafe.Pointer
	1180	if len(p) > 0 {
	1181	_p0 = unsafe.Pointer(&p[0])
	1182	} else {
	1183	_p0 = unsafe.Pointer(&_zero)
	1184	}
	1185	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1186	n = int(r0)
	1187	if e1 != 0 {
	1188	err = errnoErr(e1)
	1189	}
	1190	return
	1191	}
	1192
	1193	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1194
	1195	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1196	var _p0 unsafe.Pointer
	1197	if len(p) > 0 {
	1198	_p0 = unsafe.Pointer(&p[0])
	1199	} else {
	1200	_p0 = unsafe.Pointer(&_zero)
	1201	}
	1202	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1203	n = int(r0)
	1204	if e1 != 0 {
	1205	err = errnoErr(e1)
	1206	}
	1207	return
	1208	}
	1209
	1210	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1211
	1212	func read(fd int, p []byte) (n int, err error) {
	1213	var _p0 unsafe.Pointer
	1214	if len(p) > 0 {
	1215	_p0 = unsafe.Pointer(&p[0])
	1216	} else {
	1217	_p0 = unsafe.Pointer(&_zero)
	1218	}
	1219	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1220	n = int(r0)
	1221	if e1 != 0 {
	1222	err = errnoErr(e1)
	1223	}
	1224	return
	1225	}
	1226
	1227	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1228
	1229	func Readlink(path string, buf []byte) (n int, err error) {
	1230	var _p0 *byte
	1231	_p0, err = BytePtrFromString(path)
	1232	if err != nil {
	1233	return
	1234	}
	1235	var _p1 unsafe.Pointer
	1236	if len(buf) > 0 {
	1237	_p1 = unsafe.Pointer(&buf[0])
	1238	} else {
	1239	_p1 = unsafe.Pointer(&_zero)
	1240	}
	1241	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1242	n = int(r0)
	1243	if e1 != 0 {
	1244	err = errnoErr(e1)
	1245	}
	1246	return
	1247	}
	1248
	1249	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1250
	1251	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1252	var _p0 *byte
	1253	_p0, err = BytePtrFromString(path)
	1254	if err != nil {
	1255	return
	1256	}
	1257	var _p1 unsafe.Pointer
	1258	if len(buf) > 0 {
	1259	_p1 = unsafe.Pointer(&buf[0])
	1260	} else {
	1261	_p1 = unsafe.Pointer(&_zero)
	1262	}
	1263	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1264	n = int(r0)
	1265	if e1 != 0 {
	1266	err = errnoErr(e1)
	1267	}
	1268	return
	1269	}
	1270
	1271	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1272
	1273	func Rename(from string, to string) (err error) {
	1274	var _p0 *byte
	1275	_p0, err = BytePtrFromString(from)
	1276	if err != nil {
	1277	return
	1278	}
	1279	var _p1 *byte
	1280	_p1, err = BytePtrFromString(to)
	1281	if err != nil {
	1282	return
	1283	}
	1284	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1285	if e1 != 0 {
	1286	err = errnoErr(e1)
	1287	}
	1288	return
	1289	}
	1290
	1291	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1292
	1293	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1294	var _p0 *byte
	1295	_p0, err = BytePtrFromString(from)
	1296	if err != nil {
	1297	return
	1298	}
	1299	var _p1 *byte
	1300	_p1, err = BytePtrFromString(to)
	1301	if err != nil {
	1302	return
	1303	}
	1304	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1305	if e1 != 0 {
	1306	err = errnoErr(e1)
	1307	}
	1308	return
	1309	}
	1310
	1311	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1312
	1313	func Revoke(path string) (err error) {
	1314	var _p0 *byte
	1315	_p0, err = BytePtrFromString(path)
	1316	if err != nil {
	1317	return
	1318	}
	1319	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1320	if e1 != 0 {
	1321	err = errnoErr(e1)
	1322	}
	1323	return
	1324	}
	1325
	1326	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1327
	1328	func Rmdir(path string) (err error) {
	1329	var _p0 *byte
	1330	_p0, err = BytePtrFromString(path)
	1331	if err != nil {
	1332	return
	1333	}
	1334	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1335	if e1 != 0 {
	1336	err = errnoErr(e1)
	1337	}
	1338	return
	1339	}
	1340
	1341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1342
	1343	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1344	r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
	1345	newoffset = int64(r0)
	1346	if e1 != 0 {
	1347	err = errnoErr(e1)
	1348	}
	1349	return
	1350	}
	1351
	1352	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1353
	1354	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1355	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
	1356	if e1 != 0 {
	1357	err = errnoErr(e1)
	1358	}
	1359	return
	1360	}
	1361
	1362	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1363
	1364	func Setegid(egid int) (err error) {
	1365	_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
	1366	if e1 != 0 {
	1367	err = errnoErr(e1)
	1368	}
	1369	return
	1370	}
	1371
	1372	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1373
	1374	func Seteuid(euid int) (err error) {
	1375	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
	1376	if e1 != 0 {
	1377	err = errnoErr(e1)
	1378	}
	1379	return
	1380	}
	1381
	1382	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1383
	1384	func Setgid(gid int) (err error) {
	1385	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
	1386	if e1 != 0 {
	1387	err = errnoErr(e1)
	1388	}
	1389	return
	1390	}
	1391
	1392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1393
	1394	func Setlogin(name string) (err error) {
	1395	var _p0 *byte
	1396	_p0, err = BytePtrFromString(name)
	1397	if err != nil {
	1398	return
	1399	}
	1400	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1401	if e1 != 0 {
	1402	err = errnoErr(e1)
	1403	}
	1404	return
	1405	}
	1406
	1407	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1408
	1409	func Setpgid(pid int, pgid int) (err error) {
	1410	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
	1411	if e1 != 0 {
	1412	err = errnoErr(e1)
	1413	}
	1414	return
	1415	}
	1416
	1417	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1418
	1419	func Setpriority(which int, who int, prio int) (err error) {
	1420	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
	1421	if e1 != 0 {
	1422	err = errnoErr(e1)
	1423	}
	1424	return
	1425	}
	1426
	1427	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1428
	1429	func Setprivexec(flag int) (err error) {
	1430	_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
	1431	if e1 != 0 {
	1432	err = errnoErr(e1)
	1433	}
	1434	return
	1435	}
	1436
	1437	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1438
	1439	func Setregid(rgid int, egid int) (err error) {
	1440	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
	1441	if e1 != 0 {
	1442	err = errnoErr(e1)
	1443	}
	1444	return
	1445	}
	1446
	1447	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1448
	1449	func Setreuid(ruid int, euid int) (err error) {
	1450	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
	1451	if e1 != 0 {
	1452	err = errnoErr(e1)
	1453	}
	1454	return
	1455	}
	1456
	1457	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1458
	1459	func Setrlimit(which int, lim *Rlimit) (err error) {
	1460	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1461	if e1 != 0 {
	1462	err = errnoErr(e1)
	1463	}
	1464	return
	1465	}
	1466
	1467	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1468
	1469	func Setsid() (pid int, err error) {
	1470	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	1471	pid = int(r0)
	1472	if e1 != 0 {
	1473	err = errnoErr(e1)
	1474	}
	1475	return
	1476	}
	1477
	1478	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1479
	1480	func Settimeofday(tp *Timeval) (err error) {
	1481	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1482	if e1 != 0 {
	1483	err = errnoErr(e1)
	1484	}
	1485	return
	1486	}
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Setuid(uid int) (err error) {
	1491	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1499
	1500	func Symlink(path string, link string) (err error) {
	1501	var _p0 *byte
	1502	_p0, err = BytePtrFromString(path)
	1503	if err != nil {
	1504	return
	1505	}
	1506	var _p1 *byte
	1507	_p1, err = BytePtrFromString(link)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1519
	1520	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	1521	var _p0 *byte
	1522	_p0, err = BytePtrFromString(oldpath)
	1523	if err != nil {
	1524	return
	1525	}
	1526	var _p1 *byte
	1527	_p1, err = BytePtrFromString(newpath)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1539
	1540	func Sync() (err error) {
	1541	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
	1542	if e1 != 0 {
	1543	err = errnoErr(e1)
	1544	}
	1545	return
	1546	}
	1547
	1548	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1549
	1550	func Truncate(path string, length int64) (err error) {
	1551	var _p0 *byte
	1552	_p0, err = BytePtrFromString(path)
	1553	if err != nil {
	1554	return
	1555	}
	1556	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
	1557	if e1 != 0 {
	1558	err = errnoErr(e1)
	1559	}
	1560	return
	1561	}
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Umask(newmask int) (oldmask int) {
	1566	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	1567	oldmask = int(r0)
	1568	return
	1569	}
	1570
	1571	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1572
	1573	func Undelete(path string) (err error) {
	1574	var _p0 *byte
	1575	_p0, err = BytePtrFromString(path)
	1576	if err != nil {
	1577	return
	1578	}
	1579	_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1580	if e1 != 0 {
	1581	err = errnoErr(e1)
	1582	}
	1583	return
	1584	}
	1585
	1586	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1587
	1588	func Unlink(path string) (err error) {
	1589	var _p0 *byte
	1590	_p0, err = BytePtrFromString(path)
	1591	if err != nil {
	1592	return
	1593	}
	1594	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1595	if e1 != 0 {
	1596	err = errnoErr(e1)
	1597	}
	1598	return
	1599	}
	1600
	1601	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1602
	1603	func Unlinkat(dirfd int, path string, flags int) (err error) {
	1604	var _p0 *byte
	1605	_p0, err = BytePtrFromString(path)
	1606	if err != nil {
	1607	return
	1608	}
	1609	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	1610	if e1 != 0 {
	1611	err = errnoErr(e1)
	1612	}
	1613	return
	1614	}
	1615
	1616	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1617
	1618	func Unmount(path string, flags int) (err error) {
	1619	var _p0 *byte
	1620	_p0, err = BytePtrFromString(path)
	1621	if err != nil {
	1622	return
	1623	}
	1624	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	1625	if e1 != 0 {
	1626	err = errnoErr(e1)
	1627	}
	1628	return
	1629	}
	1630
	1631	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1632
	1633	func write(fd int, p []byte) (n int, err error) {
	1634	var _p0 unsafe.Pointer
	1635	if len(p) > 0 {
	1636	_p0 = unsafe.Pointer(&p[0])
	1637	} else {
	1638	_p0 = unsafe.Pointer(&_zero)
	1639	}
	1640	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1641	n = int(r0)
	1642	if e1 != 0 {
	1643	err = errnoErr(e1)
	1644	}
	1645	return
	1646	}
	1647
	1648	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1649
	1650	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	1651	r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
	1652	ret = uintptr(r0)
	1653	if e1 != 0 {
	1654	err = errnoErr(e1)
	1655	}
	1656	return
	1657	}
	1658
	1659	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1660
	1661	func munmap(addr uintptr, length uintptr) (err error) {
	1662	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
	1663	if e1 != 0 {
	1664	err = errnoErr(e1)
	1665	}
	1666	return
	1667	}
	1668
	1669	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1670
	1671	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	1672	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1673	n = int(r0)
	1674	if e1 != 0 {
	1675	err = errnoErr(e1)
	1676	}
	1677	return
	1678	}
	1679
	1680	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1681
	1682	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	1683	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1684	n = int(r0)
	1685	if e1 != 0 {
	1686	err = errnoErr(e1)
	1687	}
	1688	return
	1689	}
	1690
	1691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1692
	1693	func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	1694	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1695	sec = int64(r0)
	1696	usec = int32(r1)
	1697	if e1 != 0 {
	1698	err = errnoErr(e1)
	1699	}
	1700	return
	1701	}
	1702
	1703	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1704
	1705	func Fstat(fd int, stat *Stat_t) (err error) {
	1706	_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1707	if e1 != 0 {
	1708	err = errnoErr(e1)
	1709	}
	1710	return
	1711	}
	1712
	1713	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1714
	1715	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	1716	var _p0 *byte
	1717	_p0, err = BytePtrFromString(path)
	1718	if err != nil {
	1719	return
	1720	}
	1721	_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	1722	if e1 != 0 {
	1723	err = errnoErr(e1)
	1724	}
	1725	return
	1726	}
	1727
	1728	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1729
	1730	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	1731	_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1732	if e1 != 0 {
	1733	err = errnoErr(e1)
	1734	}
	1735	return
	1736	}
	1737
	1738	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1739
	1740	func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
	1741	var _p0 unsafe.Pointer
	1742	if len(buf) > 0 {
	1743	_p0 = unsafe.Pointer(&buf[0])
	1744	} else {
	1745	_p0 = unsafe.Pointer(&_zero)
	1746	}
	1747	r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
	1748	n = int(r0)
	1749	if e1 != 0 {
	1750	err = errnoErr(e1)
	1751	}
	1752	return
	1753	}
	1754
	1755	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1756
	1757	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	1758	r0, _, e1 := Syscall(SYS_GETFSSTAT64, uintptr(buf), uintptr(size), uintptr(flags))
	1759	n = int(r0)
	1760	if e1 != 0 {
	1761	err = errnoErr(e1)
	1762	}
	1763	return
	1764	}
	1765
	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1767
	1768	func Lstat(path string, stat *Stat_t) (err error) {
	1769	var _p0 *byte
	1770	_p0, err = BytePtrFromString(path)
	1771	if err != nil {
	1772	return
	1773	}
	1774	_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1775	if e1 != 0 {
	1776	err = errnoErr(e1)
	1777	}
	1778	return
	1779	}
	1780
	1781	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1782
	1783	func Stat(path string, stat *Stat_t) (err error) {
	1784	var _p0 *byte
	1785	_p0, err = BytePtrFromString(path)
	1786	if err != nil {
	1787	return
	1788	}
	1789	_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1790	if e1 != 0 {
	1791	err = errnoErr(e1)
	1792	}
	1793	return
	1794	}
	1795
	1796	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1797
	1798	func Statfs(path string, stat *Statfs_t) (err error) {
	1799	var _p0 *byte
	1800	_p0, err = BytePtrFromString(path)
	1801	if err != nil {
	1802	return
	1803	}
	1804	_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}

+1920

-1184

unix/zsyscall_darwin_amd64.go less more

0		// go run mksyscall.go -tags darwin,amd64 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
	0	// go run mksyscall.go -tags darwin,amd64,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_amd64.go
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3		// +build darwin,amd64
	3	// +build darwin,amd64,go1.12
4	4
5	5	package unix
6	6

14	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
15	15
16	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
17		r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	17	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
18	18	n = int(r0)
19	19	if e1 != 0 {
20	20	err = errnoErr(e1)

22	22	return
23	23	}
24	24
	25	func libc_getgroups_trampoline()
	26
	27	//go:linkname libc_getgroups libc_getgroups
	28	//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
	29
25	30	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
26	31
27	32	func setgroups(ngid int, gid *_Gid_t) (err error) {
28		_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
29		if e1 != 0 {
30		err = errnoErr(e1)
31		}
32		return
33		}
	33	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	34	if e1 != 0 {
	35	err = errnoErr(e1)
	36	}
	37	return
	38	}
	39
	40	func libc_setgroups_trampoline()
	41
	42	//go:linkname libc_setgroups libc_setgroups
	43	//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
34	44
35	45	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
36	46
37	47	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
38		r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	48	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
39	49	wpid = int(r0)
40	50	if e1 != 0 {
41	51	err = errnoErr(e1)

43	53	return
44	54	}
45	55
	56	func libc_wait4_trampoline()
	57
	58	//go:linkname libc_wait4 libc_wait4
	59	//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
	60
46	61	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
47	62
48	63	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
49		r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	64	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
50	65	fd = int(r0)
51	66	if e1 != 0 {
52	67	err = errnoErr(e1)

54	69	return
55	70	}
56	71
	72	func libc_accept_trampoline()
	73
	74	//go:linkname libc_accept libc_accept
	75	//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
	76
57	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
58	78
59	79	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
60		_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
61		if e1 != 0 {
62		err = errnoErr(e1)
63		}
64		return
65		}
	80	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	81	if e1 != 0 {
	82	err = errnoErr(e1)
	83	}
	84	return
	85	}
	86
	87	func libc_bind_trampoline()
	88
	89	//go:linkname libc_bind libc_bind
	90	//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
66	91
67	92	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
68	93
69	94	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
70		_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
71		if e1 != 0 {
72		err = errnoErr(e1)
73		}
74		return
75		}
	95	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	96	if e1 != 0 {
	97	err = errnoErr(e1)
	98	}
	99	return
	100	}
	101
	102	func libc_connect_trampoline()
	103
	104	//go:linkname libc_connect libc_connect
	105	//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
76	106
77	107	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
78	108
79	109	func socket(domain int, typ int, proto int) (fd int, err error) {
80		r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	110	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
81	111	fd = int(r0)
82	112	if e1 != 0 {
83	113	err = errnoErr(e1)

85	115	return
86	116	}
87	117
	118	func libc_socket_trampoline()
	119
	120	//go:linkname libc_socket libc_socket
	121	//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
	122
88	123	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
89	124
90	125	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
91		_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
92		if e1 != 0 {
93		err = errnoErr(e1)
94		}
95		return
96		}
	126	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	127	if e1 != 0 {
	128	err = errnoErr(e1)
	129	}
	130	return
	131	}
	132
	133	func libc_getsockopt_trampoline()
	134
	135	//go:linkname libc_getsockopt libc_getsockopt
	136	//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
97	137
98	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
99	139
100	140	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
101		_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
102		if e1 != 0 {
103		err = errnoErr(e1)
104		}
105		return
106		}
	141	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	func libc_setsockopt_trampoline()
	149
	150	//go:linkname libc_setsockopt libc_setsockopt
	151	//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
107	152
108	153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
109	154
110	155	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
111		_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
112		if e1 != 0 {
113		err = errnoErr(e1)
114		}
115		return
116		}
	156	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	157	if e1 != 0 {
	158	err = errnoErr(e1)
	159	}
	160	return
	161	}
	162
	163	func libc_getpeername_trampoline()
	164
	165	//go:linkname libc_getpeername libc_getpeername
	166	//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
117	167
118	168	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
119	169
120	170	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
121		_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
122		if e1 != 0 {
123		err = errnoErr(e1)
124		}
125		return
126		}
	171	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	172	if e1 != 0 {
	173	err = errnoErr(e1)
	174	}
	175	return
	176	}
	177
	178	func libc_getsockname_trampoline()
	179
	180	//go:linkname libc_getsockname libc_getsockname
	181	//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
127	182
128	183	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
129	184
130	185	func Shutdown(s int, how int) (err error) {
131		_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
132		if e1 != 0 {
133		err = errnoErr(e1)
134		}
135		return
136		}
	186	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
	187	if e1 != 0 {
	188	err = errnoErr(e1)
	189	}
	190	return
	191	}
	192
	193	func libc_shutdown_trampoline()
	194
	195	//go:linkname libc_shutdown libc_shutdown
	196	//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
137	197
138	198	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
139	199
140	200	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
141		_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
142		if e1 != 0 {
143		err = errnoErr(e1)
144		}
145		return
146		}
	201	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	202	if e1 != 0 {
	203	err = errnoErr(e1)
	204	}
	205	return
	206	}
	207
	208	func libc_socketpair_trampoline()
	209
	210	//go:linkname libc_socketpair libc_socketpair
	211	//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
147	212
148	213	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
149	214

154	219	} else {
155	220	_p0 = unsafe.Pointer(&_zero)
156	221	}
157		r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	222	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)))
158	223	n = int(r0)
159	224	if e1 != 0 {
160	225	err = errnoErr(e1)
161	226	}
162	227	return
163	228	}
	229
	230	func libc_recvfrom_trampoline()
	231
	232	//go:linkname libc_recvfrom libc_recvfrom
	233	//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
164	234
165	235	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
166	236

171	241	} else {
172	242	_p0 = unsafe.Pointer(&_zero)
173	243	}
174		_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
175		if e1 != 0 {
176		err = errnoErr(e1)
177		}
178		return
179		}
	244	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	245	if e1 != 0 {
	246	err = errnoErr(e1)
	247	}
	248	return
	249	}
	250
	251	func libc_sendto_trampoline()
	252
	253	//go:linkname libc_sendto libc_sendto
	254	//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
180	255
181	256	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
182	257
183	258	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
184		r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	259	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
185	260	n = int(r0)
186	261	if e1 != 0 {
187	262	err = errnoErr(e1)

189	264	return
190	265	}
191	266
	267	func libc_recvmsg_trampoline()
	268
	269	//go:linkname libc_recvmsg libc_recvmsg
	270	//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
	271
192	272	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
193	273
194	274	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
195		r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	275	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
196	276	n = int(r0)
197	277	if e1 != 0 {
198	278	err = errnoErr(e1)

200	280	return
201	281	}
202	282
	283	func libc_sendmsg_trampoline()
	284
	285	//go:linkname libc_sendmsg libc_sendmsg
	286	//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
	287
203	288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
204	289
205	290	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
206		r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	291	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
207	292	n = int(r0)
208	293	if e1 != 0 {
209	294	err = errnoErr(e1)
210	295	}
211	296	return
212	297	}
	298
	299	func libc_kevent_trampoline()
	300
	301	//go:linkname libc_kevent libc_kevent
	302	//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
213	303
214	304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
215	305

220	310	} else {
221	311	_p0 = unsafe.Pointer(&_zero)
222	312	}
223		_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
224		if e1 != 0 {
225		err = errnoErr(e1)
226		}
227		return
228		}
	313	_, _, 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))
	314	if e1 != 0 {
	315	err = errnoErr(e1)
	316	}
	317	return
	318	}
	319
	320	func libc___sysctl_trampoline()
	321
	322	//go:linkname libc___sysctl libc___sysctl
	323	//go:cgo_import_dynamic libc___sysctl __sysctl "/usr/lib/libSystem.B.dylib"
229	324
230	325	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
231	326

235	330	if err != nil {
236	331	return
237	332	}
238		_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
239		if e1 != 0 {
240		err = errnoErr(e1)
241		}
242		return
243		}
	333	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	334	if e1 != 0 {
	335	err = errnoErr(e1)
	336	}
	337	return
	338	}
	339
	340	func libc_utimes_trampoline()
	341
	342	//go:linkname libc_utimes libc_utimes
	343	//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
244	344
245	345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
246	346
247	347	func futimes(fd int, timeval *[2]Timeval) (err error) {
248		_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
249		if e1 != 0 {
250		err = errnoErr(e1)
251		}
252		return
253		}
	348	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	349	if e1 != 0 {
	350	err = errnoErr(e1)
	351	}
	352	return
	353	}
	354
	355	func libc_futimes_trampoline()
	356
	357	//go:linkname libc_futimes libc_futimes
	358	//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
254	359
255	360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
256	361
257	362	func fcntl(fd int, cmd int, arg int) (val int, err error) {
258		r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	363	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
259	364	val = int(r0)
260	365	if e1 != 0 {
261	366	err = errnoErr(e1)

263	368	return
264	369	}
265	370
	371	func libc_fcntl_trampoline()
	372
	373	//go:linkname libc_fcntl libc_fcntl
	374	//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
	375
266	376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
267	377
268	378	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
269		r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	379	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
270	380	n = int(r0)
271	381	if e1 != 0 {
272	382	err = errnoErr(e1)
273	383	}
274	384	return
275	385	}
	386
	387	func libc_poll_trampoline()
	388
	389	//go:linkname libc_poll libc_poll
	390	//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
276	391
277	392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
278	393

283	398	} else {
284	399	_p0 = unsafe.Pointer(&_zero)
285	400	}
286		_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
287		if e1 != 0 {
288		err = errnoErr(e1)
289		}
290		return
291		}
	401	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
	402	if e1 != 0 {
	403	err = errnoErr(e1)
	404	}
	405	return
	406	}
	407
	408	func libc_madvise_trampoline()
	409
	410	//go:linkname libc_madvise libc_madvise
	411	//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
292	412
293	413	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
294	414

299	419	} else {
300	420	_p0 = unsafe.Pointer(&_zero)
301	421	}
302		_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
303		if e1 != 0 {
304		err = errnoErr(e1)
305		}
306		return
307		}
	422	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	423	if e1 != 0 {
	424	err = errnoErr(e1)
	425	}
	426	return
	427	}
	428
	429	func libc_mlock_trampoline()
	430
	431	//go:linkname libc_mlock libc_mlock
	432	//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
308	433
309	434	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
310	435
311	436	func Mlockall(flags int) (err error) {
312		_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
313		if e1 != 0 {
314		err = errnoErr(e1)
315		}
316		return
317		}
	437	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
	438	if e1 != 0 {
	439	err = errnoErr(e1)
	440	}
	441	return
	442	}
	443
	444	func libc_mlockall_trampoline()
	445
	446	//go:linkname libc_mlockall libc_mlockall
	447	//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
318	448
319	449	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
320	450

325	455	} else {
326	456	_p0 = unsafe.Pointer(&_zero)
327	457	}
328		_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
329		if e1 != 0 {
330		err = errnoErr(e1)
331		}
332		return
333		}
	458	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
	459	if e1 != 0 {
	460	err = errnoErr(e1)
	461	}
	462	return
	463	}
	464
	465	func libc_mprotect_trampoline()
	466
	467	//go:linkname libc_mprotect libc_mprotect
	468	//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
334	469
335	470	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
336	471

341	476	} else {
342	477	_p0 = unsafe.Pointer(&_zero)
343	478	}
344		_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
345		if e1 != 0 {
346		err = errnoErr(e1)
347		}
348		return
349		}
	479	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
	480	if e1 != 0 {
	481	err = errnoErr(e1)
	482	}
	483	return
	484	}
	485
	486	func libc_msync_trampoline()
	487
	488	//go:linkname libc_msync libc_msync
	489	//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
350	490
351	491	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
352	492

357	497	} else {
358	498	_p0 = unsafe.Pointer(&_zero)
359	499	}
360		_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
361		if e1 != 0 {
362		err = errnoErr(e1)
363		}
364		return
365		}
	500	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	501	if e1 != 0 {
	502	err = errnoErr(e1)
	503	}
	504	return
	505	}
	506
	507	func libc_munlock_trampoline()
	508
	509	//go:linkname libc_munlock libc_munlock
	510	//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
366	511
367	512	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
368	513
369	514	func Munlockall() (err error) {
370		_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
371		if e1 != 0 {
372		err = errnoErr(e1)
373		}
374		return
375		}
	515	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
	516	if e1 != 0 {
	517	err = errnoErr(e1)
	518	}
	519	return
	520	}
	521
	522	func libc_munlockall_trampoline()
	523
	524	//go:linkname libc_munlockall libc_munlockall
	525	//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
376	526
377	527	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
378	528
379	529	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
380		_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
381		if e1 != 0 {
382		err = errnoErr(e1)
383		}
384		return
385		}
	530	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	531	if e1 != 0 {
	532	err = errnoErr(e1)
	533	}
	534	return
	535	}
	536
	537	func libc_ptrace_trampoline()
	538
	539	//go:linkname libc_ptrace libc_ptrace
	540	//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
	541
	542	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	543
	544	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	545	_, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	546	if e1 != 0 {
	547	err = errnoErr(e1)
	548	}
	549	return
	550	}
	551
	552	func libc_getattrlist_trampoline()
	553
	554	//go:linkname libc_getattrlist libc_getattrlist
	555	//go:cgo_import_dynamic libc_getattrlist getattrlist "/usr/lib/libSystem.B.dylib"
386	556
387	557	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
388	558
389	559	func pipe() (r int, w int, err error) {
390		r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	560	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
391	561	r = int(r0)
392	562	w = int(r1)
393	563	if e1 != 0 {

396	566	return
397	567	}
398	568
	569	func libc_pipe_trampoline()
	570
	571	//go:linkname libc_pipe libc_pipe
	572	//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
	573
399	574	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
400	575
401	576	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

409	584	if err != nil {
410	585	return
411	586	}
412		r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	587	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))
413	588	sz = int(r0)
414	589	if e1 != 0 {
415	590	err = errnoErr(e1)

417	592	return
418	593	}
419	594
	595	func libc_getxattr_trampoline()
	596
	597	//go:linkname libc_getxattr libc_getxattr
	598	//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
	599
420	600	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
421	601
422	602	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

425	605	if err != nil {
426	606	return
427	607	}
428		r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	608	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
429	609	sz = int(r0)
430	610	if e1 != 0 {
431	611	err = errnoErr(e1)
432	612	}
433	613	return
434	614	}
	615
	616	func libc_fgetxattr_trampoline()
	617
	618	//go:linkname libc_fgetxattr libc_fgetxattr
	619	//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
435	620
436	621	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
437	622

446	631	if err != nil {
447	632	return
448	633	}
449		_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
450		if e1 != 0 {
451		err = errnoErr(e1)
452		}
453		return
454		}
	634	_, _, 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))
	635	if e1 != 0 {
	636	err = errnoErr(e1)
	637	}
	638	return
	639	}
	640
	641	func libc_setxattr_trampoline()
	642
	643	//go:linkname libc_setxattr libc_setxattr
	644	//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
455	645
456	646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
457	647

461	651	if err != nil {
462	652	return
463	653	}
464		_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
465		if e1 != 0 {
466		err = errnoErr(e1)
467		}
468		return
469		}
	654	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	655	if e1 != 0 {
	656	err = errnoErr(e1)
	657	}
	658	return
	659	}
	660
	661	func libc_fsetxattr_trampoline()
	662
	663	//go:linkname libc_fsetxattr libc_fsetxattr
	664	//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
470	665
471	666	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
472	667

481	676	if err != nil {
482	677	return
483	678	}
484		_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
485		if e1 != 0 {
486		err = errnoErr(e1)
487		}
488		return
489		}
	679	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	680	if e1 != 0 {
	681	err = errnoErr(e1)
	682	}
	683	return
	684	}
	685
	686	func libc_removexattr_trampoline()
	687
	688	//go:linkname libc_removexattr libc_removexattr
	689	//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
490	690
491	691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
492	692

496	696	if err != nil {
497	697	return
498	698	}
499		_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
500		if e1 != 0 {
501		err = errnoErr(e1)
502		}
503		return
504		}
	699	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	700	if e1 != 0 {
	701	err = errnoErr(e1)
	702	}
	703	return
	704	}
	705
	706	func libc_fremovexattr_trampoline()
	707
	708	//go:linkname libc_fremovexattr libc_fremovexattr
	709	//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
505	710
506	711	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
507	712

511	716	if err != nil {
512	717	return
513	718	}
514		r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	719	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
515	720	sz = int(r0)
516	721	if e1 != 0 {
517	722	err = errnoErr(e1)

519	724	return
520	725	}
521	726
	727	func libc_listxattr_trampoline()
	728
	729	//go:linkname libc_listxattr libc_listxattr
	730	//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
	731
522	732	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
523	733
524	734	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
525		r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	735	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
526	736	sz = int(r0)
527	737	if e1 != 0 {
528	738	err = errnoErr(e1)

530	740	return
531	741	}
532	742
	743	func libc_flistxattr_trampoline()
	744
	745	//go:linkname libc_flistxattr libc_flistxattr
	746	//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
	747
	748	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	749
	750	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	751	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	752	if e1 != 0 {
	753	err = errnoErr(e1)
	754	}
	755	return
	756	}
	757
	758	func libc_setattrlist_trampoline()
	759
	760	//go:linkname libc_setattrlist libc_setattrlist
	761	//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
	762
533	763	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
534	764
535	765	func kill(pid int, signum int, posix int) (err error) {
536		_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
537		if e1 != 0 {
538		err = errnoErr(e1)
539		}
540		return
541		}
	766	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
	767	if e1 != 0 {
	768	err = errnoErr(e1)
	769	}
	770	return
	771	}
	772
	773	func libc_kill_trampoline()
	774
	775	//go:linkname libc_kill libc_kill
	776	//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
542	777
543	778	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
544	779
545	780	func ioctl(fd int, req uint, arg uintptr) (err error) {
546		_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
547		if e1 != 0 {
548		err = errnoErr(e1)
549		}
550		return
551		}
	781	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
	782	if e1 != 0 {
	783	err = errnoErr(e1)
	784	}
	785	return
	786	}
	787
	788	func libc_ioctl_trampoline()
	789
	790	//go:linkname libc_ioctl libc_ioctl
	791	//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
	792
	793	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	794
	795	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	796	_, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
	797	if e1 != 0 {
	798	err = errnoErr(e1)
	799	}
	800	return
	801	}
	802
	803	func libc_sendfile_trampoline()
	804
	805	//go:linkname libc_sendfile libc_sendfile
	806	//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
552	807
553	808	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
554	809

558	813	if err != nil {
559	814	return
560	815	}
561		_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
562		if e1 != 0 {
563		err = errnoErr(e1)
564		}
565		return
566		}
	816	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	817	if e1 != 0 {
	818	err = errnoErr(e1)
	819	}
	820	return
	821	}
	822
	823	func libc_access_trampoline()
	824
	825	//go:linkname libc_access libc_access
	826	//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
567	827
568	828	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
569	829
570	830	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
571		_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
572		if e1 != 0 {
573		err = errnoErr(e1)
574		}
575		return
576		}
	831	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	832	if e1 != 0 {
	833	err = errnoErr(e1)
	834	}
	835	return
	836	}
	837
	838	func libc_adjtime_trampoline()
	839
	840	//go:linkname libc_adjtime libc_adjtime
	841	//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
577	842
578	843	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
579	844

583	848	if err != nil {
584	849	return
585	850	}
586		_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
587		if e1 != 0 {
588		err = errnoErr(e1)
589		}
590		return
591		}
	851	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	852	if e1 != 0 {
	853	err = errnoErr(e1)
	854	}
	855	return
	856	}
	857
	858	func libc_chdir_trampoline()
	859
	860	//go:linkname libc_chdir libc_chdir
	861	//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
592	862
593	863	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
594	864

598	868	if err != nil {
599	869	return
600	870	}
601		_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
602		if e1 != 0 {
603		err = errnoErr(e1)
604		}
605		return
606		}
	871	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	872	if e1 != 0 {
	873	err = errnoErr(e1)
	874	}
	875	return
	876	}
	877
	878	func libc_chflags_trampoline()
	879
	880	//go:linkname libc_chflags libc_chflags
	881	//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
607	882
608	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
609	884

613	888	if err != nil {
614	889	return
615	890	}
616		_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
617		if e1 != 0 {
618		err = errnoErr(e1)
619		}
620		return
621		}
	891	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	892	if e1 != 0 {
	893	err = errnoErr(e1)
	894	}
	895	return
	896	}
	897
	898	func libc_chmod_trampoline()
	899
	900	//go:linkname libc_chmod libc_chmod
	901	//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
622	902
623	903	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
624	904

628	908	if err != nil {
629	909	return
630	910	}
631		_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
632		if e1 != 0 {
633		err = errnoErr(e1)
634		}
635		return
636		}
	911	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	912	if e1 != 0 {
	913	err = errnoErr(e1)
	914	}
	915	return
	916	}
	917
	918	func libc_chown_trampoline()
	919
	920	//go:linkname libc_chown libc_chown
	921	//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
637	922
638	923	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
639	924

643	928	if err != nil {
644	929	return
645	930	}
646		_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
647		if e1 != 0 {
648		err = errnoErr(e1)
649		}
650		return
651		}
	931	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	932	if e1 != 0 {
	933	err = errnoErr(e1)
	934	}
	935	return
	936	}
	937
	938	func libc_chroot_trampoline()
	939
	940	//go:linkname libc_chroot libc_chroot
	941	//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
652	942
653	943	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
654	944
655	945	func Close(fd int) (err error) {
656		_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
657		if e1 != 0 {
658		err = errnoErr(e1)
659		}
660		return
661		}
	946	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
	947	if e1 != 0 {
	948	err = errnoErr(e1)
	949	}
	950	return
	951	}
	952
	953	func libc_close_trampoline()
	954
	955	//go:linkname libc_close libc_close
	956	//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
662	957
663	958	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664	959
665	960	func Dup(fd int) (nfd int, err error) {
666		r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	961	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
667	962	nfd = int(r0)
668	963	if e1 != 0 {
669	964	err = errnoErr(e1)

671	966	return
672	967	}
673	968
	969	func libc_dup_trampoline()
	970
	971	//go:linkname libc_dup libc_dup
	972	//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
	973
674	974	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
675	975
676	976	func Dup2(from int, to int) (err error) {
677		_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
678		if e1 != 0 {
679		err = errnoErr(e1)
680		}
681		return
682		}
	977	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
	978	if e1 != 0 {
	979	err = errnoErr(e1)
	980	}
	981	return
	982	}
	983
	984	func libc_dup2_trampoline()
	985
	986	//go:linkname libc_dup2 libc_dup2
	987	//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
683	988
684	989	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
685	990

694	999	if err != nil {
695	1000	return
696	1001	}
697		_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
698		if e1 != 0 {
699		err = errnoErr(e1)
700		}
701		return
702		}
	1002	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	1003	if e1 != 0 {
	1004	err = errnoErr(e1)
	1005	}
	1006	return
	1007	}
	1008
	1009	func libc_exchangedata_trampoline()
	1010
	1011	//go:linkname libc_exchangedata libc_exchangedata
	1012	//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
703	1013
704	1014	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
705	1015
706	1016	func Exit(code int) {
707		Syscall(SYS_EXIT, uintptr(code), 0, 0)
708		return
709		}
	1017	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
	1018	return
	1019	}
	1020
	1021	func libc_exit_trampoline()
	1022
	1023	//go:linkname libc_exit libc_exit
	1024	//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
710	1025
711	1026	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
712	1027

716	1031	if err != nil {
717	1032	return
718	1033	}
719		_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
720		if e1 != 0 {
721		err = errnoErr(e1)
722		}
723		return
724		}
	1034	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1035	if e1 != 0 {
	1036	err = errnoErr(e1)
	1037	}
	1038	return
	1039	}
	1040
	1041	func libc_faccessat_trampoline()
	1042
	1043	//go:linkname libc_faccessat libc_faccessat
	1044	//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
725	1045
726	1046	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
727	1047
728	1048	func Fchdir(fd int) (err error) {
729		_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
730		if e1 != 0 {
731		err = errnoErr(e1)
732		}
733		return
734		}
	1049	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
	1050	if e1 != 0 {
	1051	err = errnoErr(e1)
	1052	}
	1053	return
	1054	}
	1055
	1056	func libc_fchdir_trampoline()
	1057
	1058	//go:linkname libc_fchdir libc_fchdir
	1059	//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
735	1060
736	1061	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
737	1062
738	1063	func Fchflags(fd int, flags int) (err error) {
739		_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
740		if e1 != 0 {
741		err = errnoErr(e1)
742		}
743		return
744		}
	1064	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
	1065	if e1 != 0 {
	1066	err = errnoErr(e1)
	1067	}
	1068	return
	1069	}
	1070
	1071	func libc_fchflags_trampoline()
	1072
	1073	//go:linkname libc_fchflags libc_fchflags
	1074	//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
745	1075
746	1076	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
747	1077
748	1078	func Fchmod(fd int, mode uint32) (err error) {
749		_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
750		if e1 != 0 {
751		err = errnoErr(e1)
752		}
753		return
754		}
	1079	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
	1080	if e1 != 0 {
	1081	err = errnoErr(e1)
	1082	}
	1083	return
	1084	}
	1085
	1086	func libc_fchmod_trampoline()
	1087
	1088	//go:linkname libc_fchmod libc_fchmod
	1089	//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
755	1090
756	1091	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
757	1092

761	1096	if err != nil {
762	1097	return
763	1098	}
764		_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
765		if e1 != 0 {
766		err = errnoErr(e1)
767		}
768		return
769		}
	1099	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1100	if e1 != 0 {
	1101	err = errnoErr(e1)
	1102	}
	1103	return
	1104	}
	1105
	1106	func libc_fchmodat_trampoline()
	1107
	1108	//go:linkname libc_fchmodat libc_fchmodat
	1109	//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
770	1110
771	1111	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
772	1112
773	1113	func Fchown(fd int, uid int, gid int) (err error) {
774		_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
775		if e1 != 0 {
776		err = errnoErr(e1)
777		}
778		return
779		}
	1114	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
	1115	if e1 != 0 {
	1116	err = errnoErr(e1)
	1117	}
	1118	return
	1119	}
	1120
	1121	func libc_fchown_trampoline()
	1122
	1123	//go:linkname libc_fchown libc_fchown
	1124	//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
780	1125
781	1126	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
782	1127

786	1131	if err != nil {
787	1132	return
788	1133	}
789		_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
790		if e1 != 0 {
791		err = errnoErr(e1)
792		}
793		return
794		}
	1134	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	1135	if e1 != 0 {
	1136	err = errnoErr(e1)
	1137	}
	1138	return
	1139	}
	1140
	1141	func libc_fchownat_trampoline()
	1142
	1143	//go:linkname libc_fchownat libc_fchownat
	1144	//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
795	1145
796	1146	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
797	1147
798	1148	func Flock(fd int, how int) (err error) {
799		_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
800		if e1 != 0 {
801		err = errnoErr(e1)
802		}
803		return
804		}
	1149	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
	1150	if e1 != 0 {
	1151	err = errnoErr(e1)
	1152	}
	1153	return
	1154	}
	1155
	1156	func libc_flock_trampoline()
	1157
	1158	//go:linkname libc_flock libc_flock
	1159	//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
805	1160
806	1161	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
807	1162
808	1163	func Fpathconf(fd int, name int) (val int, err error) {
809		r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	1164	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
810	1165	val = int(r0)
811	1166	if e1 != 0 {
812	1167	err = errnoErr(e1)

814	1169	return
815	1170	}
816	1171
	1172	func libc_fpathconf_trampoline()
	1173
	1174	//go:linkname libc_fpathconf libc_fpathconf
	1175	//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
	1176
	1177	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1178
	1179	func Fsync(fd int) (err error) {
	1180	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
	1181	if e1 != 0 {
	1182	err = errnoErr(e1)
	1183	}
	1184	return
	1185	}
	1186
	1187	func libc_fsync_trampoline()
	1188
	1189	//go:linkname libc_fsync libc_fsync
	1190	//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
	1191
	1192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1193
	1194	func Ftruncate(fd int, length int64) (err error) {
	1195	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
	1196	if e1 != 0 {
	1197	err = errnoErr(e1)
	1198	}
	1199	return
	1200	}
	1201
	1202	func libc_ftruncate_trampoline()
	1203
	1204	//go:linkname libc_ftruncate libc_ftruncate
	1205	//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
	1206
	1207	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1208
	1209	func Getdtablesize() (size int) {
	1210	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
	1211	size = int(r0)
	1212	return
	1213	}
	1214
	1215	func libc_getdtablesize_trampoline()
	1216
	1217	//go:linkname libc_getdtablesize libc_getdtablesize
	1218	//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
	1219
	1220	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1221
	1222	func Getegid() (egid int) {
	1223	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
	1224	egid = int(r0)
	1225	return
	1226	}
	1227
	1228	func libc_getegid_trampoline()
	1229
	1230	//go:linkname libc_getegid libc_getegid
	1231	//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
	1232
	1233	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1234
	1235	func Geteuid() (uid int) {
	1236	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
	1237	uid = int(r0)
	1238	return
	1239	}
	1240
	1241	func libc_geteuid_trampoline()
	1242
	1243	//go:linkname libc_geteuid libc_geteuid
	1244	//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
	1245
	1246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1247
	1248	func Getgid() (gid int) {
	1249	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
	1250	gid = int(r0)
	1251	return
	1252	}
	1253
	1254	func libc_getgid_trampoline()
	1255
	1256	//go:linkname libc_getgid libc_getgid
	1257	//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
	1258
	1259	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1260
	1261	func Getpgid(pid int) (pgid int, err error) {
	1262	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
	1263	pgid = int(r0)
	1264	if e1 != 0 {
	1265	err = errnoErr(e1)
	1266	}
	1267	return
	1268	}
	1269
	1270	func libc_getpgid_trampoline()
	1271
	1272	//go:linkname libc_getpgid libc_getpgid
	1273	//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
	1274
	1275	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1276
	1277	func Getpgrp() (pgrp int) {
	1278	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
	1279	pgrp = int(r0)
	1280	return
	1281	}
	1282
	1283	func libc_getpgrp_trampoline()
	1284
	1285	//go:linkname libc_getpgrp libc_getpgrp
	1286	//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
	1287
	1288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1289
	1290	func Getpid() (pid int) {
	1291	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
	1292	pid = int(r0)
	1293	return
	1294	}
	1295
	1296	func libc_getpid_trampoline()
	1297
	1298	//go:linkname libc_getpid libc_getpid
	1299	//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
	1300
	1301	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1302
	1303	func Getppid() (ppid int) {
	1304	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
	1305	ppid = int(r0)
	1306	return
	1307	}
	1308
	1309	func libc_getppid_trampoline()
	1310
	1311	//go:linkname libc_getppid libc_getppid
	1312	//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
	1313
	1314	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1315
	1316	func Getpriority(which int, who int) (prio int, err error) {
	1317	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
	1318	prio = int(r0)
	1319	if e1 != 0 {
	1320	err = errnoErr(e1)
	1321	}
	1322	return
	1323	}
	1324
	1325	func libc_getpriority_trampoline()
	1326
	1327	//go:linkname libc_getpriority libc_getpriority
	1328	//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
	1329
	1330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1331
	1332	func Getrlimit(which int, lim *Rlimit) (err error) {
	1333	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1334	if e1 != 0 {
	1335	err = errnoErr(e1)
	1336	}
	1337	return
	1338	}
	1339
	1340	func libc_getrlimit_trampoline()
	1341
	1342	//go:linkname libc_getrlimit libc_getrlimit
	1343	//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
	1344
	1345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1346
	1347	func Getrusage(who int, rusage *Rusage) (err error) {
	1348	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	1349	if e1 != 0 {
	1350	err = errnoErr(e1)
	1351	}
	1352	return
	1353	}
	1354
	1355	func libc_getrusage_trampoline()
	1356
	1357	//go:linkname libc_getrusage libc_getrusage
	1358	//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
	1359
	1360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1361
	1362	func Getsid(pid int) (sid int, err error) {
	1363	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
	1364	sid = int(r0)
	1365	if e1 != 0 {
	1366	err = errnoErr(e1)
	1367	}
	1368	return
	1369	}
	1370
	1371	func libc_getsid_trampoline()
	1372
	1373	//go:linkname libc_getsid libc_getsid
	1374	//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
	1375
	1376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1377
	1378	func Getuid() (uid int) {
	1379	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
	1380	uid = int(r0)
	1381	return
	1382	}
	1383
	1384	func libc_getuid_trampoline()
	1385
	1386	//go:linkname libc_getuid libc_getuid
	1387	//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
	1388
	1389	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1390
	1391	func Issetugid() (tainted bool) {
	1392	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
	1393	tainted = bool(r0 != 0)
	1394	return
	1395	}
	1396
	1397	func libc_issetugid_trampoline()
	1398
	1399	//go:linkname libc_issetugid libc_issetugid
	1400	//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
	1401
	1402	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1403
	1404	func Kqueue() (fd int, err error) {
	1405	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
	1406	fd = int(r0)
	1407	if e1 != 0 {
	1408	err = errnoErr(e1)
	1409	}
	1410	return
	1411	}
	1412
	1413	func libc_kqueue_trampoline()
	1414
	1415	//go:linkname libc_kqueue libc_kqueue
	1416	//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
	1417
	1418	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1419
	1420	func Lchown(path string, uid int, gid int) (err error) {
	1421	var _p0 *byte
	1422	_p0, err = BytePtrFromString(path)
	1423	if err != nil {
	1424	return
	1425	}
	1426	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1427	if e1 != 0 {
	1428	err = errnoErr(e1)
	1429	}
	1430	return
	1431	}
	1432
	1433	func libc_lchown_trampoline()
	1434
	1435	//go:linkname libc_lchown libc_lchown
	1436	//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
	1437
	1438	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1439
	1440	func Link(path string, link string) (err error) {
	1441	var _p0 *byte
	1442	_p0, err = BytePtrFromString(path)
	1443	if err != nil {
	1444	return
	1445	}
	1446	var _p1 *byte
	1447	_p1, err = BytePtrFromString(link)
	1448	if err != nil {
	1449	return
	1450	}
	1451	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1452	if e1 != 0 {
	1453	err = errnoErr(e1)
	1454	}
	1455	return
	1456	}
	1457
	1458	func libc_link_trampoline()
	1459
	1460	//go:linkname libc_link libc_link
	1461	//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
	1462
	1463	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1464
	1465	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1466	var _p0 *byte
	1467	_p0, err = BytePtrFromString(path)
	1468	if err != nil {
	1469	return
	1470	}
	1471	var _p1 *byte
	1472	_p1, err = BytePtrFromString(link)
	1473	if err != nil {
	1474	return
	1475	}
	1476	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1477	if e1 != 0 {
	1478	err = errnoErr(e1)
	1479	}
	1480	return
	1481	}
	1482
	1483	func libc_linkat_trampoline()
	1484
	1485	//go:linkname libc_linkat libc_linkat
	1486	//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Listen(s int, backlog int) (err error) {
	1491	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	func libc_listen_trampoline()
	1499
	1500	//go:linkname libc_listen libc_listen
	1501	//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
	1502
	1503	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1504
	1505	func Mkdir(path string, mode uint32) (err error) {
	1506	var _p0 *byte
	1507	_p0, err = BytePtrFromString(path)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	func libc_mkdir_trampoline()
	1519
	1520	//go:linkname libc_mkdir libc_mkdir
	1521	//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
	1522
	1523	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1524
	1525	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1526	var _p0 *byte
	1527	_p0, err = BytePtrFromString(path)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	func libc_mkdirat_trampoline()
	1539
	1540	//go:linkname libc_mkdirat libc_mkdirat
	1541	//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
	1542
	1543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1544
	1545	func Mkfifo(path string, mode uint32) (err error) {
	1546	var _p0 *byte
	1547	_p0, err = BytePtrFromString(path)
	1548	if err != nil {
	1549	return
	1550	}
	1551	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1552	if e1 != 0 {
	1553	err = errnoErr(e1)
	1554	}
	1555	return
	1556	}
	1557
	1558	func libc_mkfifo_trampoline()
	1559
	1560	//go:linkname libc_mkfifo libc_mkfifo
	1561	//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Mknod(path string, mode uint32, dev int) (err error) {
	1566	var _p0 *byte
	1567	_p0, err = BytePtrFromString(path)
	1568	if err != nil {
	1569	return
	1570	}
	1571	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1572	if e1 != 0 {
	1573	err = errnoErr(e1)
	1574	}
	1575	return
	1576	}
	1577
	1578	func libc_mknod_trampoline()
	1579
	1580	//go:linkname libc_mknod libc_mknod
	1581	//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
	1582
	1583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1584
	1585	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1586	var _p0 *byte
	1587	_p0, err = BytePtrFromString(path)
	1588	if err != nil {
	1589	return
	1590	}
	1591	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1592	fd = int(r0)
	1593	if e1 != 0 {
	1594	err = errnoErr(e1)
	1595	}
	1596	return
	1597	}
	1598
	1599	func libc_open_trampoline()
	1600
	1601	//go:linkname libc_open libc_open
	1602	//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
	1603
	1604	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1605
	1606	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1607	var _p0 *byte
	1608	_p0, err = BytePtrFromString(path)
	1609	if err != nil {
	1610	return
	1611	}
	1612	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1613	fd = int(r0)
	1614	if e1 != 0 {
	1615	err = errnoErr(e1)
	1616	}
	1617	return
	1618	}
	1619
	1620	func libc_openat_trampoline()
	1621
	1622	//go:linkname libc_openat libc_openat
	1623	//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
	1624
	1625	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1626
	1627	func Pathconf(path string, name int) (val int, err error) {
	1628	var _p0 *byte
	1629	_p0, err = BytePtrFromString(path)
	1630	if err != nil {
	1631	return
	1632	}
	1633	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1634	val = int(r0)
	1635	if e1 != 0 {
	1636	err = errnoErr(e1)
	1637	}
	1638	return
	1639	}
	1640
	1641	func libc_pathconf_trampoline()
	1642
	1643	//go:linkname libc_pathconf libc_pathconf
	1644	//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
	1645
	1646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1647
	1648	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1649	var _p0 unsafe.Pointer
	1650	if len(p) > 0 {
	1651	_p0 = unsafe.Pointer(&p[0])
	1652	} else {
	1653	_p0 = unsafe.Pointer(&_zero)
	1654	}
	1655	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1656	n = int(r0)
	1657	if e1 != 0 {
	1658	err = errnoErr(e1)
	1659	}
	1660	return
	1661	}
	1662
	1663	func libc_pread_trampoline()
	1664
	1665	//go:linkname libc_pread libc_pread
	1666	//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
	1667
	1668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1669
	1670	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1671	var _p0 unsafe.Pointer
	1672	if len(p) > 0 {
	1673	_p0 = unsafe.Pointer(&p[0])
	1674	} else {
	1675	_p0 = unsafe.Pointer(&_zero)
	1676	}
	1677	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1678	n = int(r0)
	1679	if e1 != 0 {
	1680	err = errnoErr(e1)
	1681	}
	1682	return
	1683	}
	1684
	1685	func libc_pwrite_trampoline()
	1686
	1687	//go:linkname libc_pwrite libc_pwrite
	1688	//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
	1689
	1690	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1691
	1692	func read(fd int, p []byte) (n int, err error) {
	1693	var _p0 unsafe.Pointer
	1694	if len(p) > 0 {
	1695	_p0 = unsafe.Pointer(&p[0])
	1696	} else {
	1697	_p0 = unsafe.Pointer(&_zero)
	1698	}
	1699	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1700	n = int(r0)
	1701	if e1 != 0 {
	1702	err = errnoErr(e1)
	1703	}
	1704	return
	1705	}
	1706
	1707	func libc_read_trampoline()
	1708
	1709	//go:linkname libc_read libc_read
	1710	//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
	1711
	1712	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1713
	1714	func Readlink(path string, buf []byte) (n int, err error) {
	1715	var _p0 *byte
	1716	_p0, err = BytePtrFromString(path)
	1717	if err != nil {
	1718	return
	1719	}
	1720	var _p1 unsafe.Pointer
	1721	if len(buf) > 0 {
	1722	_p1 = unsafe.Pointer(&buf[0])
	1723	} else {
	1724	_p1 = unsafe.Pointer(&_zero)
	1725	}
	1726	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1727	n = int(r0)
	1728	if e1 != 0 {
	1729	err = errnoErr(e1)
	1730	}
	1731	return
	1732	}
	1733
	1734	func libc_readlink_trampoline()
	1735
	1736	//go:linkname libc_readlink libc_readlink
	1737	//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
	1738
	1739	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1740
	1741	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1742	var _p0 *byte
	1743	_p0, err = BytePtrFromString(path)
	1744	if err != nil {
	1745	return
	1746	}
	1747	var _p1 unsafe.Pointer
	1748	if len(buf) > 0 {
	1749	_p1 = unsafe.Pointer(&buf[0])
	1750	} else {
	1751	_p1 = unsafe.Pointer(&_zero)
	1752	}
	1753	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1754	n = int(r0)
	1755	if e1 != 0 {
	1756	err = errnoErr(e1)
	1757	}
	1758	return
	1759	}
	1760
	1761	func libc_readlinkat_trampoline()
	1762
	1763	//go:linkname libc_readlinkat libc_readlinkat
	1764	//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
	1765
	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1767
	1768	func Rename(from string, to string) (err error) {
	1769	var _p0 *byte
	1770	_p0, err = BytePtrFromString(from)
	1771	if err != nil {
	1772	return
	1773	}
	1774	var _p1 *byte
	1775	_p1, err = BytePtrFromString(to)
	1776	if err != nil {
	1777	return
	1778	}
	1779	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1780	if e1 != 0 {
	1781	err = errnoErr(e1)
	1782	}
	1783	return
	1784	}
	1785
	1786	func libc_rename_trampoline()
	1787
	1788	//go:linkname libc_rename libc_rename
	1789	//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
	1790
	1791	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1792
	1793	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1794	var _p0 *byte
	1795	_p0, err = BytePtrFromString(from)
	1796	if err != nil {
	1797	return
	1798	}
	1799	var _p1 *byte
	1800	_p1, err = BytePtrFromString(to)
	1801	if err != nil {
	1802	return
	1803	}
	1804	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}
	1810
	1811	func libc_renameat_trampoline()
	1812
	1813	//go:linkname libc_renameat libc_renameat
	1814	//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
	1815
	1816	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1817
	1818	func Revoke(path string) (err error) {
	1819	var _p0 *byte
	1820	_p0, err = BytePtrFromString(path)
	1821	if err != nil {
	1822	return
	1823	}
	1824	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1825	if e1 != 0 {
	1826	err = errnoErr(e1)
	1827	}
	1828	return
	1829	}
	1830
	1831	func libc_revoke_trampoline()
	1832
	1833	//go:linkname libc_revoke libc_revoke
	1834	//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
	1835
	1836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1837
	1838	func Rmdir(path string) (err error) {
	1839	var _p0 *byte
	1840	_p0, err = BytePtrFromString(path)
	1841	if err != nil {
	1842	return
	1843	}
	1844	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1845	if e1 != 0 {
	1846	err = errnoErr(e1)
	1847	}
	1848	return
	1849	}
	1850
	1851	func libc_rmdir_trampoline()
	1852
	1853	//go:linkname libc_rmdir libc_rmdir
	1854	//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
	1855
	1856	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1857
	1858	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1859	r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
	1860	newoffset = int64(r0)
	1861	if e1 != 0 {
	1862	err = errnoErr(e1)
	1863	}
	1864	return
	1865	}
	1866
	1867	func libc_lseek_trampoline()
	1868
	1869	//go:linkname libc_lseek libc_lseek
	1870	//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
	1871
	1872	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1873
	1874	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1875	_, _, 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)
	1876	if e1 != 0 {
	1877	err = errnoErr(e1)
	1878	}
	1879	return
	1880	}
	1881
	1882	func libc_select_trampoline()
	1883
	1884	//go:linkname libc_select libc_select
	1885	//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
	1886
	1887	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1888
	1889	func Setegid(egid int) (err error) {
	1890	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
	1891	if e1 != 0 {
	1892	err = errnoErr(e1)
	1893	}
	1894	return
	1895	}
	1896
	1897	func libc_setegid_trampoline()
	1898
	1899	//go:linkname libc_setegid libc_setegid
	1900	//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
	1901
	1902	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1903
	1904	func Seteuid(euid int) (err error) {
	1905	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
	1906	if e1 != 0 {
	1907	err = errnoErr(e1)
	1908	}
	1909	return
	1910	}
	1911
	1912	func libc_seteuid_trampoline()
	1913
	1914	//go:linkname libc_seteuid libc_seteuid
	1915	//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
	1916
	1917	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1918
	1919	func Setgid(gid int) (err error) {
	1920	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
	1921	if e1 != 0 {
	1922	err = errnoErr(e1)
	1923	}
	1924	return
	1925	}
	1926
	1927	func libc_setgid_trampoline()
	1928
	1929	//go:linkname libc_setgid libc_setgid
	1930	//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
	1931
	1932	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1933
	1934	func Setlogin(name string) (err error) {
	1935	var _p0 *byte
	1936	_p0, err = BytePtrFromString(name)
	1937	if err != nil {
	1938	return
	1939	}
	1940	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1941	if e1 != 0 {
	1942	err = errnoErr(e1)
	1943	}
	1944	return
	1945	}
	1946
	1947	func libc_setlogin_trampoline()
	1948
	1949	//go:linkname libc_setlogin libc_setlogin
	1950	//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
	1951
	1952	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1953
	1954	func Setpgid(pid int, pgid int) (err error) {
	1955	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
	1956	if e1 != 0 {
	1957	err = errnoErr(e1)
	1958	}
	1959	return
	1960	}
	1961
	1962	func libc_setpgid_trampoline()
	1963
	1964	//go:linkname libc_setpgid libc_setpgid
	1965	//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
	1966
	1967	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1968
	1969	func Setpriority(which int, who int, prio int) (err error) {
	1970	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
	1971	if e1 != 0 {
	1972	err = errnoErr(e1)
	1973	}
	1974	return
	1975	}
	1976
	1977	func libc_setpriority_trampoline()
	1978
	1979	//go:linkname libc_setpriority libc_setpriority
	1980	//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
	1981
	1982	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1983
	1984	func Setprivexec(flag int) (err error) {
	1985	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
	1986	if e1 != 0 {
	1987	err = errnoErr(e1)
	1988	}
	1989	return
	1990	}
	1991
	1992	func libc_setprivexec_trampoline()
	1993
	1994	//go:linkname libc_setprivexec libc_setprivexec
	1995	//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
	1996
	1997	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1998
	1999	func Setregid(rgid int, egid int) (err error) {
	2000	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
	2001	if e1 != 0 {
	2002	err = errnoErr(e1)
	2003	}
	2004	return
	2005	}
	2006
	2007	func libc_setregid_trampoline()
	2008
	2009	//go:linkname libc_setregid libc_setregid
	2010	//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
	2011
	2012	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2013
	2014	func Setreuid(ruid int, euid int) (err error) {
	2015	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
	2016	if e1 != 0 {
	2017	err = errnoErr(e1)
	2018	}
	2019	return
	2020	}
	2021
	2022	func libc_setreuid_trampoline()
	2023
	2024	//go:linkname libc_setreuid libc_setreuid
	2025	//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
	2026
	2027	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2028
	2029	func Setrlimit(which int, lim *Rlimit) (err error) {
	2030	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	2031	if e1 != 0 {
	2032	err = errnoErr(e1)
	2033	}
	2034	return
	2035	}
	2036
	2037	func libc_setrlimit_trampoline()
	2038
	2039	//go:linkname libc_setrlimit libc_setrlimit
	2040	//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
	2041
	2042	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2043
	2044	func Setsid() (pid int, err error) {
	2045	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
	2046	pid = int(r0)
	2047	if e1 != 0 {
	2048	err = errnoErr(e1)
	2049	}
	2050	return
	2051	}
	2052
	2053	func libc_setsid_trampoline()
	2054
	2055	//go:linkname libc_setsid libc_setsid
	2056	//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
	2057
	2058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2059
	2060	func Settimeofday(tp *Timeval) (err error) {
	2061	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2062	if e1 != 0 {
	2063	err = errnoErr(e1)
	2064	}
	2065	return
	2066	}
	2067
	2068	func libc_settimeofday_trampoline()
	2069
	2070	//go:linkname libc_settimeofday libc_settimeofday
	2071	//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
	2072
	2073	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2074
	2075	func Setuid(uid int) (err error) {
	2076	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
	2077	if e1 != 0 {
	2078	err = errnoErr(e1)
	2079	}
	2080	return
	2081	}
	2082
	2083	func libc_setuid_trampoline()
	2084
	2085	//go:linkname libc_setuid libc_setuid
	2086	//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
	2087
	2088	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2089
	2090	func Symlink(path string, link string) (err error) {
	2091	var _p0 *byte
	2092	_p0, err = BytePtrFromString(path)
	2093	if err != nil {
	2094	return
	2095	}
	2096	var _p1 *byte
	2097	_p1, err = BytePtrFromString(link)
	2098	if err != nil {
	2099	return
	2100	}
	2101	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	2102	if e1 != 0 {
	2103	err = errnoErr(e1)
	2104	}
	2105	return
	2106	}
	2107
	2108	func libc_symlink_trampoline()
	2109
	2110	//go:linkname libc_symlink libc_symlink
	2111	//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
	2112
	2113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2114
	2115	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	2116	var _p0 *byte
	2117	_p0, err = BytePtrFromString(oldpath)
	2118	if err != nil {
	2119	return
	2120	}
	2121	var _p1 *byte
	2122	_p1, err = BytePtrFromString(newpath)
	2123	if err != nil {
	2124	return
	2125	}
	2126	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	2127	if e1 != 0 {
	2128	err = errnoErr(e1)
	2129	}
	2130	return
	2131	}
	2132
	2133	func libc_symlinkat_trampoline()
	2134
	2135	//go:linkname libc_symlinkat libc_symlinkat
	2136	//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
	2137
	2138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2139
	2140	func Sync() (err error) {
	2141	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
	2142	if e1 != 0 {
	2143	err = errnoErr(e1)
	2144	}
	2145	return
	2146	}
	2147
	2148	func libc_sync_trampoline()
	2149
	2150	//go:linkname libc_sync libc_sync
	2151	//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
	2152
	2153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2154
	2155	func Truncate(path string, length int64) (err error) {
	2156	var _p0 *byte
	2157	_p0, err = BytePtrFromString(path)
	2158	if err != nil {
	2159	return
	2160	}
	2161	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
	2162	if e1 != 0 {
	2163	err = errnoErr(e1)
	2164	}
	2165	return
	2166	}
	2167
	2168	func libc_truncate_trampoline()
	2169
	2170	//go:linkname libc_truncate libc_truncate
	2171	//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
	2172
	2173	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2174
	2175	func Umask(newmask int) (oldmask int) {
	2176	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
	2177	oldmask = int(r0)
	2178	return
	2179	}
	2180
	2181	func libc_umask_trampoline()
	2182
	2183	//go:linkname libc_umask libc_umask
	2184	//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
	2185
	2186	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2187
	2188	func Undelete(path string) (err error) {
	2189	var _p0 *byte
	2190	_p0, err = BytePtrFromString(path)
	2191	if err != nil {
	2192	return
	2193	}
	2194	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2195	if e1 != 0 {
	2196	err = errnoErr(e1)
	2197	}
	2198	return
	2199	}
	2200
	2201	func libc_undelete_trampoline()
	2202
	2203	//go:linkname libc_undelete libc_undelete
	2204	//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
	2205
	2206	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2207
	2208	func Unlink(path string) (err error) {
	2209	var _p0 *byte
	2210	_p0, err = BytePtrFromString(path)
	2211	if err != nil {
	2212	return
	2213	}
	2214	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2215	if e1 != 0 {
	2216	err = errnoErr(e1)
	2217	}
	2218	return
	2219	}
	2220
	2221	func libc_unlink_trampoline()
	2222
	2223	//go:linkname libc_unlink libc_unlink
	2224	//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
	2225
	2226	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2227
	2228	func Unlinkat(dirfd int, path string, flags int) (err error) {
	2229	var _p0 *byte
	2230	_p0, err = BytePtrFromString(path)
	2231	if err != nil {
	2232	return
	2233	}
	2234	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	2235	if e1 != 0 {
	2236	err = errnoErr(e1)
	2237	}
	2238	return
	2239	}
	2240
	2241	func libc_unlinkat_trampoline()
	2242
	2243	//go:linkname libc_unlinkat libc_unlinkat
	2244	//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
	2245
	2246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2247
	2248	func Unmount(path string, flags int) (err error) {
	2249	var _p0 *byte
	2250	_p0, err = BytePtrFromString(path)
	2251	if err != nil {
	2252	return
	2253	}
	2254	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	2255	if e1 != 0 {
	2256	err = errnoErr(e1)
	2257	}
	2258	return
	2259	}
	2260
	2261	func libc_unmount_trampoline()
	2262
	2263	//go:linkname libc_unmount libc_unmount
	2264	//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
	2265
	2266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2267
	2268	func write(fd int, p []byte) (n int, err error) {
	2269	var _p0 unsafe.Pointer
	2270	if len(p) > 0 {
	2271	_p0 = unsafe.Pointer(&p[0])
	2272	} else {
	2273	_p0 = unsafe.Pointer(&_zero)
	2274	}
	2275	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
	2276	n = int(r0)
	2277	if e1 != 0 {
	2278	err = errnoErr(e1)
	2279	}
	2280	return
	2281	}
	2282
	2283	func libc_write_trampoline()
	2284
	2285	//go:linkname libc_write libc_write
	2286	//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
	2287
	2288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2289
	2290	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	2291	r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
	2292	ret = uintptr(r0)
	2293	if e1 != 0 {
	2294	err = errnoErr(e1)
	2295	}
	2296	return
	2297	}
	2298
	2299	func libc_mmap_trampoline()
	2300
	2301	//go:linkname libc_mmap libc_mmap
	2302	//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
	2303
	2304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2305
	2306	func munmap(addr uintptr, length uintptr) (err error) {
	2307	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
	2308	if e1 != 0 {
	2309	err = errnoErr(e1)
	2310	}
	2311	return
	2312	}
	2313
	2314	func libc_munmap_trampoline()
	2315
	2316	//go:linkname libc_munmap libc_munmap
	2317	//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
	2318
	2319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2320
	2321	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	2322	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2323	n = int(r0)
	2324	if e1 != 0 {
	2325	err = errnoErr(e1)
	2326	}
	2327	return
	2328	}
	2329
	2330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2331
	2332	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	2333	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2334	n = int(r0)
	2335	if e1 != 0 {
	2336	err = errnoErr(e1)
	2337	}
	2338	return
	2339	}
	2340
	2341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2342
	2343	func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	2344	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2345	sec = int64(r0)
	2346	usec = int32(r1)
	2347	if e1 != 0 {
	2348	err = errnoErr(e1)
	2349	}
	2350	return
	2351	}
	2352
	2353	func libc_gettimeofday_trampoline()
	2354
	2355	//go:linkname libc_gettimeofday libc_gettimeofday
	2356	//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
	2357
817	2358	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
818	2359
819	2360	func Fstat(fd int, stat *Stat_t) (err error) {
820		_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
821		if e1 != 0 {
822		err = errnoErr(e1)
823		}
824		return
825		}
	2361	_, _, e1 := syscall_syscall(funcPC(libc_fstat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2362	if e1 != 0 {
	2363	err = errnoErr(e1)
	2364	}
	2365	return
	2366	}
	2367
	2368	func libc_fstat64_trampoline()
	2369
	2370	//go:linkname libc_fstat64 libc_fstat64
	2371	//go:cgo_import_dynamic libc_fstat64 fstat64 "/usr/lib/libSystem.B.dylib"
826	2372
827	2373	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
828	2374

832	2378	if err != nil {
833	2379	return
834	2380	}
835		_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
836		if e1 != 0 {
837		err = errnoErr(e1)
838		}
839		return
840		}
	2381	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	2382	if e1 != 0 {
	2383	err = errnoErr(e1)
	2384	}
	2385	return
	2386	}
	2387
	2388	func libc_fstatat64_trampoline()
	2389
	2390	//go:linkname libc_fstatat64 libc_fstatat64
	2391	//go:cgo_import_dynamic libc_fstatat64 fstatat64 "/usr/lib/libSystem.B.dylib"
841	2392
842	2393	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
843	2394
844	2395	func Fstatfs(fd int, stat *Statfs_t) (err error) {
845		_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
846		if e1 != 0 {
847		err = errnoErr(e1)
848		}
849		return
850		}
851
852		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
853
854		func Fsync(fd int) (err error) {
855		_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
856		if e1 != 0 {
857		err = errnoErr(e1)
858		}
859		return
860		}
861
862		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
863
864		func Ftruncate(fd int, length int64) (err error) {
865		_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
866		if e1 != 0 {
867		err = errnoErr(e1)
868		}
869		return
870		}
	2396	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs64_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2397	if e1 != 0 {
	2398	err = errnoErr(e1)
	2399	}
	2400	return
	2401	}
	2402
	2403	func libc_fstatfs64_trampoline()
	2404
	2405	//go:linkname libc_fstatfs64 libc_fstatfs64
	2406	//go:cgo_import_dynamic libc_fstatfs64 fstatfs64 "/usr/lib/libSystem.B.dylib"
871	2407
872	2408	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
873	2409

878	2414	} else {
879	2415	_p0 = unsafe.Pointer(&_zero)
880	2416	}
881		r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
	2417	r0, _, e1 := syscall_syscall6(funcPC(libc___getdirentries64_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
882	2418	n = int(r0)
883	2419	if e1 != 0 {
884	2420	err = errnoErr(e1)

886	2422	return
887	2423	}
888	2424
889		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
890
891		func Getdtablesize() (size int) {
892		r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
893		size = int(r0)
894		return
895		}
896
897		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
898
899		func Getegid() (egid int) {
900		r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
901		egid = int(r0)
902		return
903		}
904
905		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
906
907		func Geteuid() (uid int) {
908		r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
909		uid = int(r0)
910		return
911		}
912
913		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
914
915		func Getgid() (gid int) {
916		r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
917		gid = int(r0)
918		return
919		}
920
921		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
922
923		func Getpgid(pid int) (pgid int, err error) {
924		r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
925		pgid = int(r0)
926		if e1 != 0 {
927		err = errnoErr(e1)
928		}
929		return
930		}
931
932		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
933
934		func Getpgrp() (pgrp int) {
935		r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
936		pgrp = int(r0)
937		return
938		}
939
940		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
941
942		func Getpid() (pid int) {
943		r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
944		pid = int(r0)
945		return
946		}
947
948		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
949
950		func Getppid() (ppid int) {
951		r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
952		ppid = int(r0)
953		return
954		}
955
956		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
957
958		func Getpriority(which int, who int) (prio int, err error) {
959		r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
960		prio = int(r0)
961		if e1 != 0 {
962		err = errnoErr(e1)
963		}
964		return
965		}
966
967		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
968
969		func Getrlimit(which int, lim *Rlimit) (err error) {
970		_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
971		if e1 != 0 {
972		err = errnoErr(e1)
973		}
974		return
975		}
976
977		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
978
979		func Getrusage(who int, rusage *Rusage) (err error) {
980		_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
981		if e1 != 0 {
982		err = errnoErr(e1)
983		}
984		return
985		}
986
987		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
988
989		func Getsid(pid int) (sid int, err error) {
990		r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
991		sid = int(r0)
992		if e1 != 0 {
993		err = errnoErr(e1)
994		}
995		return
996		}
997
998		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
999
1000		func Getuid() (uid int) {
1001		r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
1002		uid = int(r0)
1003		return
1004		}
1005
1006		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1007
1008		func Issetugid() (tainted bool) {
1009		r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
1010		tainted = bool(r0 != 0)
1011		return
1012		}
1013
1014		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1015
1016		func Kqueue() (fd int, err error) {
1017		r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
1018		fd = int(r0)
1019		if e1 != 0 {
1020		err = errnoErr(e1)
1021		}
1022		return
1023		}
1024
1025		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1026
1027		func Lchown(path string, uid int, gid int) (err error) {
1028		var _p0 *byte
1029		_p0, err = BytePtrFromString(path)
1030		if err != nil {
1031		return
1032		}
1033		_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1034		if e1 != 0 {
1035		err = errnoErr(e1)
1036		}
1037		return
1038		}
1039
1040		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1041
1042		func Link(path string, link string) (err error) {
1043		var _p0 *byte
1044		_p0, err = BytePtrFromString(path)
1045		if err != nil {
1046		return
1047		}
1048		var _p1 *byte
1049		_p1, err = BytePtrFromString(link)
1050		if err != nil {
1051		return
1052		}
1053		_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1054		if e1 != 0 {
1055		err = errnoErr(e1)
1056		}
1057		return
1058		}
1059
1060		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1061
1062		func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
1063		var _p0 *byte
1064		_p0, err = BytePtrFromString(path)
1065		if err != nil {
1066		return
1067		}
1068		var _p1 *byte
1069		_p1, err = BytePtrFromString(link)
1070		if err != nil {
1071		return
1072		}
1073		_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1074		if e1 != 0 {
1075		err = errnoErr(e1)
1076		}
1077		return
1078		}
1079
1080		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1081
1082		func Listen(s int, backlog int) (err error) {
1083		_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
1084		if e1 != 0 {
1085		err = errnoErr(e1)
1086		}
1087		return
1088		}
	2425	func libc___getdirentries64_trampoline()
	2426
	2427	//go:linkname libc___getdirentries64 libc___getdirentries64
	2428	//go:cgo_import_dynamic libc___getdirentries64 __getdirentries64 "/usr/lib/libSystem.B.dylib"
	2429
	2430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2431
	2432	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	2433	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat64_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
	2434	n = int(r0)
	2435	if e1 != 0 {
	2436	err = errnoErr(e1)
	2437	}
	2438	return
	2439	}
	2440
	2441	func libc_getfsstat64_trampoline()
	2442
	2443	//go:linkname libc_getfsstat64 libc_getfsstat64
	2444	//go:cgo_import_dynamic libc_getfsstat64 getfsstat64 "/usr/lib/libSystem.B.dylib"
1089	2445
1090	2446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1091	2447

1095	2451	if err != nil {
1096	2452	return
1097	2453	}
1098		_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1099		if e1 != 0 {
1100		err = errnoErr(e1)
1101		}
1102		return
1103		}
1104
1105		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1106
1107		func Mkdir(path string, mode uint32) (err error) {
1108		var _p0 *byte
1109		_p0, err = BytePtrFromString(path)
1110		if err != nil {
1111		return
1112		}
1113		_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1114		if e1 != 0 {
1115		err = errnoErr(e1)
1116		}
1117		return
1118		}
1119
1120		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1121
1122		func Mkdirat(dirfd int, path string, mode uint32) (err error) {
1123		var _p0 *byte
1124		_p0, err = BytePtrFromString(path)
1125		if err != nil {
1126		return
1127		}
1128		_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1129		if e1 != 0 {
1130		err = errnoErr(e1)
1131		}
1132		return
1133		}
1134
1135		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1136
1137		func Mkfifo(path string, mode uint32) (err error) {
1138		var _p0 *byte
1139		_p0, err = BytePtrFromString(path)
1140		if err != nil {
1141		return
1142		}
1143		_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1144		if e1 != 0 {
1145		err = errnoErr(e1)
1146		}
1147		return
1148		}
1149
1150		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1151
1152		func Mknod(path string, mode uint32, dev int) (err error) {
1153		var _p0 *byte
1154		_p0, err = BytePtrFromString(path)
1155		if err != nil {
1156		return
1157		}
1158		_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1159		if e1 != 0 {
1160		err = errnoErr(e1)
1161		}
1162		return
1163		}
1164
1165		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1166
1167		func Open(path string, mode int, perm uint32) (fd int, err error) {
1168		var _p0 *byte
1169		_p0, err = BytePtrFromString(path)
1170		if err != nil {
1171		return
1172		}
1173		r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1174		fd = int(r0)
1175		if e1 != 0 {
1176		err = errnoErr(e1)
1177		}
1178		return
1179		}
1180
1181		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1182
1183		func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
1184		var _p0 *byte
1185		_p0, err = BytePtrFromString(path)
1186		if err != nil {
1187		return
1188		}
1189		r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1190		fd = int(r0)
1191		if e1 != 0 {
1192		err = errnoErr(e1)
1193		}
1194		return
1195		}
1196
1197		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1198
1199		func Pathconf(path string, name int) (val int, err error) {
1200		var _p0 *byte
1201		_p0, err = BytePtrFromString(path)
1202		if err != nil {
1203		return
1204		}
1205		r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1206		val = int(r0)
1207		if e1 != 0 {
1208		err = errnoErr(e1)
1209		}
1210		return
1211		}
1212
1213		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1214
1215		func Pread(fd int, p []byte, offset int64) (n int, err error) {
1216		var _p0 unsafe.Pointer
1217		if len(p) > 0 {
1218		_p0 = unsafe.Pointer(&p[0])
1219		} else {
1220		_p0 = unsafe.Pointer(&_zero)
1221		}
1222		r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1223		n = int(r0)
1224		if e1 != 0 {
1225		err = errnoErr(e1)
1226		}
1227		return
1228		}
1229
1230		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1231
1232		func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
1233		var _p0 unsafe.Pointer
1234		if len(p) > 0 {
1235		_p0 = unsafe.Pointer(&p[0])
1236		} else {
1237		_p0 = unsafe.Pointer(&_zero)
1238		}
1239		r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1240		n = int(r0)
1241		if e1 != 0 {
1242		err = errnoErr(e1)
1243		}
1244		return
1245		}
1246
1247		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1248
1249		func read(fd int, p []byte) (n int, err error) {
1250		var _p0 unsafe.Pointer
1251		if len(p) > 0 {
1252		_p0 = unsafe.Pointer(&p[0])
1253		} else {
1254		_p0 = unsafe.Pointer(&_zero)
1255		}
1256		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
1257		n = int(r0)
1258		if e1 != 0 {
1259		err = errnoErr(e1)
1260		}
1261		return
1262		}
1263
1264		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1265
1266		func Readlink(path string, buf []byte) (n int, err error) {
1267		var _p0 *byte
1268		_p0, err = BytePtrFromString(path)
1269		if err != nil {
1270		return
1271		}
1272		var _p1 unsafe.Pointer
1273		if len(buf) > 0 {
1274		_p1 = unsafe.Pointer(&buf[0])
1275		} else {
1276		_p1 = unsafe.Pointer(&_zero)
1277		}
1278		r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1279		n = int(r0)
1280		if e1 != 0 {
1281		err = errnoErr(e1)
1282		}
1283		return
1284		}
1285
1286		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1287
1288		func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
1289		var _p0 *byte
1290		_p0, err = BytePtrFromString(path)
1291		if err != nil {
1292		return
1293		}
1294		var _p1 unsafe.Pointer
1295		if len(buf) > 0 {
1296		_p1 = unsafe.Pointer(&buf[0])
1297		} else {
1298		_p1 = unsafe.Pointer(&_zero)
1299		}
1300		r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1301		n = int(r0)
1302		if e1 != 0 {
1303		err = errnoErr(e1)
1304		}
1305		return
1306		}
1307
1308		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1309
1310		func Rename(from string, to string) (err error) {
1311		var _p0 *byte
1312		_p0, err = BytePtrFromString(from)
1313		if err != nil {
1314		return
1315		}
1316		var _p1 *byte
1317		_p1, err = BytePtrFromString(to)
1318		if err != nil {
1319		return
1320		}
1321		_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1322		if e1 != 0 {
1323		err = errnoErr(e1)
1324		}
1325		return
1326		}
1327
1328		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1329
1330		func Renameat(fromfd int, from string, tofd int, to string) (err error) {
1331		var _p0 *byte
1332		_p0, err = BytePtrFromString(from)
1333		if err != nil {
1334		return
1335		}
1336		var _p1 *byte
1337		_p1, err = BytePtrFromString(to)
1338		if err != nil {
1339		return
1340		}
1341		_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1342		if e1 != 0 {
1343		err = errnoErr(e1)
1344		}
1345		return
1346		}
1347
1348		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1349
1350		func Revoke(path string) (err error) {
1351		var _p0 *byte
1352		_p0, err = BytePtrFromString(path)
1353		if err != nil {
1354		return
1355		}
1356		_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1357		if e1 != 0 {
1358		err = errnoErr(e1)
1359		}
1360		return
1361		}
1362
1363		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1364
1365		func Rmdir(path string) (err error) {
1366		var _p0 *byte
1367		_p0, err = BytePtrFromString(path)
1368		if err != nil {
1369		return
1370		}
1371		_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
1372		if e1 != 0 {
1373		err = errnoErr(e1)
1374		}
1375		return
1376		}
1377
1378		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1379
1380		func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1381		r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
1382		newoffset = int64(r0)
1383		if e1 != 0 {
1384		err = errnoErr(e1)
1385		}
1386		return
1387		}
1388
1389		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1390
1391		func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
1392		_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1393		if e1 != 0 {
1394		err = errnoErr(e1)
1395		}
1396		return
1397		}
1398
1399		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1400
1401		func Setegid(egid int) (err error) {
1402		_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
1403		if e1 != 0 {
1404		err = errnoErr(e1)
1405		}
1406		return
1407		}
1408
1409		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1410
1411		func Seteuid(euid int) (err error) {
1412		_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
1413		if e1 != 0 {
1414		err = errnoErr(e1)
1415		}
1416		return
1417		}
1418
1419		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1420
1421		func Setgid(gid int) (err error) {
1422		_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
1423		if e1 != 0 {
1424		err = errnoErr(e1)
1425		}
1426		return
1427		}
1428
1429		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1430
1431		func Setlogin(name string) (err error) {
1432		var _p0 *byte
1433		_p0, err = BytePtrFromString(name)
1434		if err != nil {
1435		return
1436		}
1437		_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
1438		if e1 != 0 {
1439		err = errnoErr(e1)
1440		}
1441		return
1442		}
1443
1444		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1445
1446		func Setpgid(pid int, pgid int) (err error) {
1447		_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
1448		if e1 != 0 {
1449		err = errnoErr(e1)
1450		}
1451		return
1452		}
1453
1454		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1455
1456		func Setpriority(which int, who int, prio int) (err error) {
1457		_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
1458		if e1 != 0 {
1459		err = errnoErr(e1)
1460		}
1461		return
1462		}
1463
1464		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1465
1466		func Setprivexec(flag int) (err error) {
1467		_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
1468		if e1 != 0 {
1469		err = errnoErr(e1)
1470		}
1471		return
1472		}
1473
1474		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1475
1476		func Setregid(rgid int, egid int) (err error) {
1477		_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
1478		if e1 != 0 {
1479		err = errnoErr(e1)
1480		}
1481		return
1482		}
1483
1484		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1485
1486		func Setreuid(ruid int, euid int) (err error) {
1487		_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1488		if e1 != 0 {
1489		err = errnoErr(e1)
1490		}
1491		return
1492		}
1493
1494		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1495
1496		func Setrlimit(which int, lim *Rlimit) (err error) {
1497		_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1498		if e1 != 0 {
1499		err = errnoErr(e1)
1500		}
1501		return
1502		}
1503
1504		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1505
1506		func Setsid() (pid int, err error) {
1507		r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
1508		pid = int(r0)
1509		if e1 != 0 {
1510		err = errnoErr(e1)
1511		}
1512		return
1513		}
1514
1515		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1516
1517		func Settimeofday(tp *Timeval) (err error) {
1518		_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1519		if e1 != 0 {
1520		err = errnoErr(e1)
1521		}
1522		return
1523		}
1524
1525		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1526
1527		func Setuid(uid int) (err error) {
1528		_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1529		if e1 != 0 {
1530		err = errnoErr(e1)
1531		}
1532		return
1533		}
	2454	_, _, e1 := syscall_syscall(funcPC(libc_lstat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2455	if e1 != 0 {
	2456	err = errnoErr(e1)
	2457	}
	2458	return
	2459	}
	2460
	2461	func libc_lstat64_trampoline()
	2462
	2463	//go:linkname libc_lstat64 libc_lstat64
	2464	//go:cgo_import_dynamic libc_lstat64 lstat64 "/usr/lib/libSystem.B.dylib"
1534	2465
1535	2466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1536	2467

1540	2471	if err != nil {
1541	2472	return
1542	2473	}
1543		_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1544		if e1 != 0 {
1545		err = errnoErr(e1)
1546		}
1547		return
1548		}
	2474	_, _, e1 := syscall_syscall(funcPC(libc_stat64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2475	if e1 != 0 {
	2476	err = errnoErr(e1)
	2477	}
	2478	return
	2479	}
	2480
	2481	func libc_stat64_trampoline()
	2482
	2483	//go:linkname libc_stat64 libc_stat64
	2484	//go:cgo_import_dynamic libc_stat64 stat64 "/usr/lib/libSystem.B.dylib"
1549	2485
1550	2486	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1551	2487

1555	2491	if err != nil {
1556	2492	return
1557	2493	}
1558		_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1559		if e1 != 0 {
1560		err = errnoErr(e1)
1561		}
1562		return
1563		}
1564
1565		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1566
1567		func Symlink(path string, link string) (err error) {
1568		var _p0 *byte
1569		_p0, err = BytePtrFromString(path)
1570		if err != nil {
1571		return
1572		}
1573		var _p1 *byte
1574		_p1, err = BytePtrFromString(link)
1575		if err != nil {
1576		return
1577		}
1578		_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1579		if e1 != 0 {
1580		err = errnoErr(e1)
1581		}
1582		return
1583		}
1584
1585		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1586
1587		func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
1588		var _p0 *byte
1589		_p0, err = BytePtrFromString(oldpath)
1590		if err != nil {
1591		return
1592		}
1593		var _p1 *byte
1594		_p1, err = BytePtrFromString(newpath)
1595		if err != nil {
1596		return
1597		}
1598		_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
1599		if e1 != 0 {
1600		err = errnoErr(e1)
1601		}
1602		return
1603		}
1604
1605		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1606
1607		func Sync() (err error) {
1608		_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
1609		if e1 != 0 {
1610		err = errnoErr(e1)
1611		}
1612		return
1613		}
1614
1615		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1616
1617		func Truncate(path string, length int64) (err error) {
1618		var _p0 *byte
1619		_p0, err = BytePtrFromString(path)
1620		if err != nil {
1621		return
1622		}
1623		_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
1624		if e1 != 0 {
1625		err = errnoErr(e1)
1626		}
1627		return
1628		}
1629
1630		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1631
1632		func Umask(newmask int) (oldmask int) {
1633		r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
1634		oldmask = int(r0)
1635		return
1636		}
1637
1638		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1639
1640		func Undelete(path string) (err error) {
1641		var _p0 *byte
1642		_p0, err = BytePtrFromString(path)
1643		if err != nil {
1644		return
1645		}
1646		_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1647		if e1 != 0 {
1648		err = errnoErr(e1)
1649		}
1650		return
1651		}
1652
1653		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1654
1655		func Unlink(path string) (err error) {
1656		var _p0 *byte
1657		_p0, err = BytePtrFromString(path)
1658		if err != nil {
1659		return
1660		}
1661		_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
1662		if e1 != 0 {
1663		err = errnoErr(e1)
1664		}
1665		return
1666		}
1667
1668		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1669
1670		func Unlinkat(dirfd int, path string, flags int) (err error) {
1671		var _p0 *byte
1672		_p0, err = BytePtrFromString(path)
1673		if err != nil {
1674		return
1675		}
1676		_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
1677		if e1 != 0 {
1678		err = errnoErr(e1)
1679		}
1680		return
1681		}
1682
1683		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1684
1685		func Unmount(path string, flags int) (err error) {
1686		var _p0 *byte
1687		_p0, err = BytePtrFromString(path)
1688		if err != nil {
1689		return
1690		}
1691		_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1692		if e1 != 0 {
1693		err = errnoErr(e1)
1694		}
1695		return
1696		}
1697
1698		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1699
1700		func write(fd int, p []byte) (n int, err error) {
1701		var _p0 unsafe.Pointer
1702		if len(p) > 0 {
1703		_p0 = unsafe.Pointer(&p[0])
1704		} else {
1705		_p0 = unsafe.Pointer(&_zero)
1706		}
1707		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
1708		n = int(r0)
1709		if e1 != 0 {
1710		err = errnoErr(e1)
1711		}
1712		return
1713		}
1714
1715		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1716
1717		func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1718		r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
1719		ret = uintptr(r0)
1720		if e1 != 0 {
1721		err = errnoErr(e1)
1722		}
1723		return
1724		}
1725
1726		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1727
1728		func munmap(addr uintptr, length uintptr) (err error) {
1729		_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
1730		if e1 != 0 {
1731		err = errnoErr(e1)
1732		}
1733		return
1734		}
1735
1736		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1737
1738		func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1739		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1740		n = int(r0)
1741		if e1 != 0 {
1742		err = errnoErr(e1)
1743		}
1744		return
1745		}
1746
1747		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1748
1749		func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1750		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1751		n = int(r0)
1752		if e1 != 0 {
1753		err = errnoErr(e1)
1754		}
1755		return
1756		}
1757
1758		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1759
1760		func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
1761		r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1762		sec = int64(r0)
1763		usec = int32(r1)
1764		if e1 != 0 {
1765		err = errnoErr(e1)
1766		}
1767		return
1768		}
	2494	_, _, e1 := syscall_syscall(funcPC(libc_statfs64_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2495	if e1 != 0 {
	2496	err = errnoErr(e1)
	2497	}
	2498	return
	2499	}
	2500
	2501	func libc_statfs64_trampoline()
	2502
	2503	//go:linkname libc_statfs64 libc_statfs64
	2504	//go:cgo_import_dynamic libc_statfs64 statfs64 "/usr/lib/libSystem.B.dylib"

+284

-0

unix/zsyscall_darwin_amd64.s less more

	0	// go run mkasm_darwin.go amd64
	1	// Code generated by the command above; DO NOT EDIT.
	2
	3	// +build go1.12
	4
	5	#include "textflag.h"
	6	TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
	7	JMP libc_getgroups(SB)
	8	TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
	9	JMP libc_setgroups(SB)
	10	TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
	11	JMP libc_wait4(SB)
	12	TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
	13	JMP libc_accept(SB)
	14	TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
	15	JMP libc_bind(SB)
	16	TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
	17	JMP libc_connect(SB)
	18	TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
	19	JMP libc_socket(SB)
	20	TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
	21	JMP libc_getsockopt(SB)
	22	TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
	23	JMP libc_setsockopt(SB)
	24	TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
	25	JMP libc_getpeername(SB)
	26	TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
	27	JMP libc_getsockname(SB)
	28	TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
	29	JMP libc_shutdown(SB)
	30	TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
	31	JMP libc_socketpair(SB)
	32	TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
	33	JMP libc_recvfrom(SB)
	34	TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
	35	JMP libc_sendto(SB)
	36	TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
	37	JMP libc_recvmsg(SB)
	38	TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
	39	JMP libc_sendmsg(SB)
	40	TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
	41	JMP libc_kevent(SB)
	42	TEXT ·libc___sysctl_trampoline(SB),NOSPLIT,$0-0
	43	JMP libc___sysctl(SB)
	44	TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
	45	JMP libc_utimes(SB)
	46	TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
	47	JMP libc_futimes(SB)
	48	TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
	49	JMP libc_fcntl(SB)
	50	TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
	51	JMP libc_poll(SB)
	52	TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
	53	JMP libc_madvise(SB)
	54	TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
	55	JMP libc_mlock(SB)
	56	TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
	57	JMP libc_mlockall(SB)
	58	TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
	59	JMP libc_mprotect(SB)
	60	TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
	61	JMP libc_msync(SB)
	62	TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
	63	JMP libc_munlock(SB)
	64	TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
	65	JMP libc_munlockall(SB)
	66	TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
	67	JMP libc_ptrace(SB)
	68	TEXT ·libc_getattrlist_trampoline(SB),NOSPLIT,$0-0
	69	JMP libc_getattrlist(SB)
	70	TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
	71	JMP libc_pipe(SB)
	72	TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
	73	JMP libc_getxattr(SB)
	74	TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
	75	JMP libc_fgetxattr(SB)
	76	TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
	77	JMP libc_setxattr(SB)
	78	TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
	79	JMP libc_fsetxattr(SB)
	80	TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
	81	JMP libc_removexattr(SB)
	82	TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
	83	JMP libc_fremovexattr(SB)
	84	TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
	85	JMP libc_listxattr(SB)
	86	TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
	87	JMP libc_flistxattr(SB)
	88	TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
	89	JMP libc_setattrlist(SB)
	90	TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
	91	JMP libc_kill(SB)
	92	TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
	93	JMP libc_ioctl(SB)
	94	TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
	95	JMP libc_sendfile(SB)
	96	TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
	97	JMP libc_access(SB)
	98	TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
	99	JMP libc_adjtime(SB)
	100	TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
	101	JMP libc_chdir(SB)
	102	TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
	103	JMP libc_chflags(SB)
	104	TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
	105	JMP libc_chmod(SB)
	106	TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
	107	JMP libc_chown(SB)
	108	TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
	109	JMP libc_chroot(SB)
	110	TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
	111	JMP libc_close(SB)
	112	TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
	113	JMP libc_dup(SB)
	114	TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
	115	JMP libc_dup2(SB)
	116	TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
	117	JMP libc_exchangedata(SB)
	118	TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
	119	JMP libc_exit(SB)
	120	TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
	121	JMP libc_faccessat(SB)
	122	TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
	123	JMP libc_fchdir(SB)
	124	TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
	125	JMP libc_fchflags(SB)
	126	TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
	127	JMP libc_fchmod(SB)
	128	TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
	129	JMP libc_fchmodat(SB)
	130	TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
	131	JMP libc_fchown(SB)
	132	TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
	133	JMP libc_fchownat(SB)
	134	TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
	135	JMP libc_flock(SB)
	136	TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
	137	JMP libc_fpathconf(SB)
	138	TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
	139	JMP libc_fsync(SB)
	140	TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
	141	JMP libc_ftruncate(SB)
	142	TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
	143	JMP libc_getdtablesize(SB)
	144	TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
	145	JMP libc_getegid(SB)
	146	TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
	147	JMP libc_geteuid(SB)
	148	TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
	149	JMP libc_getgid(SB)
	150	TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
	151	JMP libc_getpgid(SB)
	152	TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
	153	JMP libc_getpgrp(SB)
	154	TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
	155	JMP libc_getpid(SB)
	156	TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
	157	JMP libc_getppid(SB)
	158	TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
	159	JMP libc_getpriority(SB)
	160	TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
	161	JMP libc_getrlimit(SB)
	162	TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
	163	JMP libc_getrusage(SB)
	164	TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
	165	JMP libc_getsid(SB)
	166	TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
	167	JMP libc_getuid(SB)
	168	TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
	169	JMP libc_issetugid(SB)
	170	TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
	171	JMP libc_kqueue(SB)
	172	TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
	173	JMP libc_lchown(SB)
	174	TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
	175	JMP libc_link(SB)
	176	TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
	177	JMP libc_linkat(SB)
	178	TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
	179	JMP libc_listen(SB)
	180	TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
	181	JMP libc_mkdir(SB)
	182	TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
	183	JMP libc_mkdirat(SB)
	184	TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
	185	JMP libc_mkfifo(SB)
	186	TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
	187	JMP libc_mknod(SB)
	188	TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
	189	JMP libc_open(SB)
	190	TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
	191	JMP libc_openat(SB)
	192	TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
	193	JMP libc_pathconf(SB)
	194	TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
	195	JMP libc_pread(SB)
	196	TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
	197	JMP libc_pwrite(SB)
	198	TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
	199	JMP libc_read(SB)
	200	TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
	201	JMP libc_readlink(SB)
	202	TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
	203	JMP libc_readlinkat(SB)
	204	TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
	205	JMP libc_rename(SB)
	206	TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
	207	JMP libc_renameat(SB)
	208	TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
	209	JMP libc_revoke(SB)
	210	TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
	211	JMP libc_rmdir(SB)
	212	TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
	213	JMP libc_lseek(SB)
	214	TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
	215	JMP libc_select(SB)
	216	TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
	217	JMP libc_setegid(SB)
	218	TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
	219	JMP libc_seteuid(SB)
	220	TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
	221	JMP libc_setgid(SB)
	222	TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
	223	JMP libc_setlogin(SB)
	224	TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
	225	JMP libc_setpgid(SB)
	226	TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
	227	JMP libc_setpriority(SB)
	228	TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
	229	JMP libc_setprivexec(SB)
	230	TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
	231	JMP libc_setregid(SB)
	232	TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
	233	JMP libc_setreuid(SB)
	234	TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
	235	JMP libc_setrlimit(SB)
	236	TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
	237	JMP libc_setsid(SB)
	238	TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
	239	JMP libc_settimeofday(SB)
	240	TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
	241	JMP libc_setuid(SB)
	242	TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
	243	JMP libc_symlink(SB)
	244	TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
	245	JMP libc_symlinkat(SB)
	246	TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
	247	JMP libc_sync(SB)
	248	TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
	249	JMP libc_truncate(SB)
	250	TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
	251	JMP libc_umask(SB)
	252	TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
	253	JMP libc_undelete(SB)
	254	TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
	255	JMP libc_unlink(SB)
	256	TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
	257	JMP libc_unlinkat(SB)
	258	TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
	259	JMP libc_unmount(SB)
	260	TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
	261	JMP libc_write(SB)
	262	TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
	263	JMP libc_mmap(SB)
	264	TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
	265	JMP libc_munmap(SB)
	266	TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
	267	JMP libc_gettimeofday(SB)
	268	TEXT ·libc_fstat64_trampoline(SB),NOSPLIT,$0-0
	269	JMP libc_fstat64(SB)
	270	TEXT ·libc_fstatat64_trampoline(SB),NOSPLIT,$0-0
	271	JMP libc_fstatat64(SB)
	272	TEXT ·libc_fstatfs64_trampoline(SB),NOSPLIT,$0-0
	273	JMP libc_fstatfs64(SB)
	274	TEXT ·libc___getdirentries64_trampoline(SB),NOSPLIT,$0-0
	275	JMP libc___getdirentries64(SB)
	276	TEXT ·libc_getfsstat64_trampoline(SB),NOSPLIT,$0-0
	277	JMP libc_getfsstat64(SB)
	278	TEXT ·libc_lstat64_trampoline(SB),NOSPLIT,$0-0
	279	JMP libc_lstat64(SB)
	280	TEXT ·libc_stat64_trampoline(SB),NOSPLIT,$0-0
	281	JMP libc_stat64(SB)
	282	TEXT ·libc_statfs64_trampoline(SB),NOSPLIT,$0-0
	283	JMP libc_statfs64(SB)

+1793

-0

unix/zsyscall_darwin_arm.1_11.go less more

	0	// go run mksyscall.go -l32 -tags darwin,arm,!go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm.go
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
	2
	3	// +build darwin,arm,!go1.12
	4
	5	package unix
	6
	7	import (
	8	"syscall"
	9	"unsafe"
	10	)
	11
	12	var _ syscall.Errno
	13
	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	15
	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
	17	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	18	n = int(r0)
	19	if e1 != 0 {
	20	err = errnoErr(e1)
	21	}
	22	return
	23	}
	24
	25	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	26
	27	func setgroups(ngid int, gid *_Gid_t) (err error) {
	28	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	29	if e1 != 0 {
	30	err = errnoErr(e1)
	31	}
	32	return
	33	}
	34
	35	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	36
	37	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
	38	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	39	wpid = int(r0)
	40	if e1 != 0 {
	41	err = errnoErr(e1)
	42	}
	43	return
	44	}
	45
	46	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	47
	48	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
	49	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	50	fd = int(r0)
	51	if e1 != 0 {
	52	err = errnoErr(e1)
	53	}
	54	return
	55	}
	56
	57	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	58
	59	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	60	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
	61	if e1 != 0 {
	62	err = errnoErr(e1)
	63	}
	64	return
	65	}
	66
	67	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	68
	69	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	70	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
	71	if e1 != 0 {
	72	err = errnoErr(e1)
	73	}
	74	return
	75	}
	76
	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	78
	79	func socket(domain int, typ int, proto int) (fd int, err error) {
	80	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	81	fd = int(r0)
	82	if e1 != 0 {
	83	err = errnoErr(e1)
	84	}
	85	return
	86	}
	87
	88	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	89
	90	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
	91	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	92	if e1 != 0 {
	93	err = errnoErr(e1)
	94	}
	95	return
	96	}
	97
	98	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	99
	100	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
	101	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	102	if e1 != 0 {
	103	err = errnoErr(e1)
	104	}
	105	return
	106	}
	107
	108	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	109
	110	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	111	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	112	if e1 != 0 {
	113	err = errnoErr(e1)
	114	}
	115	return
	116	}
	117
	118	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	119
	120	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	121	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	122	if e1 != 0 {
	123	err = errnoErr(e1)
	124	}
	125	return
	126	}
	127
	128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	129
	130	func Shutdown(s int, how int) (err error) {
	131	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
	132	if e1 != 0 {
	133	err = errnoErr(e1)
	134	}
	135	return
	136	}
	137
	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	139
	140	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
	141	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	149
	150	func recvfrom(fd int, p []byte, flags int, from RawSockaddrAny, fromlen _Socklen) (n int, err error) {
	151	var _p0 unsafe.Pointer
	152	if len(p) > 0 {
	153	_p0 = unsafe.Pointer(&p[0])
	154	} else {
	155	_p0 = unsafe.Pointer(&_zero)
	156	}
	157	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	158	n = int(r0)
	159	if e1 != 0 {
	160	err = errnoErr(e1)
	161	}
	162	return
	163	}
	164
	165	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	166
	167	func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
	168	var _p0 unsafe.Pointer
	169	if len(buf) > 0 {
	170	_p0 = unsafe.Pointer(&buf[0])
	171	} else {
	172	_p0 = unsafe.Pointer(&_zero)
	173	}
	174	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	175	if e1 != 0 {
	176	err = errnoErr(e1)
	177	}
	178	return
	179	}
	180
	181	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	182
	183	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	184	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	185	n = int(r0)
	186	if e1 != 0 {
	187	err = errnoErr(e1)
	188	}
	189	return
	190	}
	191
	192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	193
	194	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	195	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	196	n = int(r0)
	197	if e1 != 0 {
	198	err = errnoErr(e1)
	199	}
	200	return
	201	}
	202
	203	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	204
	205	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
	206	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	207	n = int(r0)
	208	if e1 != 0 {
	209	err = errnoErr(e1)
	210	}
	211	return
	212	}
	213
	214	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	215
	216	func sysctl(mib []_C_int, old byte, oldlen uintptr, new *byte, newlen uintptr) (err error) {
	217	var _p0 unsafe.Pointer
	218	if len(mib) > 0 {
	219	_p0 = unsafe.Pointer(&mib[0])
	220	} else {
	221	_p0 = unsafe.Pointer(&_zero)
	222	}
	223	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
	224	if e1 != 0 {
	225	err = errnoErr(e1)
	226	}
	227	return
	228	}
	229
	230	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	231
	232	func utimes(path string, timeval *[2]Timeval) (err error) {
	233	var _p0 *byte
	234	_p0, err = BytePtrFromString(path)
	235	if err != nil {
	236	return
	237	}
	238	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	239	if e1 != 0 {
	240	err = errnoErr(e1)
	241	}
	242	return
	243	}
	244
	245	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	246
	247	func futimes(fd int, timeval *[2]Timeval) (err error) {
	248	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	249	if e1 != 0 {
	250	err = errnoErr(e1)
	251	}
	252	return
	253	}
	254
	255	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	256
	257	func fcntl(fd int, cmd int, arg int) (val int, err error) {
	258	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	259	val = int(r0)
	260	if e1 != 0 {
	261	err = errnoErr(e1)
	262	}
	263	return
	264	}
	265
	266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	267
	268	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
	269	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	270	n = int(r0)
	271	if e1 != 0 {
	272	err = errnoErr(e1)
	273	}
	274	return
	275	}
	276
	277	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	278
	279	func Madvise(b []byte, behav int) (err error) {
	280	var _p0 unsafe.Pointer
	281	if len(b) > 0 {
	282	_p0 = unsafe.Pointer(&b[0])
	283	} else {
	284	_p0 = unsafe.Pointer(&_zero)
	285	}
	286	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
	287	if e1 != 0 {
	288	err = errnoErr(e1)
	289	}
	290	return
	291	}
	292
	293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	294
	295	func Mlock(b []byte) (err error) {
	296	var _p0 unsafe.Pointer
	297	if len(b) > 0 {
	298	_p0 = unsafe.Pointer(&b[0])
	299	} else {
	300	_p0 = unsafe.Pointer(&_zero)
	301	}
	302	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
	303	if e1 != 0 {
	304	err = errnoErr(e1)
	305	}
	306	return
	307	}
	308
	309	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	310
	311	func Mlockall(flags int) (err error) {
	312	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
	313	if e1 != 0 {
	314	err = errnoErr(e1)
	315	}
	316	return
	317	}
	318
	319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	320
	321	func Mprotect(b []byte, prot int) (err error) {
	322	var _p0 unsafe.Pointer
	323	if len(b) > 0 {
	324	_p0 = unsafe.Pointer(&b[0])
	325	} else {
	326	_p0 = unsafe.Pointer(&_zero)
	327	}
	328	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
	329	if e1 != 0 {
	330	err = errnoErr(e1)
	331	}
	332	return
	333	}
	334
	335	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	336
	337	func Msync(b []byte, flags int) (err error) {
	338	var _p0 unsafe.Pointer
	339	if len(b) > 0 {
	340	_p0 = unsafe.Pointer(&b[0])
	341	} else {
	342	_p0 = unsafe.Pointer(&_zero)
	343	}
	344	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
	345	if e1 != 0 {
	346	err = errnoErr(e1)
	347	}
	348	return
	349	}
	350
	351	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	352
	353	func Munlock(b []byte) (err error) {
	354	var _p0 unsafe.Pointer
	355	if len(b) > 0 {
	356	_p0 = unsafe.Pointer(&b[0])
	357	} else {
	358	_p0 = unsafe.Pointer(&_zero)
	359	}
	360	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
	361	if e1 != 0 {
	362	err = errnoErr(e1)
	363	}
	364	return
	365	}
	366
	367	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	368
	369	func Munlockall() (err error) {
	370	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
	371	if e1 != 0 {
	372	err = errnoErr(e1)
	373	}
	374	return
	375	}
	376
	377	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	378
	379	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
	380	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	381	if e1 != 0 {
	382	err = errnoErr(e1)
	383	}
	384	return
	385	}
	386
	387	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	388
	389	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	390	_, _, e1 := Syscall6(SYS_GETATTRLIST, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	391	if e1 != 0 {
	392	err = errnoErr(e1)
	393	}
	394	return
	395	}
	396
	397	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	398
	399	func pipe() (r int, w int, err error) {
	400	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	401	r = int(r0)
	402	w = int(r1)
	403	if e1 != 0 {
	404	err = errnoErr(e1)
	405	}
	406	return
	407	}
	408
	409	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	410
	411	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	412	var _p0 *byte
	413	_p0, err = BytePtrFromString(path)
	414	if err != nil {
	415	return
	416	}
	417	var _p1 *byte
	418	_p1, err = BytePtrFromString(attr)
	419	if err != nil {
	420	return
	421	}
	422	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	423	sz = int(r0)
	424	if e1 != 0 {
	425	err = errnoErr(e1)
	426	}
	427	return
	428	}
	429
	430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	431
	432	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	433	var _p0 *byte
	434	_p0, err = BytePtrFromString(attr)
	435	if err != nil {
	436	return
	437	}
	438	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	439	sz = int(r0)
	440	if e1 != 0 {
	441	err = errnoErr(e1)
	442	}
	443	return
	444	}
	445
	446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	447
	448	func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
	449	var _p0 *byte
	450	_p0, err = BytePtrFromString(path)
	451	if err != nil {
	452	return
	453	}
	454	var _p1 *byte
	455	_p1, err = BytePtrFromString(attr)
	456	if err != nil {
	457	return
	458	}
	459	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	460	if e1 != 0 {
	461	err = errnoErr(e1)
	462	}
	463	return
	464	}
	465
	466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	467
	468	func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
	469	var _p0 *byte
	470	_p0, err = BytePtrFromString(attr)
	471	if err != nil {
	472	return
	473	}
	474	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	475	if e1 != 0 {
	476	err = errnoErr(e1)
	477	}
	478	return
	479	}
	480
	481	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	482
	483	func removexattr(path string, attr string, options int) (err error) {
	484	var _p0 *byte
	485	_p0, err = BytePtrFromString(path)
	486	if err != nil {
	487	return
	488	}
	489	var _p1 *byte
	490	_p1, err = BytePtrFromString(attr)
	491	if err != nil {
	492	return
	493	}
	494	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	495	if e1 != 0 {
	496	err = errnoErr(e1)
	497	}
	498	return
	499	}
	500
	501	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	502
	503	func fremovexattr(fd int, attr string, options int) (err error) {
	504	var _p0 *byte
	505	_p0, err = BytePtrFromString(attr)
	506	if err != nil {
	507	return
	508	}
	509	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	510	if e1 != 0 {
	511	err = errnoErr(e1)
	512	}
	513	return
	514	}
	515
	516	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	517
	518	func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
	519	var _p0 *byte
	520	_p0, err = BytePtrFromString(path)
	521	if err != nil {
	522	return
	523	}
	524	r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	525	sz = int(r0)
	526	if e1 != 0 {
	527	err = errnoErr(e1)
	528	}
	529	return
	530	}
	531
	532	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	533
	534	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
	535	r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	536	sz = int(r0)
	537	if e1 != 0 {
	538	err = errnoErr(e1)
	539	}
	540	return
	541	}
	542
	543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	544
	545	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	546	_, _, e1 := Syscall6(SYS_SETATTRLIST, 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	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	554
	555	func kill(pid int, signum int, posix int) (err error) {
	556	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
	557	if e1 != 0 {
	558	err = errnoErr(e1)
	559	}
	560	return
	561	}
	562
	563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	564
	565	func ioctl(fd int, req uint, arg uintptr) (err error) {
	566	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
	567	if e1 != 0 {
	568	err = errnoErr(e1)
	569	}
	570	return
	571	}
	572
	573	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	574
	575	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	576	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
	577	if e1 != 0 {
	578	err = errnoErr(e1)
	579	}
	580	return
	581	}
	582
	583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	584
	585	func Access(path string, mode uint32) (err error) {
	586	var _p0 *byte
	587	_p0, err = BytePtrFromString(path)
	588	if err != nil {
	589	return
	590	}
	591	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	592	if e1 != 0 {
	593	err = errnoErr(e1)
	594	}
	595	return
	596	}
	597
	598	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	599
	600	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
	601	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	602	if e1 != 0 {
	603	err = errnoErr(e1)
	604	}
	605	return
	606	}
	607
	608	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	609
	610	func Chdir(path string) (err error) {
	611	var _p0 *byte
	612	_p0, err = BytePtrFromString(path)
	613	if err != nil {
	614	return
	615	}
	616	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	617	if e1 != 0 {
	618	err = errnoErr(e1)
	619	}
	620	return
	621	}
	622
	623	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	624
	625	func Chflags(path string, flags int) (err error) {
	626	var _p0 *byte
	627	_p0, err = BytePtrFromString(path)
	628	if err != nil {
	629	return
	630	}
	631	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	632	if e1 != 0 {
	633	err = errnoErr(e1)
	634	}
	635	return
	636	}
	637
	638	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	639
	640	func Chmod(path string, mode uint32) (err error) {
	641	var _p0 *byte
	642	_p0, err = BytePtrFromString(path)
	643	if err != nil {
	644	return
	645	}
	646	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	647	if e1 != 0 {
	648	err = errnoErr(e1)
	649	}
	650	return
	651	}
	652
	653	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	654
	655	func Chown(path string, uid int, gid int) (err error) {
	656	var _p0 *byte
	657	_p0, err = BytePtrFromString(path)
	658	if err != nil {
	659	return
	660	}
	661	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	662	if e1 != 0 {
	663	err = errnoErr(e1)
	664	}
	665	return
	666	}
	667
	668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	669
	670	func Chroot(path string) (err error) {
	671	var _p0 *byte
	672	_p0, err = BytePtrFromString(path)
	673	if err != nil {
	674	return
	675	}
	676	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
	677	if e1 != 0 {
	678	err = errnoErr(e1)
	679	}
	680	return
	681	}
	682
	683	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	684
	685	func Close(fd int) (err error) {
	686	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
	687	if e1 != 0 {
	688	err = errnoErr(e1)
	689	}
	690	return
	691	}
	692
	693	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	694
	695	func Dup(fd int) (nfd int, err error) {
	696	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	697	nfd = int(r0)
	698	if e1 != 0 {
	699	err = errnoErr(e1)
	700	}
	701	return
	702	}
	703
	704	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	705
	706	func Dup2(from int, to int) (err error) {
	707	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
	708	if e1 != 0 {
	709	err = errnoErr(e1)
	710	}
	711	return
	712	}
	713
	714	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	715
	716	func Exchangedata(path1 string, path2 string, options int) (err error) {
	717	var _p0 *byte
	718	_p0, err = BytePtrFromString(path1)
	719	if err != nil {
	720	return
	721	}
	722	var _p1 *byte
	723	_p1, err = BytePtrFromString(path2)
	724	if err != nil {
	725	return
	726	}
	727	_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	728	if e1 != 0 {
	729	err = errnoErr(e1)
	730	}
	731	return
	732	}
	733
	734	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	735
	736	func Exit(code int) {
	737	Syscall(SYS_EXIT, uintptr(code), 0, 0)
	738	return
	739	}
	740
	741	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	742
	743	func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
	744	var _p0 *byte
	745	_p0, err = BytePtrFromString(path)
	746	if err != nil {
	747	return
	748	}
	749	_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	750	if e1 != 0 {
	751	err = errnoErr(e1)
	752	}
	753	return
	754	}
	755
	756	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	757
	758	func Fchdir(fd int) (err error) {
	759	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
	760	if e1 != 0 {
	761	err = errnoErr(e1)
	762	}
	763	return
	764	}
	765
	766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	767
	768	func Fchflags(fd int, flags int) (err error) {
	769	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
	770	if e1 != 0 {
	771	err = errnoErr(e1)
	772	}
	773	return
	774	}
	775
	776	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	777
	778	func Fchmod(fd int, mode uint32) (err error) {
	779	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
	780	if e1 != 0 {
	781	err = errnoErr(e1)
	782	}
	783	return
	784	}
	785
	786	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	787
	788	func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
	789	var _p0 *byte
	790	_p0, err = BytePtrFromString(path)
	791	if err != nil {
	792	return
	793	}
	794	_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	795	if e1 != 0 {
	796	err = errnoErr(e1)
	797	}
	798	return
	799	}
	800
	801	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	802
	803	func Fchown(fd int, uid int, gid int) (err error) {
	804	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
	805	if e1 != 0 {
	806	err = errnoErr(e1)
	807	}
	808	return
	809	}
	810
	811	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	812
	813	func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
	814	var _p0 *byte
	815	_p0, err = BytePtrFromString(path)
	816	if err != nil {
	817	return
	818	}
	819	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	820	if e1 != 0 {
	821	err = errnoErr(e1)
	822	}
	823	return
	824	}
	825
	826	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	827
	828	func Flock(fd int, how int) (err error) {
	829	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
	830	if e1 != 0 {
	831	err = errnoErr(e1)
	832	}
	833	return
	834	}
	835
	836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	837
	838	func Fpathconf(fd int, name int) (val int, err error) {
	839	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	840	val = int(r0)
	841	if e1 != 0 {
	842	err = errnoErr(e1)
	843	}
	844	return
	845	}
	846
	847	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	848
	849	func Fsync(fd int) (err error) {
	850	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
	851	if e1 != 0 {
	852	err = errnoErr(e1)
	853	}
	854	return
	855	}
	856
	857	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	858
	859	func Ftruncate(fd int, length int64) (err error) {
	860	_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), uintptr(length>>32))
	861	if e1 != 0 {
	862	err = errnoErr(e1)
	863	}
	864	return
	865	}
	866
	867	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	868
	869	func Getdtablesize() (size int) {
	870	r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	871	size = int(r0)
	872	return
	873	}
	874
	875	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	876
	877	func Getegid() (egid int) {
	878	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	879	egid = int(r0)
	880	return
	881	}
	882
	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	884
	885	func Geteuid() (uid int) {
	886	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	887	uid = int(r0)
	888	return
	889	}
	890
	891	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	892
	893	func Getgid() (gid int) {
	894	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	895	gid = int(r0)
	896	return
	897	}
	898
	899	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	900
	901	func Getpgid(pid int) (pgid int, err error) {
	902	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	903	pgid = int(r0)
	904	if e1 != 0 {
	905	err = errnoErr(e1)
	906	}
	907	return
	908	}
	909
	910	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	911
	912	func Getpgrp() (pgrp int) {
	913	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	914	pgrp = int(r0)
	915	return
	916	}
	917
	918	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	919
	920	func Getpid() (pid int) {
	921	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	922	pid = int(r0)
	923	return
	924	}
	925
	926	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	927
	928	func Getppid() (ppid int) {
	929	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	930	ppid = int(r0)
	931	return
	932	}
	933
	934	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	935
	936	func Getpriority(which int, who int) (prio int, err error) {
	937	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	938	prio = int(r0)
	939	if e1 != 0 {
	940	err = errnoErr(e1)
	941	}
	942	return
	943	}
	944
	945	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	946
	947	func Getrlimit(which int, lim *Rlimit) (err error) {
	948	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	949	if e1 != 0 {
	950	err = errnoErr(e1)
	951	}
	952	return
	953	}
	954
	955	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	956
	957	func Getrusage(who int, rusage *Rusage) (err error) {
	958	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	959	if e1 != 0 {
	960	err = errnoErr(e1)
	961	}
	962	return
	963	}
	964
	965	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	966
	967	func Getsid(pid int) (sid int, err error) {
	968	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	969	sid = int(r0)
	970	if e1 != 0 {
	971	err = errnoErr(e1)
	972	}
	973	return
	974	}
	975
	976	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	977
	978	func Getuid() (uid int) {
	979	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	980	uid = int(r0)
	981	return
	982	}
	983
	984	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	985
	986	func Issetugid() (tainted bool) {
	987	r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	988	tainted = bool(r0 != 0)
	989	return
	990	}
	991
	992	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	993
	994	func Kqueue() (fd int, err error) {
	995	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	996	fd = int(r0)
	997	if e1 != 0 {
	998	err = errnoErr(e1)
	999	}
	1000	return
	1001	}
	1002
	1003	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1004
	1005	func Lchown(path string, uid int, gid int) (err error) {
	1006	var _p0 *byte
	1007	_p0, err = BytePtrFromString(path)
	1008	if err != nil {
	1009	return
	1010	}
	1011	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1012	if e1 != 0 {
	1013	err = errnoErr(e1)
	1014	}
	1015	return
	1016	}
	1017
	1018	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1019
	1020	func Link(path string, link string) (err error) {
	1021	var _p0 *byte
	1022	_p0, err = BytePtrFromString(path)
	1023	if err != nil {
	1024	return
	1025	}
	1026	var _p1 *byte
	1027	_p1, err = BytePtrFromString(link)
	1028	if err != nil {
	1029	return
	1030	}
	1031	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1032	if e1 != 0 {
	1033	err = errnoErr(e1)
	1034	}
	1035	return
	1036	}
	1037
	1038	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1039
	1040	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1041	var _p0 *byte
	1042	_p0, err = BytePtrFromString(path)
	1043	if err != nil {
	1044	return
	1045	}
	1046	var _p1 *byte
	1047	_p1, err = BytePtrFromString(link)
	1048	if err != nil {
	1049	return
	1050	}
	1051	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1052	if e1 != 0 {
	1053	err = errnoErr(e1)
	1054	}
	1055	return
	1056	}
	1057
	1058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1059
	1060	func Listen(s int, backlog int) (err error) {
	1061	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
	1062	if e1 != 0 {
	1063	err = errnoErr(e1)
	1064	}
	1065	return
	1066	}
	1067
	1068	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1069
	1070	func Mkdir(path string, mode uint32) (err error) {
	1071	var _p0 *byte
	1072	_p0, err = BytePtrFromString(path)
	1073	if err != nil {
	1074	return
	1075	}
	1076	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1077	if e1 != 0 {
	1078	err = errnoErr(e1)
	1079	}
	1080	return
	1081	}
	1082
	1083	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1084
	1085	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1086	var _p0 *byte
	1087	_p0, err = BytePtrFromString(path)
	1088	if err != nil {
	1089	return
	1090	}
	1091	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1092	if e1 != 0 {
	1093	err = errnoErr(e1)
	1094	}
	1095	return
	1096	}
	1097
	1098	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1099
	1100	func Mkfifo(path string, mode uint32) (err error) {
	1101	var _p0 *byte
	1102	_p0, err = BytePtrFromString(path)
	1103	if err != nil {
	1104	return
	1105	}
	1106	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1107	if e1 != 0 {
	1108	err = errnoErr(e1)
	1109	}
	1110	return
	1111	}
	1112
	1113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1114
	1115	func Mknod(path string, mode uint32, dev int) (err error) {
	1116	var _p0 *byte
	1117	_p0, err = BytePtrFromString(path)
	1118	if err != nil {
	1119	return
	1120	}
	1121	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1122	if e1 != 0 {
	1123	err = errnoErr(e1)
	1124	}
	1125	return
	1126	}
	1127
	1128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1129
	1130	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1131	var _p0 *byte
	1132	_p0, err = BytePtrFromString(path)
	1133	if err != nil {
	1134	return
	1135	}
	1136	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1137	fd = int(r0)
	1138	if e1 != 0 {
	1139	err = errnoErr(e1)
	1140	}
	1141	return
	1142	}
	1143
	1144	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1145
	1146	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1147	var _p0 *byte
	1148	_p0, err = BytePtrFromString(path)
	1149	if err != nil {
	1150	return
	1151	}
	1152	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1153	fd = int(r0)
	1154	if e1 != 0 {
	1155	err = errnoErr(e1)
	1156	}
	1157	return
	1158	}
	1159
	1160	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1161
	1162	func Pathconf(path string, name int) (val int, err error) {
	1163	var _p0 *byte
	1164	_p0, err = BytePtrFromString(path)
	1165	if err != nil {
	1166	return
	1167	}
	1168	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1169	val = int(r0)
	1170	if e1 != 0 {
	1171	err = errnoErr(e1)
	1172	}
	1173	return
	1174	}
	1175
	1176	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1177
	1178	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1179	var _p0 unsafe.Pointer
	1180	if len(p) > 0 {
	1181	_p0 = unsafe.Pointer(&p[0])
	1182	} else {
	1183	_p0 = unsafe.Pointer(&_zero)
	1184	}
	1185	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1186	n = int(r0)
	1187	if e1 != 0 {
	1188	err = errnoErr(e1)
	1189	}
	1190	return
	1191	}
	1192
	1193	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1194
	1195	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1196	var _p0 unsafe.Pointer
	1197	if len(p) > 0 {
	1198	_p0 = unsafe.Pointer(&p[0])
	1199	} else {
	1200	_p0 = unsafe.Pointer(&_zero)
	1201	}
	1202	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1203	n = int(r0)
	1204	if e1 != 0 {
	1205	err = errnoErr(e1)
	1206	}
	1207	return
	1208	}
	1209
	1210	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1211
	1212	func read(fd int, p []byte) (n int, err error) {
	1213	var _p0 unsafe.Pointer
	1214	if len(p) > 0 {
	1215	_p0 = unsafe.Pointer(&p[0])
	1216	} else {
	1217	_p0 = unsafe.Pointer(&_zero)
	1218	}
	1219	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1220	n = int(r0)
	1221	if e1 != 0 {
	1222	err = errnoErr(e1)
	1223	}
	1224	return
	1225	}
	1226
	1227	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1228
	1229	func Readlink(path string, buf []byte) (n int, err error) {
	1230	var _p0 *byte
	1231	_p0, err = BytePtrFromString(path)
	1232	if err != nil {
	1233	return
	1234	}
	1235	var _p1 unsafe.Pointer
	1236	if len(buf) > 0 {
	1237	_p1 = unsafe.Pointer(&buf[0])
	1238	} else {
	1239	_p1 = unsafe.Pointer(&_zero)
	1240	}
	1241	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1242	n = int(r0)
	1243	if e1 != 0 {
	1244	err = errnoErr(e1)
	1245	}
	1246	return
	1247	}
	1248
	1249	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1250
	1251	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1252	var _p0 *byte
	1253	_p0, err = BytePtrFromString(path)
	1254	if err != nil {
	1255	return
	1256	}
	1257	var _p1 unsafe.Pointer
	1258	if len(buf) > 0 {
	1259	_p1 = unsafe.Pointer(&buf[0])
	1260	} else {
	1261	_p1 = unsafe.Pointer(&_zero)
	1262	}
	1263	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1264	n = int(r0)
	1265	if e1 != 0 {
	1266	err = errnoErr(e1)
	1267	}
	1268	return
	1269	}
	1270
	1271	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1272
	1273	func Rename(from string, to string) (err error) {
	1274	var _p0 *byte
	1275	_p0, err = BytePtrFromString(from)
	1276	if err != nil {
	1277	return
	1278	}
	1279	var _p1 *byte
	1280	_p1, err = BytePtrFromString(to)
	1281	if err != nil {
	1282	return
	1283	}
	1284	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1285	if e1 != 0 {
	1286	err = errnoErr(e1)
	1287	}
	1288	return
	1289	}
	1290
	1291	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1292
	1293	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1294	var _p0 *byte
	1295	_p0, err = BytePtrFromString(from)
	1296	if err != nil {
	1297	return
	1298	}
	1299	var _p1 *byte
	1300	_p1, err = BytePtrFromString(to)
	1301	if err != nil {
	1302	return
	1303	}
	1304	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1305	if e1 != 0 {
	1306	err = errnoErr(e1)
	1307	}
	1308	return
	1309	}
	1310
	1311	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1312
	1313	func Revoke(path string) (err error) {
	1314	var _p0 *byte
	1315	_p0, err = BytePtrFromString(path)
	1316	if err != nil {
	1317	return
	1318	}
	1319	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1320	if e1 != 0 {
	1321	err = errnoErr(e1)
	1322	}
	1323	return
	1324	}
	1325
	1326	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1327
	1328	func Rmdir(path string) (err error) {
	1329	var _p0 *byte
	1330	_p0, err = BytePtrFromString(path)
	1331	if err != nil {
	1332	return
	1333	}
	1334	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1335	if e1 != 0 {
	1336	err = errnoErr(e1)
	1337	}
	1338	return
	1339	}
	1340
	1341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1342
	1343	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1344	r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
	1345	newoffset = int64(int64(r1)<<32 \| int64(r0))
	1346	if e1 != 0 {
	1347	err = errnoErr(e1)
	1348	}
	1349	return
	1350	}
	1351
	1352	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1353
	1354	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1355	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
	1356	if e1 != 0 {
	1357	err = errnoErr(e1)
	1358	}
	1359	return
	1360	}
	1361
	1362	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1363
	1364	func Setegid(egid int) (err error) {
	1365	_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
	1366	if e1 != 0 {
	1367	err = errnoErr(e1)
	1368	}
	1369	return
	1370	}
	1371
	1372	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1373
	1374	func Seteuid(euid int) (err error) {
	1375	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
	1376	if e1 != 0 {
	1377	err = errnoErr(e1)
	1378	}
	1379	return
	1380	}
	1381
	1382	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1383
	1384	func Setgid(gid int) (err error) {
	1385	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
	1386	if e1 != 0 {
	1387	err = errnoErr(e1)
	1388	}
	1389	return
	1390	}
	1391
	1392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1393
	1394	func Setlogin(name string) (err error) {
	1395	var _p0 *byte
	1396	_p0, err = BytePtrFromString(name)
	1397	if err != nil {
	1398	return
	1399	}
	1400	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1401	if e1 != 0 {
	1402	err = errnoErr(e1)
	1403	}
	1404	return
	1405	}
	1406
	1407	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1408
	1409	func Setpgid(pid int, pgid int) (err error) {
	1410	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
	1411	if e1 != 0 {
	1412	err = errnoErr(e1)
	1413	}
	1414	return
	1415	}
	1416
	1417	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1418
	1419	func Setpriority(which int, who int, prio int) (err error) {
	1420	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
	1421	if e1 != 0 {
	1422	err = errnoErr(e1)
	1423	}
	1424	return
	1425	}
	1426
	1427	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1428
	1429	func Setprivexec(flag int) (err error) {
	1430	_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
	1431	if e1 != 0 {
	1432	err = errnoErr(e1)
	1433	}
	1434	return
	1435	}
	1436
	1437	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1438
	1439	func Setregid(rgid int, egid int) (err error) {
	1440	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
	1441	if e1 != 0 {
	1442	err = errnoErr(e1)
	1443	}
	1444	return
	1445	}
	1446
	1447	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1448
	1449	func Setreuid(ruid int, euid int) (err error) {
	1450	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
	1451	if e1 != 0 {
	1452	err = errnoErr(e1)
	1453	}
	1454	return
	1455	}
	1456
	1457	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1458
	1459	func Setrlimit(which int, lim *Rlimit) (err error) {
	1460	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1461	if e1 != 0 {
	1462	err = errnoErr(e1)
	1463	}
	1464	return
	1465	}
	1466
	1467	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1468
	1469	func Setsid() (pid int, err error) {
	1470	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	1471	pid = int(r0)
	1472	if e1 != 0 {
	1473	err = errnoErr(e1)
	1474	}
	1475	return
	1476	}
	1477
	1478	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1479
	1480	func Settimeofday(tp *Timeval) (err error) {
	1481	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1482	if e1 != 0 {
	1483	err = errnoErr(e1)
	1484	}
	1485	return
	1486	}
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Setuid(uid int) (err error) {
	1491	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1499
	1500	func Symlink(path string, link string) (err error) {
	1501	var _p0 *byte
	1502	_p0, err = BytePtrFromString(path)
	1503	if err != nil {
	1504	return
	1505	}
	1506	var _p1 *byte
	1507	_p1, err = BytePtrFromString(link)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1519
	1520	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	1521	var _p0 *byte
	1522	_p0, err = BytePtrFromString(oldpath)
	1523	if err != nil {
	1524	return
	1525	}
	1526	var _p1 *byte
	1527	_p1, err = BytePtrFromString(newpath)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1539
	1540	func Sync() (err error) {
	1541	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
	1542	if e1 != 0 {
	1543	err = errnoErr(e1)
	1544	}
	1545	return
	1546	}
	1547
	1548	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1549
	1550	func Truncate(path string, length int64) (err error) {
	1551	var _p0 *byte
	1552	_p0, err = BytePtrFromString(path)
	1553	if err != nil {
	1554	return
	1555	}
	1556	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
	1557	if e1 != 0 {
	1558	err = errnoErr(e1)
	1559	}
	1560	return
	1561	}
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Umask(newmask int) (oldmask int) {
	1566	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	1567	oldmask = int(r0)
	1568	return
	1569	}
	1570
	1571	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1572
	1573	func Undelete(path string) (err error) {
	1574	var _p0 *byte
	1575	_p0, err = BytePtrFromString(path)
	1576	if err != nil {
	1577	return
	1578	}
	1579	_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1580	if e1 != 0 {
	1581	err = errnoErr(e1)
	1582	}
	1583	return
	1584	}
	1585
	1586	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1587
	1588	func Unlink(path string) (err error) {
	1589	var _p0 *byte
	1590	_p0, err = BytePtrFromString(path)
	1591	if err != nil {
	1592	return
	1593	}
	1594	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1595	if e1 != 0 {
	1596	err = errnoErr(e1)
	1597	}
	1598	return
	1599	}
	1600
	1601	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1602
	1603	func Unlinkat(dirfd int, path string, flags int) (err error) {
	1604	var _p0 *byte
	1605	_p0, err = BytePtrFromString(path)
	1606	if err != nil {
	1607	return
	1608	}
	1609	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	1610	if e1 != 0 {
	1611	err = errnoErr(e1)
	1612	}
	1613	return
	1614	}
	1615
	1616	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1617
	1618	func Unmount(path string, flags int) (err error) {
	1619	var _p0 *byte
	1620	_p0, err = BytePtrFromString(path)
	1621	if err != nil {
	1622	return
	1623	}
	1624	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	1625	if e1 != 0 {
	1626	err = errnoErr(e1)
	1627	}
	1628	return
	1629	}
	1630
	1631	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1632
	1633	func write(fd int, p []byte) (n int, err error) {
	1634	var _p0 unsafe.Pointer
	1635	if len(p) > 0 {
	1636	_p0 = unsafe.Pointer(&p[0])
	1637	} else {
	1638	_p0 = unsafe.Pointer(&_zero)
	1639	}
	1640	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1641	n = int(r0)
	1642	if e1 != 0 {
	1643	err = errnoErr(e1)
	1644	}
	1645	return
	1646	}
	1647
	1648	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1649
	1650	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	1651	r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
	1652	ret = uintptr(r0)
	1653	if e1 != 0 {
	1654	err = errnoErr(e1)
	1655	}
	1656	return
	1657	}
	1658
	1659	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1660
	1661	func munmap(addr uintptr, length uintptr) (err error) {
	1662	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
	1663	if e1 != 0 {
	1664	err = errnoErr(e1)
	1665	}
	1666	return
	1667	}
	1668
	1669	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1670
	1671	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	1672	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1673	n = int(r0)
	1674	if e1 != 0 {
	1675	err = errnoErr(e1)
	1676	}
	1677	return
	1678	}
	1679
	1680	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1681
	1682	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	1683	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1684	n = int(r0)
	1685	if e1 != 0 {
	1686	err = errnoErr(e1)
	1687	}
	1688	return
	1689	}
	1690
	1691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1692
	1693	func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
	1694	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1695	sec = int32(r0)
	1696	usec = int32(r1)
	1697	if e1 != 0 {
	1698	err = errnoErr(e1)
	1699	}
	1700	return
	1701	}
	1702
	1703	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1704
	1705	func Fstat(fd int, stat *Stat_t) (err error) {
	1706	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1707	if e1 != 0 {
	1708	err = errnoErr(e1)
	1709	}
	1710	return
	1711	}
	1712
	1713	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1714
	1715	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	1716	var _p0 *byte
	1717	_p0, err = BytePtrFromString(path)
	1718	if err != nil {
	1719	return
	1720	}
	1721	_, _, e1 := Syscall6(SYS_FSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	1722	if e1 != 0 {
	1723	err = errnoErr(e1)
	1724	}
	1725	return
	1726	}
	1727
	1728	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1729
	1730	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	1731	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1732	if e1 != 0 {
	1733	err = errnoErr(e1)
	1734	}
	1735	return
	1736	}
	1737
	1738	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1739
	1740	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	1741	r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(buf), uintptr(size), uintptr(flags))
	1742	n = int(r0)
	1743	if e1 != 0 {
	1744	err = errnoErr(e1)
	1745	}
	1746	return
	1747	}
	1748
	1749	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1750
	1751	func Lstat(path string, stat *Stat_t) (err error) {
	1752	var _p0 *byte
	1753	_p0, err = BytePtrFromString(path)
	1754	if err != nil {
	1755	return
	1756	}
	1757	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1758	if e1 != 0 {
	1759	err = errnoErr(e1)
	1760	}
	1761	return
	1762	}
	1763
	1764	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1765
	1766	func Stat(path string, stat *Stat_t) (err error) {
	1767	var _p0 *byte
	1768	_p0, err = BytePtrFromString(path)
	1769	if err != nil {
	1770	return
	1771	}
	1772	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1773	if e1 != 0 {
	1774	err = errnoErr(e1)
	1775	}
	1776	return
	1777	}
	1778
	1779	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1780
	1781	func Statfs(path string, stat *Statfs_t) (err error) {
	1782	var _p0 *byte
	1783	_p0, err = BytePtrFromString(path)
	1784	if err != nil {
	1785	return
	1786	}
	1787	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1788	if e1 != 0 {
	1789	err = errnoErr(e1)
	1790	}
	1791	return
	1792	}

+1359

-645

unix/zsyscall_darwin_arm.go less more

0		// go run mksyscall.go -l32 -tags darwin,arm syscall_bsd.go syscall_darwin.go syscall_darwin_arm.go
	0	// go run mksyscall.go -l32 -tags darwin,arm,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm.go
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3		// +build darwin,arm
	3	// +build darwin,arm,go1.12
4	4
5	5	package unix
6	6

14	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
15	15
16	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
17		r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	17	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
18	18	n = int(r0)
19	19	if e1 != 0 {
20	20	err = errnoErr(e1)

22	22	return
23	23	}
24	24
	25	func libc_getgroups_trampoline()
	26
	27	//go:linkname libc_getgroups libc_getgroups
	28	//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
	29
25	30	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
26	31
27	32	func setgroups(ngid int, gid *_Gid_t) (err error) {
28		_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
29		if e1 != 0 {
30		err = errnoErr(e1)
31		}
32		return
33		}
	33	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	34	if e1 != 0 {
	35	err = errnoErr(e1)
	36	}
	37	return
	38	}
	39
	40	func libc_setgroups_trampoline()
	41
	42	//go:linkname libc_setgroups libc_setgroups
	43	//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
34	44
35	45	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
36	46
37	47	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
38		r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	48	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
39	49	wpid = int(r0)
40	50	if e1 != 0 {
41	51	err = errnoErr(e1)

43	53	return
44	54	}
45	55
	56	func libc_wait4_trampoline()
	57
	58	//go:linkname libc_wait4 libc_wait4
	59	//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
	60
46	61	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
47	62
48	63	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
49		r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	64	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
50	65	fd = int(r0)
51	66	if e1 != 0 {
52	67	err = errnoErr(e1)

54	69	return
55	70	}
56	71
	72	func libc_accept_trampoline()
	73
	74	//go:linkname libc_accept libc_accept
	75	//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
	76
57	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
58	78
59	79	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
60		_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
61		if e1 != 0 {
62		err = errnoErr(e1)
63		}
64		return
65		}
	80	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	81	if e1 != 0 {
	82	err = errnoErr(e1)
	83	}
	84	return
	85	}
	86
	87	func libc_bind_trampoline()
	88
	89	//go:linkname libc_bind libc_bind
	90	//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
66	91
67	92	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
68	93
69	94	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
70		_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
71		if e1 != 0 {
72		err = errnoErr(e1)
73		}
74		return
75		}
	95	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	96	if e1 != 0 {
	97	err = errnoErr(e1)
	98	}
	99	return
	100	}
	101
	102	func libc_connect_trampoline()
	103
	104	//go:linkname libc_connect libc_connect
	105	//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
76	106
77	107	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
78	108
79	109	func socket(domain int, typ int, proto int) (fd int, err error) {
80		r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	110	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
81	111	fd = int(r0)
82	112	if e1 != 0 {
83	113	err = errnoErr(e1)

85	115	return
86	116	}
87	117
	118	func libc_socket_trampoline()
	119
	120	//go:linkname libc_socket libc_socket
	121	//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
	122
88	123	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
89	124
90	125	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
91		_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
92		if e1 != 0 {
93		err = errnoErr(e1)
94		}
95		return
96		}
	126	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	127	if e1 != 0 {
	128	err = errnoErr(e1)
	129	}
	130	return
	131	}
	132
	133	func libc_getsockopt_trampoline()
	134
	135	//go:linkname libc_getsockopt libc_getsockopt
	136	//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
97	137
98	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
99	139
100	140	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
101		_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
102		if e1 != 0 {
103		err = errnoErr(e1)
104		}
105		return
106		}
	141	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	func libc_setsockopt_trampoline()
	149
	150	//go:linkname libc_setsockopt libc_setsockopt
	151	//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
107	152
108	153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
109	154
110	155	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
111		_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
112		if e1 != 0 {
113		err = errnoErr(e1)
114		}
115		return
116		}
	156	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	157	if e1 != 0 {
	158	err = errnoErr(e1)
	159	}
	160	return
	161	}
	162
	163	func libc_getpeername_trampoline()
	164
	165	//go:linkname libc_getpeername libc_getpeername
	166	//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
117	167
118	168	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
119	169
120	170	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
121		_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
122		if e1 != 0 {
123		err = errnoErr(e1)
124		}
125		return
126		}
	171	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	172	if e1 != 0 {
	173	err = errnoErr(e1)
	174	}
	175	return
	176	}
	177
	178	func libc_getsockname_trampoline()
	179
	180	//go:linkname libc_getsockname libc_getsockname
	181	//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
127	182
128	183	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
129	184
130	185	func Shutdown(s int, how int) (err error) {
131		_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
132		if e1 != 0 {
133		err = errnoErr(e1)
134		}
135		return
136		}
	186	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
	187	if e1 != 0 {
	188	err = errnoErr(e1)
	189	}
	190	return
	191	}
	192
	193	func libc_shutdown_trampoline()
	194
	195	//go:linkname libc_shutdown libc_shutdown
	196	//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
137	197
138	198	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
139	199
140	200	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
141		_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
142		if e1 != 0 {
143		err = errnoErr(e1)
144		}
145		return
146		}
	201	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	202	if e1 != 0 {
	203	err = errnoErr(e1)
	204	}
	205	return
	206	}
	207
	208	func libc_socketpair_trampoline()
	209
	210	//go:linkname libc_socketpair libc_socketpair
	211	//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
147	212
148	213	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
149	214

154	219	} else {
155	220	_p0 = unsafe.Pointer(&_zero)
156	221	}
157		r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	222	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)))
158	223	n = int(r0)
159	224	if e1 != 0 {
160	225	err = errnoErr(e1)
161	226	}
162	227	return
163	228	}
	229
	230	func libc_recvfrom_trampoline()
	231
	232	//go:linkname libc_recvfrom libc_recvfrom
	233	//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
164	234
165	235	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
166	236

171	241	} else {
172	242	_p0 = unsafe.Pointer(&_zero)
173	243	}
174		_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
175		if e1 != 0 {
176		err = errnoErr(e1)
177		}
178		return
179		}
	244	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	245	if e1 != 0 {
	246	err = errnoErr(e1)
	247	}
	248	return
	249	}
	250
	251	func libc_sendto_trampoline()
	252
	253	//go:linkname libc_sendto libc_sendto
	254	//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
180	255
181	256	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
182	257
183	258	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
184		r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	259	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
185	260	n = int(r0)
186	261	if e1 != 0 {
187	262	err = errnoErr(e1)

189	264	return
190	265	}
191	266
	267	func libc_recvmsg_trampoline()
	268
	269	//go:linkname libc_recvmsg libc_recvmsg
	270	//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
	271
192	272	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
193	273
194	274	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
195		r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	275	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
196	276	n = int(r0)
197	277	if e1 != 0 {
198	278	err = errnoErr(e1)

200	280	return
201	281	}
202	282
	283	func libc_sendmsg_trampoline()
	284
	285	//go:linkname libc_sendmsg libc_sendmsg
	286	//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
	287
203	288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
204	289
205	290	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
206		r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	291	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
207	292	n = int(r0)
208	293	if e1 != 0 {
209	294	err = errnoErr(e1)
210	295	}
211	296	return
212	297	}
	298
	299	func libc_kevent_trampoline()
	300
	301	//go:linkname libc_kevent libc_kevent
	302	//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
213	303
214	304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
215	305

220	310	} else {
221	311	_p0 = unsafe.Pointer(&_zero)
222	312	}
223		_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
224		if e1 != 0 {
225		err = errnoErr(e1)
226		}
227		return
228		}
	313	_, _, 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))
	314	if e1 != 0 {
	315	err = errnoErr(e1)
	316	}
	317	return
	318	}
	319
	320	func libc___sysctl_trampoline()
	321
	322	//go:linkname libc___sysctl libc___sysctl
	323	//go:cgo_import_dynamic libc___sysctl __sysctl "/usr/lib/libSystem.B.dylib"
229	324
230	325	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
231	326

235	330	if err != nil {
236	331	return
237	332	}
238		_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
239		if e1 != 0 {
240		err = errnoErr(e1)
241		}
242		return
243		}
	333	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	334	if e1 != 0 {
	335	err = errnoErr(e1)
	336	}
	337	return
	338	}
	339
	340	func libc_utimes_trampoline()
	341
	342	//go:linkname libc_utimes libc_utimes
	343	//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
244	344
245	345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
246	346
247	347	func futimes(fd int, timeval *[2]Timeval) (err error) {
248		_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
249		if e1 != 0 {
250		err = errnoErr(e1)
251		}
252		return
253		}
	348	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	349	if e1 != 0 {
	350	err = errnoErr(e1)
	351	}
	352	return
	353	}
	354
	355	func libc_futimes_trampoline()
	356
	357	//go:linkname libc_futimes libc_futimes
	358	//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
254	359
255	360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
256	361
257	362	func fcntl(fd int, cmd int, arg int) (val int, err error) {
258		r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	363	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
259	364	val = int(r0)
260	365	if e1 != 0 {
261	366	err = errnoErr(e1)

263	368	return
264	369	}
265	370
	371	func libc_fcntl_trampoline()
	372
	373	//go:linkname libc_fcntl libc_fcntl
	374	//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
	375
266	376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
267	377
268	378	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
269		r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	379	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
270	380	n = int(r0)
271	381	if e1 != 0 {
272	382	err = errnoErr(e1)
273	383	}
274	384	return
275	385	}
	386
	387	func libc_poll_trampoline()
	388
	389	//go:linkname libc_poll libc_poll
	390	//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
276	391
277	392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
278	393

283	398	} else {
284	399	_p0 = unsafe.Pointer(&_zero)
285	400	}
286		_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
287		if e1 != 0 {
288		err = errnoErr(e1)
289		}
290		return
291		}
	401	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
	402	if e1 != 0 {
	403	err = errnoErr(e1)
	404	}
	405	return
	406	}
	407
	408	func libc_madvise_trampoline()
	409
	410	//go:linkname libc_madvise libc_madvise
	411	//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
292	412
293	413	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
294	414

299	419	} else {
300	420	_p0 = unsafe.Pointer(&_zero)
301	421	}
302		_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
303		if e1 != 0 {
304		err = errnoErr(e1)
305		}
306		return
307		}
	422	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	423	if e1 != 0 {
	424	err = errnoErr(e1)
	425	}
	426	return
	427	}
	428
	429	func libc_mlock_trampoline()
	430
	431	//go:linkname libc_mlock libc_mlock
	432	//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
308	433
309	434	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
310	435
311	436	func Mlockall(flags int) (err error) {
312		_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
313		if e1 != 0 {
314		err = errnoErr(e1)
315		}
316		return
317		}
	437	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
	438	if e1 != 0 {
	439	err = errnoErr(e1)
	440	}
	441	return
	442	}
	443
	444	func libc_mlockall_trampoline()
	445
	446	//go:linkname libc_mlockall libc_mlockall
	447	//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
318	448
319	449	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
320	450

325	455	} else {
326	456	_p0 = unsafe.Pointer(&_zero)
327	457	}
328		_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
329		if e1 != 0 {
330		err = errnoErr(e1)
331		}
332		return
333		}
	458	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
	459	if e1 != 0 {
	460	err = errnoErr(e1)
	461	}
	462	return
	463	}
	464
	465	func libc_mprotect_trampoline()
	466
	467	//go:linkname libc_mprotect libc_mprotect
	468	//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
334	469
335	470	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
336	471

341	476	} else {
342	477	_p0 = unsafe.Pointer(&_zero)
343	478	}
344		_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
345		if e1 != 0 {
346		err = errnoErr(e1)
347		}
348		return
349		}
	479	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
	480	if e1 != 0 {
	481	err = errnoErr(e1)
	482	}
	483	return
	484	}
	485
	486	func libc_msync_trampoline()
	487
	488	//go:linkname libc_msync libc_msync
	489	//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
350	490
351	491	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
352	492

357	497	} else {
358	498	_p0 = unsafe.Pointer(&_zero)
359	499	}
360		_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
361		if e1 != 0 {
362		err = errnoErr(e1)
363		}
364		return
365		}
	500	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	501	if e1 != 0 {
	502	err = errnoErr(e1)
	503	}
	504	return
	505	}
	506
	507	func libc_munlock_trampoline()
	508
	509	//go:linkname libc_munlock libc_munlock
	510	//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
366	511
367	512	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
368	513
369	514	func Munlockall() (err error) {
370		_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
371		if e1 != 0 {
372		err = errnoErr(e1)
373		}
374		return
375		}
	515	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
	516	if e1 != 0 {
	517	err = errnoErr(e1)
	518	}
	519	return
	520	}
	521
	522	func libc_munlockall_trampoline()
	523
	524	//go:linkname libc_munlockall libc_munlockall
	525	//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
376	526
377	527	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
378	528
379	529	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
380		_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
381		if e1 != 0 {
382		err = errnoErr(e1)
383		}
384		return
385		}
	530	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	531	if e1 != 0 {
	532	err = errnoErr(e1)
	533	}
	534	return
	535	}
	536
	537	func libc_ptrace_trampoline()
	538
	539	//go:linkname libc_ptrace libc_ptrace
	540	//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
	541
	542	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	543
	544	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	545	_, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	546	if e1 != 0 {
	547	err = errnoErr(e1)
	548	}
	549	return
	550	}
	551
	552	func libc_getattrlist_trampoline()
	553
	554	//go:linkname libc_getattrlist libc_getattrlist
	555	//go:cgo_import_dynamic libc_getattrlist getattrlist "/usr/lib/libSystem.B.dylib"
386	556
387	557	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
388	558
389	559	func pipe() (r int, w int, err error) {
390		r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	560	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
391	561	r = int(r0)
392	562	w = int(r1)
393	563	if e1 != 0 {

396	566	return
397	567	}
398	568
	569	func libc_pipe_trampoline()
	570
	571	//go:linkname libc_pipe libc_pipe
	572	//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
	573
399	574	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
400	575
401	576	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

409	584	if err != nil {
410	585	return
411	586	}
412		r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	587	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))
413	588	sz = int(r0)
414	589	if e1 != 0 {
415	590	err = errnoErr(e1)

417	592	return
418	593	}
419	594
	595	func libc_getxattr_trampoline()
	596
	597	//go:linkname libc_getxattr libc_getxattr
	598	//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
	599
420	600	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
421	601
422	602	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

425	605	if err != nil {
426	606	return
427	607	}
428		r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	608	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
429	609	sz = int(r0)
430	610	if e1 != 0 {
431	611	err = errnoErr(e1)
432	612	}
433	613	return
434	614	}
	615
	616	func libc_fgetxattr_trampoline()
	617
	618	//go:linkname libc_fgetxattr libc_fgetxattr
	619	//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
435	620
436	621	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
437	622

446	631	if err != nil {
447	632	return
448	633	}
449		_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
450		if e1 != 0 {
451		err = errnoErr(e1)
452		}
453		return
454		}
	634	_, _, 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))
	635	if e1 != 0 {
	636	err = errnoErr(e1)
	637	}
	638	return
	639	}
	640
	641	func libc_setxattr_trampoline()
	642
	643	//go:linkname libc_setxattr libc_setxattr
	644	//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
455	645
456	646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
457	647

461	651	if err != nil {
462	652	return
463	653	}
464		_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
465		if e1 != 0 {
466		err = errnoErr(e1)
467		}
468		return
469		}
	654	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	655	if e1 != 0 {
	656	err = errnoErr(e1)
	657	}
	658	return
	659	}
	660
	661	func libc_fsetxattr_trampoline()
	662
	663	//go:linkname libc_fsetxattr libc_fsetxattr
	664	//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
470	665
471	666	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
472	667

481	676	if err != nil {
482	677	return
483	678	}
484		_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
485		if e1 != 0 {
486		err = errnoErr(e1)
487		}
488		return
489		}
	679	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	680	if e1 != 0 {
	681	err = errnoErr(e1)
	682	}
	683	return
	684	}
	685
	686	func libc_removexattr_trampoline()
	687
	688	//go:linkname libc_removexattr libc_removexattr
	689	//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
490	690
491	691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
492	692

496	696	if err != nil {
497	697	return
498	698	}
499		_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
500		if e1 != 0 {
501		err = errnoErr(e1)
502		}
503		return
504		}
	699	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	700	if e1 != 0 {
	701	err = errnoErr(e1)
	702	}
	703	return
	704	}
	705
	706	func libc_fremovexattr_trampoline()
	707
	708	//go:linkname libc_fremovexattr libc_fremovexattr
	709	//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
505	710
506	711	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
507	712

511	716	if err != nil {
512	717	return
513	718	}
514		r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	719	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
515	720	sz = int(r0)
516	721	if e1 != 0 {
517	722	err = errnoErr(e1)

519	724	return
520	725	}
521	726
	727	func libc_listxattr_trampoline()
	728
	729	//go:linkname libc_listxattr libc_listxattr
	730	//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
	731
522	732	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
523	733
524	734	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
525		r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	735	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
526	736	sz = int(r0)
527	737	if e1 != 0 {
528	738	err = errnoErr(e1)

530	740	return
531	741	}
532	742
	743	func libc_flistxattr_trampoline()
	744
	745	//go:linkname libc_flistxattr libc_flistxattr
	746	//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
	747
	748	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	749
	750	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	751	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	752	if e1 != 0 {
	753	err = errnoErr(e1)
	754	}
	755	return
	756	}
	757
	758	func libc_setattrlist_trampoline()
	759
	760	//go:linkname libc_setattrlist libc_setattrlist
	761	//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
	762
533	763	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
534	764
535	765	func kill(pid int, signum int, posix int) (err error) {
536		_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
537		if e1 != 0 {
538		err = errnoErr(e1)
539		}
540		return
541		}
	766	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
	767	if e1 != 0 {
	768	err = errnoErr(e1)
	769	}
	770	return
	771	}
	772
	773	func libc_kill_trampoline()
	774
	775	//go:linkname libc_kill libc_kill
	776	//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
542	777
543	778	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
544	779
545	780	func ioctl(fd int, req uint, arg uintptr) (err error) {
546		_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
547		if e1 != 0 {
548		err = errnoErr(e1)
549		}
550		return
551		}
	781	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
	782	if e1 != 0 {
	783	err = errnoErr(e1)
	784	}
	785	return
	786	}
	787
	788	func libc_ioctl_trampoline()
	789
	790	//go:linkname libc_ioctl libc_ioctl
	791	//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
	792
	793	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	794
	795	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	796	_, _, e1 := syscall_syscall9(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(offset>>32), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags), 0, 0)
	797	if e1 != 0 {
	798	err = errnoErr(e1)
	799	}
	800	return
	801	}
	802
	803	func libc_sendfile_trampoline()
	804
	805	//go:linkname libc_sendfile libc_sendfile
	806	//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
552	807
553	808	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
554	809

558	813	if err != nil {
559	814	return
560	815	}
561		_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
562		if e1 != 0 {
563		err = errnoErr(e1)
564		}
565		return
566		}
	816	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	817	if e1 != 0 {
	818	err = errnoErr(e1)
	819	}
	820	return
	821	}
	822
	823	func libc_access_trampoline()
	824
	825	//go:linkname libc_access libc_access
	826	//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
567	827
568	828	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
569	829
570	830	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
571		_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
572		if e1 != 0 {
573		err = errnoErr(e1)
574		}
575		return
576		}
	831	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	832	if e1 != 0 {
	833	err = errnoErr(e1)
	834	}
	835	return
	836	}
	837
	838	func libc_adjtime_trampoline()
	839
	840	//go:linkname libc_adjtime libc_adjtime
	841	//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
577	842
578	843	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
579	844

583	848	if err != nil {
584	849	return
585	850	}
586		_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
587		if e1 != 0 {
588		err = errnoErr(e1)
589		}
590		return
591		}
	851	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	852	if e1 != 0 {
	853	err = errnoErr(e1)
	854	}
	855	return
	856	}
	857
	858	func libc_chdir_trampoline()
	859
	860	//go:linkname libc_chdir libc_chdir
	861	//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
592	862
593	863	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
594	864

598	868	if err != nil {
599	869	return
600	870	}
601		_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
602		if e1 != 0 {
603		err = errnoErr(e1)
604		}
605		return
606		}
	871	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	872	if e1 != 0 {
	873	err = errnoErr(e1)
	874	}
	875	return
	876	}
	877
	878	func libc_chflags_trampoline()
	879
	880	//go:linkname libc_chflags libc_chflags
	881	//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
607	882
608	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
609	884

613	888	if err != nil {
614	889	return
615	890	}
616		_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
617		if e1 != 0 {
618		err = errnoErr(e1)
619		}
620		return
621		}
	891	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	892	if e1 != 0 {
	893	err = errnoErr(e1)
	894	}
	895	return
	896	}
	897
	898	func libc_chmod_trampoline()
	899
	900	//go:linkname libc_chmod libc_chmod
	901	//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
622	902
623	903	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
624	904

628	908	if err != nil {
629	909	return
630	910	}
631		_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
632		if e1 != 0 {
633		err = errnoErr(e1)
634		}
635		return
636		}
	911	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	912	if e1 != 0 {
	913	err = errnoErr(e1)
	914	}
	915	return
	916	}
	917
	918	func libc_chown_trampoline()
	919
	920	//go:linkname libc_chown libc_chown
	921	//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
637	922
638	923	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
639	924

643	928	if err != nil {
644	929	return
645	930	}
646		_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
647		if e1 != 0 {
648		err = errnoErr(e1)
649		}
650		return
651		}
	931	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	932	if e1 != 0 {
	933	err = errnoErr(e1)
	934	}
	935	return
	936	}
	937
	938	func libc_chroot_trampoline()
	939
	940	//go:linkname libc_chroot libc_chroot
	941	//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
652	942
653	943	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
654	944
655	945	func Close(fd int) (err error) {
656		_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
657		if e1 != 0 {
658		err = errnoErr(e1)
659		}
660		return
661		}
	946	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
	947	if e1 != 0 {
	948	err = errnoErr(e1)
	949	}
	950	return
	951	}
	952
	953	func libc_close_trampoline()
	954
	955	//go:linkname libc_close libc_close
	956	//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
662	957
663	958	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664	959
665	960	func Dup(fd int) (nfd int, err error) {
666		r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	961	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
667	962	nfd = int(r0)
668	963	if e1 != 0 {
669	964	err = errnoErr(e1)

671	966	return
672	967	}
673	968
	969	func libc_dup_trampoline()
	970
	971	//go:linkname libc_dup libc_dup
	972	//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
	973
674	974	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
675	975
676	976	func Dup2(from int, to int) (err error) {
677		_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
678		if e1 != 0 {
679		err = errnoErr(e1)
680		}
681		return
682		}
	977	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
	978	if e1 != 0 {
	979	err = errnoErr(e1)
	980	}
	981	return
	982	}
	983
	984	func libc_dup2_trampoline()
	985
	986	//go:linkname libc_dup2 libc_dup2
	987	//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
683	988
684	989	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
685	990

694	999	if err != nil {
695	1000	return
696	1001	}
697		_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
698		if e1 != 0 {
699		err = errnoErr(e1)
700		}
701		return
702		}
	1002	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	1003	if e1 != 0 {
	1004	err = errnoErr(e1)
	1005	}
	1006	return
	1007	}
	1008
	1009	func libc_exchangedata_trampoline()
	1010
	1011	//go:linkname libc_exchangedata libc_exchangedata
	1012	//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
703	1013
704	1014	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
705	1015
706	1016	func Exit(code int) {
707		Syscall(SYS_EXIT, uintptr(code), 0, 0)
708		return
709		}
	1017	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
	1018	return
	1019	}
	1020
	1021	func libc_exit_trampoline()
	1022
	1023	//go:linkname libc_exit libc_exit
	1024	//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
710	1025
711	1026	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
712	1027

716	1031	if err != nil {
717	1032	return
718	1033	}
719		_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
720		if e1 != 0 {
721		err = errnoErr(e1)
722		}
723		return
724		}
	1034	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1035	if e1 != 0 {
	1036	err = errnoErr(e1)
	1037	}
	1038	return
	1039	}
	1040
	1041	func libc_faccessat_trampoline()
	1042
	1043	//go:linkname libc_faccessat libc_faccessat
	1044	//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
725	1045
726	1046	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
727	1047
728	1048	func Fchdir(fd int) (err error) {
729		_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
730		if e1 != 0 {
731		err = errnoErr(e1)
732		}
733		return
734		}
	1049	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
	1050	if e1 != 0 {
	1051	err = errnoErr(e1)
	1052	}
	1053	return
	1054	}
	1055
	1056	func libc_fchdir_trampoline()
	1057
	1058	//go:linkname libc_fchdir libc_fchdir
	1059	//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
735	1060
736	1061	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
737	1062
738	1063	func Fchflags(fd int, flags int) (err error) {
739		_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
740		if e1 != 0 {
741		err = errnoErr(e1)
742		}
743		return
744		}
	1064	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
	1065	if e1 != 0 {
	1066	err = errnoErr(e1)
	1067	}
	1068	return
	1069	}
	1070
	1071	func libc_fchflags_trampoline()
	1072
	1073	//go:linkname libc_fchflags libc_fchflags
	1074	//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
745	1075
746	1076	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
747	1077
748	1078	func Fchmod(fd int, mode uint32) (err error) {
749		_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
750		if e1 != 0 {
751		err = errnoErr(e1)
752		}
753		return
754		}
	1079	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
	1080	if e1 != 0 {
	1081	err = errnoErr(e1)
	1082	}
	1083	return
	1084	}
	1085
	1086	func libc_fchmod_trampoline()
	1087
	1088	//go:linkname libc_fchmod libc_fchmod
	1089	//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
755	1090
756	1091	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
757	1092

761	1096	if err != nil {
762	1097	return
763	1098	}
764		_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
765		if e1 != 0 {
766		err = errnoErr(e1)
767		}
768		return
769		}
	1099	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1100	if e1 != 0 {
	1101	err = errnoErr(e1)
	1102	}
	1103	return
	1104	}
	1105
	1106	func libc_fchmodat_trampoline()
	1107
	1108	//go:linkname libc_fchmodat libc_fchmodat
	1109	//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
770	1110
771	1111	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
772	1112
773	1113	func Fchown(fd int, uid int, gid int) (err error) {
774		_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
775		if e1 != 0 {
776		err = errnoErr(e1)
777		}
778		return
779		}
	1114	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
	1115	if e1 != 0 {
	1116	err = errnoErr(e1)
	1117	}
	1118	return
	1119	}
	1120
	1121	func libc_fchown_trampoline()
	1122
	1123	//go:linkname libc_fchown libc_fchown
	1124	//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
780	1125
781	1126	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
782	1127

786	1131	if err != nil {
787	1132	return
788	1133	}
789		_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
790		if e1 != 0 {
791		err = errnoErr(e1)
792		}
793		return
794		}
	1134	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	1135	if e1 != 0 {
	1136	err = errnoErr(e1)
	1137	}
	1138	return
	1139	}
	1140
	1141	func libc_fchownat_trampoline()
	1142
	1143	//go:linkname libc_fchownat libc_fchownat
	1144	//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
795	1145
796	1146	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
797	1147
798	1148	func Flock(fd int, how int) (err error) {
799		_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
800		if e1 != 0 {
801		err = errnoErr(e1)
802		}
803		return
804		}
	1149	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
	1150	if e1 != 0 {
	1151	err = errnoErr(e1)
	1152	}
	1153	return
	1154	}
	1155
	1156	func libc_flock_trampoline()
	1157
	1158	//go:linkname libc_flock libc_flock
	1159	//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
805	1160
806	1161	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
807	1162
808	1163	func Fpathconf(fd int, name int) (val int, err error) {
809		r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	1164	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
810	1165	val = int(r0)
811	1166	if e1 != 0 {
812	1167	err = errnoErr(e1)

814	1169	return
815	1170	}
816	1171
817		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
818
819		func Fstat(fd int, stat *Stat_t) (err error) {
820		_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
821		if e1 != 0 {
822		err = errnoErr(e1)
823		}
824		return
825		}
826
827		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
828
829		func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
830		var _p0 *byte
831		_p0, err = BytePtrFromString(path)
832		if err != nil {
833		return
834		}
835		_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
836		if e1 != 0 {
837		err = errnoErr(e1)
838		}
839		return
840		}
841
842		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
843
844		func Fstatfs(fd int, stat *Statfs_t) (err error) {
845		_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
846		if e1 != 0 {
847		err = errnoErr(e1)
848		}
849		return
850		}
	1172	func libc_fpathconf_trampoline()
	1173
	1174	//go:linkname libc_fpathconf libc_fpathconf
	1175	//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
851	1176
852	1177	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
853	1178
854	1179	func Fsync(fd int) (err error) {
855		_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
856		if e1 != 0 {
857		err = errnoErr(e1)
858		}
859		return
860		}
	1180	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
	1181	if e1 != 0 {
	1182	err = errnoErr(e1)
	1183	}
	1184	return
	1185	}
	1186
	1187	func libc_fsync_trampoline()
	1188
	1189	//go:linkname libc_fsync libc_fsync
	1190	//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
861	1191
862	1192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
863	1193
864	1194	func Ftruncate(fd int, length int64) (err error) {
865		_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), uintptr(length>>32))
866		if e1 != 0 {
867		err = errnoErr(e1)
868		}
869		return
870		}
871
872		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
873
874		func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
875		var _p0 unsafe.Pointer
876		if len(buf) > 0 {
877		_p0 = unsafe.Pointer(&buf[0])
878		} else {
879		_p0 = unsafe.Pointer(&_zero)
880		}
881		r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
882		n = int(r0)
883		if e1 != 0 {
884		err = errnoErr(e1)
885		}
886		return
887		}
	1195	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), uintptr(length>>32))
	1196	if e1 != 0 {
	1197	err = errnoErr(e1)
	1198	}
	1199	return
	1200	}
	1201
	1202	func libc_ftruncate_trampoline()
	1203
	1204	//go:linkname libc_ftruncate libc_ftruncate
	1205	//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
888	1206
889	1207	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
890	1208
891	1209	func Getdtablesize() (size int) {
892		r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	1210	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
893	1211	size = int(r0)
894	1212	return
895	1213	}
896	1214
	1215	func libc_getdtablesize_trampoline()
	1216
	1217	//go:linkname libc_getdtablesize libc_getdtablesize
	1218	//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
	1219
897	1220	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
898	1221
899	1222	func Getegid() (egid int) {
900		r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	1223	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
901	1224	egid = int(r0)
902	1225	return
903	1226	}
904	1227
	1228	func libc_getegid_trampoline()
	1229
	1230	//go:linkname libc_getegid libc_getegid
	1231	//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
	1232
905	1233	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
906	1234
907	1235	func Geteuid() (uid int) {
908		r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	1236	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
909	1237	uid = int(r0)
910	1238	return
911	1239	}
912	1240
	1241	func libc_geteuid_trampoline()
	1242
	1243	//go:linkname libc_geteuid libc_geteuid
	1244	//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
	1245
913	1246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
914	1247
915	1248	func Getgid() (gid int) {
916		r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	1249	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
917	1250	gid = int(r0)
918	1251	return
919	1252	}
920	1253
	1254	func libc_getgid_trampoline()
	1255
	1256	//go:linkname libc_getgid libc_getgid
	1257	//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
	1258
921	1259	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
922	1260
923	1261	func Getpgid(pid int) (pgid int, err error) {
924		r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	1262	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
925	1263	pgid = int(r0)
926	1264	if e1 != 0 {
927	1265	err = errnoErr(e1)

929	1267	return
930	1268	}
931	1269
	1270	func libc_getpgid_trampoline()
	1271
	1272	//go:linkname libc_getpgid libc_getpgid
	1273	//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
	1274
932	1275	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
933	1276
934	1277	func Getpgrp() (pgrp int) {
935		r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	1278	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
936	1279	pgrp = int(r0)
937	1280	return
938	1281	}
939	1282
	1283	func libc_getpgrp_trampoline()
	1284
	1285	//go:linkname libc_getpgrp libc_getpgrp
	1286	//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
	1287
940	1288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
941	1289
942	1290	func Getpid() (pid int) {
943		r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	1291	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
944	1292	pid = int(r0)
945	1293	return
946	1294	}
947	1295
	1296	func libc_getpid_trampoline()
	1297
	1298	//go:linkname libc_getpid libc_getpid
	1299	//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
	1300
948	1301	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
949	1302
950	1303	func Getppid() (ppid int) {
951		r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	1304	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
952	1305	ppid = int(r0)
953	1306	return
954	1307	}
955	1308
	1309	func libc_getppid_trampoline()
	1310
	1311	//go:linkname libc_getppid libc_getppid
	1312	//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
	1313
956	1314	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
957	1315
958	1316	func Getpriority(which int, who int) (prio int, err error) {
959		r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	1317	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
960	1318	prio = int(r0)
961	1319	if e1 != 0 {
962	1320	err = errnoErr(e1)

964	1322	return
965	1323	}
966	1324
	1325	func libc_getpriority_trampoline()
	1326
	1327	//go:linkname libc_getpriority libc_getpriority
	1328	//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
	1329
967	1330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
968	1331
969	1332	func Getrlimit(which int, lim *Rlimit) (err error) {
970		_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
971		if e1 != 0 {
972		err = errnoErr(e1)
973		}
974		return
975		}
	1333	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1334	if e1 != 0 {
	1335	err = errnoErr(e1)
	1336	}
	1337	return
	1338	}
	1339
	1340	func libc_getrlimit_trampoline()
	1341
	1342	//go:linkname libc_getrlimit libc_getrlimit
	1343	//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
976	1344
977	1345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
978	1346
979	1347	func Getrusage(who int, rusage *Rusage) (err error) {
980		_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
981		if e1 != 0 {
982		err = errnoErr(e1)
983		}
984		return
985		}
	1348	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	1349	if e1 != 0 {
	1350	err = errnoErr(e1)
	1351	}
	1352	return
	1353	}
	1354
	1355	func libc_getrusage_trampoline()
	1356
	1357	//go:linkname libc_getrusage libc_getrusage
	1358	//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
986	1359
987	1360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
988	1361
989	1362	func Getsid(pid int) (sid int, err error) {
990		r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	1363	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
991	1364	sid = int(r0)
992	1365	if e1 != 0 {
993	1366	err = errnoErr(e1)

995	1368	return
996	1369	}
997	1370
	1371	func libc_getsid_trampoline()
	1372
	1373	//go:linkname libc_getsid libc_getsid
	1374	//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
	1375
998	1376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
999	1377
1000	1378	func Getuid() (uid int) {
1001		r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	1379	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
1002	1380	uid = int(r0)
1003	1381	return
1004	1382	}
1005	1383
	1384	func libc_getuid_trampoline()
	1385
	1386	//go:linkname libc_getuid libc_getuid
	1387	//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
	1388
1006	1389	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1007	1390
1008	1391	func Issetugid() (tainted bool) {
1009		r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	1392	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
1010	1393	tainted = bool(r0 != 0)
1011	1394	return
1012	1395	}
1013	1396
	1397	func libc_issetugid_trampoline()
	1398
	1399	//go:linkname libc_issetugid libc_issetugid
	1400	//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
	1401
1014	1402	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1015	1403
1016	1404	func Kqueue() (fd int, err error) {
1017		r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	1405	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
1018	1406	fd = int(r0)
1019	1407	if e1 != 0 {
1020	1408	err = errnoErr(e1)

1022	1410	return
1023	1411	}
1024	1412
	1413	func libc_kqueue_trampoline()
	1414
	1415	//go:linkname libc_kqueue libc_kqueue
	1416	//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
	1417
1025	1418	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1026	1419
1027	1420	func Lchown(path string, uid int, gid int) (err error) {

1030	1423	if err != nil {
1031	1424	return
1032	1425	}
1033		_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1034		if e1 != 0 {
1035		err = errnoErr(e1)
1036		}
1037		return
1038		}
	1426	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1427	if e1 != 0 {
	1428	err = errnoErr(e1)
	1429	}
	1430	return
	1431	}
	1432
	1433	func libc_lchown_trampoline()
	1434
	1435	//go:linkname libc_lchown libc_lchown
	1436	//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
1039	1437
1040	1438	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1041	1439

1050	1448	if err != nil {
1051	1449	return
1052	1450	}
1053		_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1054		if e1 != 0 {
1055		err = errnoErr(e1)
1056		}
1057		return
1058		}
	1451	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1452	if e1 != 0 {
	1453	err = errnoErr(e1)
	1454	}
	1455	return
	1456	}
	1457
	1458	func libc_link_trampoline()
	1459
	1460	//go:linkname libc_link libc_link
	1461	//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
1059	1462
1060	1463	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1061	1464

1070	1473	if err != nil {
1071	1474	return
1072	1475	}
1073		_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1074		if e1 != 0 {
1075		err = errnoErr(e1)
1076		}
1077		return
1078		}
	1476	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1477	if e1 != 0 {
	1478	err = errnoErr(e1)
	1479	}
	1480	return
	1481	}
	1482
	1483	func libc_linkat_trampoline()
	1484
	1485	//go:linkname libc_linkat libc_linkat
	1486	//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
1079	1487
1080	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1081	1489
1082	1490	func Listen(s int, backlog int) (err error) {
1083		_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
1084		if e1 != 0 {
1085		err = errnoErr(e1)
1086		}
1087		return
1088		}
1089
1090		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1091
1092		func Lstat(path string, stat *Stat_t) (err error) {
1093		var _p0 *byte
1094		_p0, err = BytePtrFromString(path)
1095		if err != nil {
1096		return
1097		}
1098		_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1099		if e1 != 0 {
1100		err = errnoErr(e1)
1101		}
1102		return
1103		}
	1491	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	func libc_listen_trampoline()
	1499
	1500	//go:linkname libc_listen libc_listen
	1501	//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
1104	1502
1105	1503	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1106	1504

1110	1508	if err != nil {
1111	1509	return
1112	1510	}
1113		_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1114		if e1 != 0 {
1115		err = errnoErr(e1)
1116		}
1117		return
1118		}
	1511	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	func libc_mkdir_trampoline()
	1519
	1520	//go:linkname libc_mkdir libc_mkdir
	1521	//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
1119	1522
1120	1523	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1121	1524

1125	1528	if err != nil {
1126	1529	return
1127	1530	}
1128		_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1129		if e1 != 0 {
1130		err = errnoErr(e1)
1131		}
1132		return
1133		}
	1531	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	func libc_mkdirat_trampoline()
	1539
	1540	//go:linkname libc_mkdirat libc_mkdirat
	1541	//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
1134	1542
1135	1543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1136	1544

1140	1548	if err != nil {
1141	1549	return
1142	1550	}
1143		_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1144		if e1 != 0 {
1145		err = errnoErr(e1)
1146		}
1147		return
1148		}
	1551	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1552	if e1 != 0 {
	1553	err = errnoErr(e1)
	1554	}
	1555	return
	1556	}
	1557
	1558	func libc_mkfifo_trampoline()
	1559
	1560	//go:linkname libc_mkfifo libc_mkfifo
	1561	//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
1149	1562
1150	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1151	1564

1155	1568	if err != nil {
1156	1569	return
1157	1570	}
1158		_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1159		if e1 != 0 {
1160		err = errnoErr(e1)
1161		}
1162		return
1163		}
	1571	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1572	if e1 != 0 {
	1573	err = errnoErr(e1)
	1574	}
	1575	return
	1576	}
	1577
	1578	func libc_mknod_trampoline()
	1579
	1580	//go:linkname libc_mknod libc_mknod
	1581	//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
1164	1582
1165	1583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1166	1584

1170	1588	if err != nil {
1171	1589	return
1172	1590	}
1173		r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1591	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1174	1592	fd = int(r0)
1175	1593	if e1 != 0 {
1176	1594	err = errnoErr(e1)

1178	1596	return
1179	1597	}
1180	1598
	1599	func libc_open_trampoline()
	1600
	1601	//go:linkname libc_open libc_open
	1602	//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
	1603
1181	1604	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1182	1605
1183	1606	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {

1186	1609	if err != nil {
1187	1610	return
1188	1611	}
1189		r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1612	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1190	1613	fd = int(r0)
1191	1614	if e1 != 0 {
1192	1615	err = errnoErr(e1)

1194	1617	return
1195	1618	}
1196	1619
	1620	func libc_openat_trampoline()
	1621
	1622	//go:linkname libc_openat libc_openat
	1623	//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
	1624
1197	1625	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1198	1626
1199	1627	func Pathconf(path string, name int) (val int, err error) {

1202	1630	if err != nil {
1203	1631	return
1204	1632	}
1205		r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1633	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1206	1634	val = int(r0)
1207	1635	if e1 != 0 {
1208	1636	err = errnoErr(e1)
1209	1637	}
1210	1638	return
1211	1639	}
	1640
	1641	func libc_pathconf_trampoline()
	1642
	1643	//go:linkname libc_pathconf libc_pathconf
	1644	//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
1212	1645
1213	1646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1214	1647

1219	1652	} else {
1220	1653	_p0 = unsafe.Pointer(&_zero)
1221	1654	}
1222		r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1655	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1223	1656	n = int(r0)
1224	1657	if e1 != 0 {
1225	1658	err = errnoErr(e1)
1226	1659	}
1227	1660	return
1228	1661	}
	1662
	1663	func libc_pread_trampoline()
	1664
	1665	//go:linkname libc_pread libc_pread
	1666	//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
1229	1667
1230	1668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1231	1669

1236	1674	} else {
1237	1675	_p0 = unsafe.Pointer(&_zero)
1238	1676	}
1239		r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
	1677	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
1240	1678	n = int(r0)
1241	1679	if e1 != 0 {
1242	1680	err = errnoErr(e1)
1243	1681	}
1244	1682	return
1245	1683	}
	1684
	1685	func libc_pwrite_trampoline()
	1686
	1687	//go:linkname libc_pwrite libc_pwrite
	1688	//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
1246	1689
1247	1690	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1248	1691

1253	1696	} else {
1254	1697	_p0 = unsafe.Pointer(&_zero)
1255	1698	}
1256		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1699	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1257	1700	n = int(r0)
1258	1701	if e1 != 0 {
1259	1702	err = errnoErr(e1)
1260	1703	}
1261	1704	return
1262	1705	}
	1706
	1707	func libc_read_trampoline()
	1708
	1709	//go:linkname libc_read libc_read
	1710	//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
1263	1711
1264	1712	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1265	1713

1275	1723	} else {
1276	1724	_p1 = unsafe.Pointer(&_zero)
1277	1725	}
1278		r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1726	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1279	1727	n = int(r0)
1280	1728	if e1 != 0 {
1281	1729	err = errnoErr(e1)
1282	1730	}
1283	1731	return
1284	1732	}
	1733
	1734	func libc_readlink_trampoline()
	1735
	1736	//go:linkname libc_readlink libc_readlink
	1737	//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
1285	1738
1286	1739	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1287	1740

1297	1750	} else {
1298	1751	_p1 = unsafe.Pointer(&_zero)
1299	1752	}
1300		r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1753	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1301	1754	n = int(r0)
1302	1755	if e1 != 0 {
1303	1756	err = errnoErr(e1)
1304	1757	}
1305	1758	return
1306	1759	}
	1760
	1761	func libc_readlinkat_trampoline()
	1762
	1763	//go:linkname libc_readlinkat libc_readlinkat
	1764	//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
1307	1765
1308	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1309	1767

1318	1776	if err != nil {
1319	1777	return
1320	1778	}
1321		_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1322		if e1 != 0 {
1323		err = errnoErr(e1)
1324		}
1325		return
1326		}
	1779	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1780	if e1 != 0 {
	1781	err = errnoErr(e1)
	1782	}
	1783	return
	1784	}
	1785
	1786	func libc_rename_trampoline()
	1787
	1788	//go:linkname libc_rename libc_rename
	1789	//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
1327	1790
1328	1791	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1329	1792

1338	1801	if err != nil {
1339	1802	return
1340	1803	}
1341		_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1342		if e1 != 0 {
1343		err = errnoErr(e1)
1344		}
1345		return
1346		}
	1804	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}
	1810
	1811	func libc_renameat_trampoline()
	1812
	1813	//go:linkname libc_renameat libc_renameat
	1814	//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
1347	1815
1348	1816	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1349	1817

1353	1821	if err != nil {
1354	1822	return
1355	1823	}
1356		_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1357		if e1 != 0 {
1358		err = errnoErr(e1)
1359		}
1360		return
1361		}
	1824	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1825	if e1 != 0 {
	1826	err = errnoErr(e1)
	1827	}
	1828	return
	1829	}
	1830
	1831	func libc_revoke_trampoline()
	1832
	1833	//go:linkname libc_revoke libc_revoke
	1834	//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
1362	1835
1363	1836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1364	1837

1368	1841	if err != nil {
1369	1842	return
1370	1843	}
1371		_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
1372		if e1 != 0 {
1373		err = errnoErr(e1)
1374		}
1375		return
1376		}
	1844	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1845	if e1 != 0 {
	1846	err = errnoErr(e1)
	1847	}
	1848	return
	1849	}
	1850
	1851	func libc_rmdir_trampoline()
	1852
	1853	//go:linkname libc_rmdir libc_rmdir
	1854	//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
1377	1855
1378	1856	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1379	1857
1380	1858	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1381		r0, r1, e1 := Syscall6(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
	1859	r0, r1, e1 := syscall_syscall6(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(offset>>32), uintptr(whence), 0, 0)
1382	1860	newoffset = int64(int64(r1)<<32 \| int64(r0))
1383	1861	if e1 != 0 {
1384	1862	err = errnoErr(e1)

1386	1864	return
1387	1865	}
1388	1866
	1867	func libc_lseek_trampoline()
	1868
	1869	//go:linkname libc_lseek libc_lseek
	1870	//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
	1871
1389	1872	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1390	1873
1391	1874	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
1392		_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1393		if e1 != 0 {
1394		err = errnoErr(e1)
1395		}
1396		return
1397		}
	1875	_, _, 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)
	1876	if e1 != 0 {
	1877	err = errnoErr(e1)
	1878	}
	1879	return
	1880	}
	1881
	1882	func libc_select_trampoline()
	1883
	1884	//go:linkname libc_select libc_select
	1885	//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
1398	1886
1399	1887	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1400	1888
1401	1889	func Setegid(egid int) (err error) {
1402		_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
1403		if e1 != 0 {
1404		err = errnoErr(e1)
1405		}
1406		return
1407		}
	1890	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
	1891	if e1 != 0 {
	1892	err = errnoErr(e1)
	1893	}
	1894	return
	1895	}
	1896
	1897	func libc_setegid_trampoline()
	1898
	1899	//go:linkname libc_setegid libc_setegid
	1900	//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
1408	1901
1409	1902	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1410	1903
1411	1904	func Seteuid(euid int) (err error) {
1412		_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
1413		if e1 != 0 {
1414		err = errnoErr(e1)
1415		}
1416		return
1417		}
	1905	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
	1906	if e1 != 0 {
	1907	err = errnoErr(e1)
	1908	}
	1909	return
	1910	}
	1911
	1912	func libc_seteuid_trampoline()
	1913
	1914	//go:linkname libc_seteuid libc_seteuid
	1915	//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
1418	1916
1419	1917	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1420	1918
1421	1919	func Setgid(gid int) (err error) {
1422		_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
1423		if e1 != 0 {
1424		err = errnoErr(e1)
1425		}
1426		return
1427		}
	1920	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
	1921	if e1 != 0 {
	1922	err = errnoErr(e1)
	1923	}
	1924	return
	1925	}
	1926
	1927	func libc_setgid_trampoline()
	1928
	1929	//go:linkname libc_setgid libc_setgid
	1930	//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
1428	1931
1429	1932	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1430	1933

1434	1937	if err != nil {
1435	1938	return
1436	1939	}
1437		_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
1438		if e1 != 0 {
1439		err = errnoErr(e1)
1440		}
1441		return
1442		}
	1940	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1941	if e1 != 0 {
	1942	err = errnoErr(e1)
	1943	}
	1944	return
	1945	}
	1946
	1947	func libc_setlogin_trampoline()
	1948
	1949	//go:linkname libc_setlogin libc_setlogin
	1950	//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
1443	1951
1444	1952	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1445	1953
1446	1954	func Setpgid(pid int, pgid int) (err error) {
1447		_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
1448		if e1 != 0 {
1449		err = errnoErr(e1)
1450		}
1451		return
1452		}
	1955	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
	1956	if e1 != 0 {
	1957	err = errnoErr(e1)
	1958	}
	1959	return
	1960	}
	1961
	1962	func libc_setpgid_trampoline()
	1963
	1964	//go:linkname libc_setpgid libc_setpgid
	1965	//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
1453	1966
1454	1967	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1455	1968
1456	1969	func Setpriority(which int, who int, prio int) (err error) {
1457		_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
1458		if e1 != 0 {
1459		err = errnoErr(e1)
1460		}
1461		return
1462		}
	1970	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
	1971	if e1 != 0 {
	1972	err = errnoErr(e1)
	1973	}
	1974	return
	1975	}
	1976
	1977	func libc_setpriority_trampoline()
	1978
	1979	//go:linkname libc_setpriority libc_setpriority
	1980	//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
1463	1981
1464	1982	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1465	1983
1466	1984	func Setprivexec(flag int) (err error) {
1467		_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
1468		if e1 != 0 {
1469		err = errnoErr(e1)
1470		}
1471		return
1472		}
	1985	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
	1986	if e1 != 0 {
	1987	err = errnoErr(e1)
	1988	}
	1989	return
	1990	}
	1991
	1992	func libc_setprivexec_trampoline()
	1993
	1994	//go:linkname libc_setprivexec libc_setprivexec
	1995	//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
1473	1996
1474	1997	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1475	1998
1476	1999	func Setregid(rgid int, egid int) (err error) {
1477		_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
1478		if e1 != 0 {
1479		err = errnoErr(e1)
1480		}
1481		return
1482		}
	2000	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
	2001	if e1 != 0 {
	2002	err = errnoErr(e1)
	2003	}
	2004	return
	2005	}
	2006
	2007	func libc_setregid_trampoline()
	2008
	2009	//go:linkname libc_setregid libc_setregid
	2010	//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
1483	2011
1484	2012	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1485	2013
1486	2014	func Setreuid(ruid int, euid int) (err error) {
1487		_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1488		if e1 != 0 {
1489		err = errnoErr(e1)
1490		}
1491		return
1492		}
	2015	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
	2016	if e1 != 0 {
	2017	err = errnoErr(e1)
	2018	}
	2019	return
	2020	}
	2021
	2022	func libc_setreuid_trampoline()
	2023
	2024	//go:linkname libc_setreuid libc_setreuid
	2025	//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
1493	2026
1494	2027	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1495	2028
1496	2029	func Setrlimit(which int, lim *Rlimit) (err error) {
1497		_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1498		if e1 != 0 {
1499		err = errnoErr(e1)
1500		}
1501		return
1502		}
	2030	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	2031	if e1 != 0 {
	2032	err = errnoErr(e1)
	2033	}
	2034	return
	2035	}
	2036
	2037	func libc_setrlimit_trampoline()
	2038
	2039	//go:linkname libc_setrlimit libc_setrlimit
	2040	//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
1503	2041
1504	2042	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1505	2043
1506	2044	func Setsid() (pid int, err error) {
1507		r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	2045	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
1508	2046	pid = int(r0)
1509	2047	if e1 != 0 {
1510	2048	err = errnoErr(e1)

1512	2050	return
1513	2051	}
1514	2052
	2053	func libc_setsid_trampoline()
	2054
	2055	//go:linkname libc_setsid libc_setsid
	2056	//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
	2057
1515	2058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1516	2059
1517	2060	func Settimeofday(tp *Timeval) (err error) {
1518		_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1519		if e1 != 0 {
1520		err = errnoErr(e1)
1521		}
1522		return
1523		}
	2061	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2062	if e1 != 0 {
	2063	err = errnoErr(e1)
	2064	}
	2065	return
	2066	}
	2067
	2068	func libc_settimeofday_trampoline()
	2069
	2070	//go:linkname libc_settimeofday libc_settimeofday
	2071	//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
1524	2072
1525	2073	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1526	2074
1527	2075	func Setuid(uid int) (err error) {
1528		_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1529		if e1 != 0 {
1530		err = errnoErr(e1)
1531		}
1532		return
1533		}
1534
1535		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1536
1537		func Stat(path string, stat *Stat_t) (err error) {
1538		var _p0 *byte
1539		_p0, err = BytePtrFromString(path)
1540		if err != nil {
1541		return
1542		}
1543		_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1544		if e1 != 0 {
1545		err = errnoErr(e1)
1546		}
1547		return
1548		}
1549
1550		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1551
1552		func Statfs(path string, stat *Statfs_t) (err error) {
1553		var _p0 *byte
1554		_p0, err = BytePtrFromString(path)
1555		if err != nil {
1556		return
1557		}
1558		_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1559		if e1 != 0 {
1560		err = errnoErr(e1)
1561		}
1562		return
1563		}
	2076	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
	2077	if e1 != 0 {
	2078	err = errnoErr(e1)
	2079	}
	2080	return
	2081	}
	2082
	2083	func libc_setuid_trampoline()
	2084
	2085	//go:linkname libc_setuid libc_setuid
	2086	//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
1564	2087
1565	2088	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1566	2089

1575	2098	if err != nil {
1576	2099	return
1577	2100	}
1578		_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1579		if e1 != 0 {
1580		err = errnoErr(e1)
1581		}
1582		return
1583		}
	2101	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	2102	if e1 != 0 {
	2103	err = errnoErr(e1)
	2104	}
	2105	return
	2106	}
	2107
	2108	func libc_symlink_trampoline()
	2109
	2110	//go:linkname libc_symlink libc_symlink
	2111	//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
1584	2112
1585	2113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1586	2114

1595	2123	if err != nil {
1596	2124	return
1597	2125	}
1598		_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
1599		if e1 != 0 {
1600		err = errnoErr(e1)
1601		}
1602		return
1603		}
	2126	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	2127	if e1 != 0 {
	2128	err = errnoErr(e1)
	2129	}
	2130	return
	2131	}
	2132
	2133	func libc_symlinkat_trampoline()
	2134
	2135	//go:linkname libc_symlinkat libc_symlinkat
	2136	//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
1604	2137
1605	2138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1606	2139
1607	2140	func Sync() (err error) {
1608		_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
1609		if e1 != 0 {
1610		err = errnoErr(e1)
1611		}
1612		return
1613		}
	2141	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
	2142	if e1 != 0 {
	2143	err = errnoErr(e1)
	2144	}
	2145	return
	2146	}
	2147
	2148	func libc_sync_trampoline()
	2149
	2150	//go:linkname libc_sync libc_sync
	2151	//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
1614	2152
1615	2153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1616	2154

1620	2158	if err != nil {
1621	2159	return
1622	2160	}
1623		_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
1624		if e1 != 0 {
1625		err = errnoErr(e1)
1626		}
1627		return
1628		}
	2161	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), uintptr(length>>32))
	2162	if e1 != 0 {
	2163	err = errnoErr(e1)
	2164	}
	2165	return
	2166	}
	2167
	2168	func libc_truncate_trampoline()
	2169
	2170	//go:linkname libc_truncate libc_truncate
	2171	//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
1629	2172
1630	2173	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1631	2174
1632	2175	func Umask(newmask int) (oldmask int) {
1633		r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	2176	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
1634	2177	oldmask = int(r0)
1635	2178	return
1636	2179	}
1637	2180
	2181	func libc_umask_trampoline()
	2182
	2183	//go:linkname libc_umask libc_umask
	2184	//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
	2185
1638	2186	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1639	2187
1640	2188	func Undelete(path string) (err error) {

1643	2191	if err != nil {
1644	2192	return
1645	2193	}
1646		_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1647		if e1 != 0 {
1648		err = errnoErr(e1)
1649		}
1650		return
1651		}
	2194	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2195	if e1 != 0 {
	2196	err = errnoErr(e1)
	2197	}
	2198	return
	2199	}
	2200
	2201	func libc_undelete_trampoline()
	2202
	2203	//go:linkname libc_undelete libc_undelete
	2204	//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
1652	2205
1653	2206	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1654	2207

1658	2211	if err != nil {
1659	2212	return
1660	2213	}
1661		_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
1662		if e1 != 0 {
1663		err = errnoErr(e1)
1664		}
1665		return
1666		}
	2214	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2215	if e1 != 0 {
	2216	err = errnoErr(e1)
	2217	}
	2218	return
	2219	}
	2220
	2221	func libc_unlink_trampoline()
	2222
	2223	//go:linkname libc_unlink libc_unlink
	2224	//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
1667	2225
1668	2226	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1669	2227

1673	2231	if err != nil {
1674	2232	return
1675	2233	}
1676		_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
1677		if e1 != 0 {
1678		err = errnoErr(e1)
1679		}
1680		return
1681		}
	2234	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	2235	if e1 != 0 {
	2236	err = errnoErr(e1)
	2237	}
	2238	return
	2239	}
	2240
	2241	func libc_unlinkat_trampoline()
	2242
	2243	//go:linkname libc_unlinkat libc_unlinkat
	2244	//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
1682	2245
1683	2246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1684	2247

1688	2251	if err != nil {
1689	2252	return
1690	2253	}
1691		_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1692		if e1 != 0 {
1693		err = errnoErr(e1)
1694		}
1695		return
1696		}
	2254	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	2255	if e1 != 0 {
	2256	err = errnoErr(e1)
	2257	}
	2258	return
	2259	}
	2260
	2261	func libc_unmount_trampoline()
	2262
	2263	//go:linkname libc_unmount libc_unmount
	2264	//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
1697	2265
1698	2266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1699	2267

1704	2272	} else {
1705	2273	_p0 = unsafe.Pointer(&_zero)
1706	2274	}
1707		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	2275	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1708	2276	n = int(r0)
1709	2277	if e1 != 0 {
1710	2278	err = errnoErr(e1)

1712	2280	return
1713	2281	}
1714	2282
	2283	func libc_write_trampoline()
	2284
	2285	//go:linkname libc_write libc_write
	2286	//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
	2287
1715	2288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1716	2289
1717	2290	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1718		r0, _, e1 := Syscall9(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
	2291	r0, _, e1 := syscall_syscall9(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos), uintptr(pos>>32), 0, 0)
1719	2292	ret = uintptr(r0)
1720	2293	if e1 != 0 {
1721	2294	err = errnoErr(e1)

1723	2296	return
1724	2297	}
1725	2298
	2299	func libc_mmap_trampoline()
	2300
	2301	//go:linkname libc_mmap libc_mmap
	2302	//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
	2303
1726	2304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1727	2305
1728	2306	func munmap(addr uintptr, length uintptr) (err error) {
1729		_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
1730		if e1 != 0 {
1731		err = errnoErr(e1)
1732		}
1733		return
1734		}
	2307	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
	2308	if e1 != 0 {
	2309	err = errnoErr(e1)
	2310	}
	2311	return
	2312	}
	2313
	2314	func libc_munmap_trampoline()
	2315
	2316	//go:linkname libc_munmap libc_munmap
	2317	//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
1735	2318
1736	2319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1737	2320
1738	2321	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1739		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2322	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1740	2323	n = int(r0)
1741	2324	if e1 != 0 {
1742	2325	err = errnoErr(e1)

1747	2330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1748	2331
1749	2332	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1750		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2333	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1751	2334	n = int(r0)
1752	2335	if e1 != 0 {
1753	2336	err = errnoErr(e1)

1758	2341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1759	2342
1760	2343	func gettimeofday(tp *Timeval) (sec int32, usec int32, err error) {
1761		r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	2344	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
1762	2345	sec = int32(r0)
1763	2346	usec = int32(r1)
1764	2347	if e1 != 0 {

1766	2349	}
1767	2350	return
1768	2351	}
	2352
	2353	func libc_gettimeofday_trampoline()
	2354
	2355	//go:linkname libc_gettimeofday libc_gettimeofday
	2356	//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
	2357
	2358	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2359
	2360	func Fstat(fd int, stat *Stat_t) (err error) {
	2361	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2362	if e1 != 0 {
	2363	err = errnoErr(e1)
	2364	}
	2365	return
	2366	}
	2367
	2368	func libc_fstat_trampoline()
	2369
	2370	//go:linkname libc_fstat libc_fstat
	2371	//go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
	2372
	2373	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2374
	2375	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	2376	var _p0 *byte
	2377	_p0, err = BytePtrFromString(path)
	2378	if err != nil {
	2379	return
	2380	}
	2381	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	2382	if e1 != 0 {
	2383	err = errnoErr(e1)
	2384	}
	2385	return
	2386	}
	2387
	2388	func libc_fstatat_trampoline()
	2389
	2390	//go:linkname libc_fstatat libc_fstatat
	2391	//go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
	2392
	2393	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2394
	2395	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	2396	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2397	if e1 != 0 {
	2398	err = errnoErr(e1)
	2399	}
	2400	return
	2401	}
	2402
	2403	func libc_fstatfs_trampoline()
	2404
	2405	//go:linkname libc_fstatfs libc_fstatfs
	2406	//go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
	2407
	2408	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2409
	2410	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	2411	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
	2412	n = int(r0)
	2413	if e1 != 0 {
	2414	err = errnoErr(e1)
	2415	}
	2416	return
	2417	}
	2418
	2419	func libc_getfsstat_trampoline()
	2420
	2421	//go:linkname libc_getfsstat libc_getfsstat
	2422	//go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
	2423
	2424	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2425
	2426	func Lstat(path string, stat *Stat_t) (err error) {
	2427	var _p0 *byte
	2428	_p0, err = BytePtrFromString(path)
	2429	if err != nil {
	2430	return
	2431	}
	2432	_, _, e1 := syscall_syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2433	if e1 != 0 {
	2434	err = errnoErr(e1)
	2435	}
	2436	return
	2437	}
	2438
	2439	func libc_lstat_trampoline()
	2440
	2441	//go:linkname libc_lstat libc_lstat
	2442	//go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
	2443
	2444	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2445
	2446	func Stat(path string, stat *Stat_t) (err error) {
	2447	var _p0 *byte
	2448	_p0, err = BytePtrFromString(path)
	2449	if err != nil {
	2450	return
	2451	}
	2452	_, _, e1 := syscall_syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2453	if e1 != 0 {
	2454	err = errnoErr(e1)
	2455	}
	2456	return
	2457	}
	2458
	2459	func libc_stat_trampoline()
	2460
	2461	//go:linkname libc_stat libc_stat
	2462	//go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
	2463
	2464	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2465
	2466	func Statfs(path string, stat *Statfs_t) (err error) {
	2467	var _p0 *byte
	2468	_p0, err = BytePtrFromString(path)
	2469	if err != nil {
	2470	return
	2471	}
	2472	_, _, e1 := syscall_syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2473	if e1 != 0 {
	2474	err = errnoErr(e1)
	2475	}
	2476	return
	2477	}
	2478
	2479	func libc_statfs_trampoline()
	2480
	2481	//go:linkname libc_statfs libc_statfs
	2482	//go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"

+282

-0

unix/zsyscall_darwin_arm.s less more

	0	// go run mkasm_darwin.go arm
	1	// Code generated by the command above; DO NOT EDIT.
	2
	3	// +build go1.12
	4
	5	#include "textflag.h"
	6	TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
	7	JMP libc_getgroups(SB)
	8	TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
	9	JMP libc_setgroups(SB)
	10	TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
	11	JMP libc_wait4(SB)
	12	TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
	13	JMP libc_accept(SB)
	14	TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
	15	JMP libc_bind(SB)
	16	TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
	17	JMP libc_connect(SB)
	18	TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
	19	JMP libc_socket(SB)
	20	TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
	21	JMP libc_getsockopt(SB)
	22	TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
	23	JMP libc_setsockopt(SB)
	24	TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
	25	JMP libc_getpeername(SB)
	26	TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
	27	JMP libc_getsockname(SB)
	28	TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
	29	JMP libc_shutdown(SB)
	30	TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
	31	JMP libc_socketpair(SB)
	32	TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
	33	JMP libc_recvfrom(SB)
	34	TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
	35	JMP libc_sendto(SB)
	36	TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
	37	JMP libc_recvmsg(SB)
	38	TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
	39	JMP libc_sendmsg(SB)
	40	TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
	41	JMP libc_kevent(SB)
	42	TEXT ·libc___sysctl_trampoline(SB),NOSPLIT,$0-0
	43	JMP libc___sysctl(SB)
	44	TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
	45	JMP libc_utimes(SB)
	46	TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
	47	JMP libc_futimes(SB)
	48	TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
	49	JMP libc_fcntl(SB)
	50	TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
	51	JMP libc_poll(SB)
	52	TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
	53	JMP libc_madvise(SB)
	54	TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
	55	JMP libc_mlock(SB)
	56	TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
	57	JMP libc_mlockall(SB)
	58	TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
	59	JMP libc_mprotect(SB)
	60	TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
	61	JMP libc_msync(SB)
	62	TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
	63	JMP libc_munlock(SB)
	64	TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
	65	JMP libc_munlockall(SB)
	66	TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
	67	JMP libc_ptrace(SB)
	68	TEXT ·libc_getattrlist_trampoline(SB),NOSPLIT,$0-0
	69	JMP libc_getattrlist(SB)
	70	TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
	71	JMP libc_pipe(SB)
	72	TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
	73	JMP libc_getxattr(SB)
	74	TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
	75	JMP libc_fgetxattr(SB)
	76	TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
	77	JMP libc_setxattr(SB)
	78	TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
	79	JMP libc_fsetxattr(SB)
	80	TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
	81	JMP libc_removexattr(SB)
	82	TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
	83	JMP libc_fremovexattr(SB)
	84	TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
	85	JMP libc_listxattr(SB)
	86	TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
	87	JMP libc_flistxattr(SB)
	88	TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
	89	JMP libc_setattrlist(SB)
	90	TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
	91	JMP libc_kill(SB)
	92	TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
	93	JMP libc_ioctl(SB)
	94	TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
	95	JMP libc_sendfile(SB)
	96	TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
	97	JMP libc_access(SB)
	98	TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
	99	JMP libc_adjtime(SB)
	100	TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
	101	JMP libc_chdir(SB)
	102	TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
	103	JMP libc_chflags(SB)
	104	TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
	105	JMP libc_chmod(SB)
	106	TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
	107	JMP libc_chown(SB)
	108	TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
	109	JMP libc_chroot(SB)
	110	TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
	111	JMP libc_close(SB)
	112	TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
	113	JMP libc_dup(SB)
	114	TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
	115	JMP libc_dup2(SB)
	116	TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
	117	JMP libc_exchangedata(SB)
	118	TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
	119	JMP libc_exit(SB)
	120	TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
	121	JMP libc_faccessat(SB)
	122	TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
	123	JMP libc_fchdir(SB)
	124	TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
	125	JMP libc_fchflags(SB)
	126	TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
	127	JMP libc_fchmod(SB)
	128	TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
	129	JMP libc_fchmodat(SB)
	130	TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
	131	JMP libc_fchown(SB)
	132	TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
	133	JMP libc_fchownat(SB)
	134	TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
	135	JMP libc_flock(SB)
	136	TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
	137	JMP libc_fpathconf(SB)
	138	TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
	139	JMP libc_fsync(SB)
	140	TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
	141	JMP libc_ftruncate(SB)
	142	TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
	143	JMP libc_getdtablesize(SB)
	144	TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
	145	JMP libc_getegid(SB)
	146	TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
	147	JMP libc_geteuid(SB)
	148	TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
	149	JMP libc_getgid(SB)
	150	TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
	151	JMP libc_getpgid(SB)
	152	TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
	153	JMP libc_getpgrp(SB)
	154	TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
	155	JMP libc_getpid(SB)
	156	TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
	157	JMP libc_getppid(SB)
	158	TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
	159	JMP libc_getpriority(SB)
	160	TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
	161	JMP libc_getrlimit(SB)
	162	TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
	163	JMP libc_getrusage(SB)
	164	TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
	165	JMP libc_getsid(SB)
	166	TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
	167	JMP libc_getuid(SB)
	168	TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
	169	JMP libc_issetugid(SB)
	170	TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
	171	JMP libc_kqueue(SB)
	172	TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
	173	JMP libc_lchown(SB)
	174	TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
	175	JMP libc_link(SB)
	176	TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
	177	JMP libc_linkat(SB)
	178	TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
	179	JMP libc_listen(SB)
	180	TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
	181	JMP libc_mkdir(SB)
	182	TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
	183	JMP libc_mkdirat(SB)
	184	TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
	185	JMP libc_mkfifo(SB)
	186	TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
	187	JMP libc_mknod(SB)
	188	TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
	189	JMP libc_open(SB)
	190	TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
	191	JMP libc_openat(SB)
	192	TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
	193	JMP libc_pathconf(SB)
	194	TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
	195	JMP libc_pread(SB)
	196	TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
	197	JMP libc_pwrite(SB)
	198	TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
	199	JMP libc_read(SB)
	200	TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
	201	JMP libc_readlink(SB)
	202	TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
	203	JMP libc_readlinkat(SB)
	204	TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
	205	JMP libc_rename(SB)
	206	TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
	207	JMP libc_renameat(SB)
	208	TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
	209	JMP libc_revoke(SB)
	210	TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
	211	JMP libc_rmdir(SB)
	212	TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
	213	JMP libc_lseek(SB)
	214	TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
	215	JMP libc_select(SB)
	216	TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
	217	JMP libc_setegid(SB)
	218	TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
	219	JMP libc_seteuid(SB)
	220	TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
	221	JMP libc_setgid(SB)
	222	TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
	223	JMP libc_setlogin(SB)
	224	TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
	225	JMP libc_setpgid(SB)
	226	TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
	227	JMP libc_setpriority(SB)
	228	TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
	229	JMP libc_setprivexec(SB)
	230	TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
	231	JMP libc_setregid(SB)
	232	TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
	233	JMP libc_setreuid(SB)
	234	TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
	235	JMP libc_setrlimit(SB)
	236	TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
	237	JMP libc_setsid(SB)
	238	TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
	239	JMP libc_settimeofday(SB)
	240	TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
	241	JMP libc_setuid(SB)
	242	TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
	243	JMP libc_symlink(SB)
	244	TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
	245	JMP libc_symlinkat(SB)
	246	TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
	247	JMP libc_sync(SB)
	248	TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
	249	JMP libc_truncate(SB)
	250	TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
	251	JMP libc_umask(SB)
	252	TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
	253	JMP libc_undelete(SB)
	254	TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
	255	JMP libc_unlink(SB)
	256	TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
	257	JMP libc_unlinkat(SB)
	258	TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
	259	JMP libc_unmount(SB)
	260	TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
	261	JMP libc_write(SB)
	262	TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
	263	JMP libc_mmap(SB)
	264	TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
	265	JMP libc_munmap(SB)
	266	TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
	267	JMP libc_gettimeofday(SB)
	268	TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
	269	JMP libc_fstat(SB)
	270	TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
	271	JMP libc_fstatat(SB)
	272	TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
	273	JMP libc_fstatfs(SB)
	274	TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
	275	JMP libc_getfsstat(SB)
	276	TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
	277	JMP libc_lstat(SB)
	278	TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
	279	JMP libc_stat(SB)
	280	TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
	281	JMP libc_statfs(SB)

+1793

-0

unix/zsyscall_darwin_arm64.1_11.go less more

	0	// go run mksyscall.go -tags darwin,arm64,!go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm64.go
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
	2
	3	// +build darwin,arm64,!go1.12
	4
	5	package unix
	6
	7	import (
	8	"syscall"
	9	"unsafe"
	10	)
	11
	12	var _ syscall.Errno
	13
	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	15
	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
	17	r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	18	n = int(r0)
	19	if e1 != 0 {
	20	err = errnoErr(e1)
	21	}
	22	return
	23	}
	24
	25	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	26
	27	func setgroups(ngid int, gid *_Gid_t) (err error) {
	28	_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	29	if e1 != 0 {
	30	err = errnoErr(e1)
	31	}
	32	return
	33	}
	34
	35	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	36
	37	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
	38	r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	39	wpid = int(r0)
	40	if e1 != 0 {
	41	err = errnoErr(e1)
	42	}
	43	return
	44	}
	45
	46	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	47
	48	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
	49	r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	50	fd = int(r0)
	51	if e1 != 0 {
	52	err = errnoErr(e1)
	53	}
	54	return
	55	}
	56
	57	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	58
	59	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	60	_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
	61	if e1 != 0 {
	62	err = errnoErr(e1)
	63	}
	64	return
	65	}
	66
	67	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	68
	69	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
	70	_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
	71	if e1 != 0 {
	72	err = errnoErr(e1)
	73	}
	74	return
	75	}
	76
	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	78
	79	func socket(domain int, typ int, proto int) (fd int, err error) {
	80	r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	81	fd = int(r0)
	82	if e1 != 0 {
	83	err = errnoErr(e1)
	84	}
	85	return
	86	}
	87
	88	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	89
	90	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
	91	_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	92	if e1 != 0 {
	93	err = errnoErr(e1)
	94	}
	95	return
	96	}
	97
	98	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	99
	100	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
	101	_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	102	if e1 != 0 {
	103	err = errnoErr(e1)
	104	}
	105	return
	106	}
	107
	108	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	109
	110	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	111	_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	112	if e1 != 0 {
	113	err = errnoErr(e1)
	114	}
	115	return
	116	}
	117
	118	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	119
	120	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
	121	_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	122	if e1 != 0 {
	123	err = errnoErr(e1)
	124	}
	125	return
	126	}
	127
	128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	129
	130	func Shutdown(s int, how int) (err error) {
	131	_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
	132	if e1 != 0 {
	133	err = errnoErr(e1)
	134	}
	135	return
	136	}
	137
	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	139
	140	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
	141	_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	149
	150	func recvfrom(fd int, p []byte, flags int, from RawSockaddrAny, fromlen _Socklen) (n int, err error) {
	151	var _p0 unsafe.Pointer
	152	if len(p) > 0 {
	153	_p0 = unsafe.Pointer(&p[0])
	154	} else {
	155	_p0 = unsafe.Pointer(&_zero)
	156	}
	157	r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	158	n = int(r0)
	159	if e1 != 0 {
	160	err = errnoErr(e1)
	161	}
	162	return
	163	}
	164
	165	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	166
	167	func sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) {
	168	var _p0 unsafe.Pointer
	169	if len(buf) > 0 {
	170	_p0 = unsafe.Pointer(&buf[0])
	171	} else {
	172	_p0 = unsafe.Pointer(&_zero)
	173	}
	174	_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	175	if e1 != 0 {
	176	err = errnoErr(e1)
	177	}
	178	return
	179	}
	180
	181	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	182
	183	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	184	r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	185	n = int(r0)
	186	if e1 != 0 {
	187	err = errnoErr(e1)
	188	}
	189	return
	190	}
	191
	192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	193
	194	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
	195	r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	196	n = int(r0)
	197	if e1 != 0 {
	198	err = errnoErr(e1)
	199	}
	200	return
	201	}
	202
	203	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	204
	205	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
	206	r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	207	n = int(r0)
	208	if e1 != 0 {
	209	err = errnoErr(e1)
	210	}
	211	return
	212	}
	213
	214	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	215
	216	func sysctl(mib []_C_int, old byte, oldlen uintptr, new *byte, newlen uintptr) (err error) {
	217	var _p0 unsafe.Pointer
	218	if len(mib) > 0 {
	219	_p0 = unsafe.Pointer(&mib[0])
	220	} else {
	221	_p0 = unsafe.Pointer(&_zero)
	222	}
	223	_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
	224	if e1 != 0 {
	225	err = errnoErr(e1)
	226	}
	227	return
	228	}
	229
	230	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	231
	232	func utimes(path string, timeval *[2]Timeval) (err error) {
	233	var _p0 *byte
	234	_p0, err = BytePtrFromString(path)
	235	if err != nil {
	236	return
	237	}
	238	_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	239	if e1 != 0 {
	240	err = errnoErr(e1)
	241	}
	242	return
	243	}
	244
	245	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	246
	247	func futimes(fd int, timeval *[2]Timeval) (err error) {
	248	_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	249	if e1 != 0 {
	250	err = errnoErr(e1)
	251	}
	252	return
	253	}
	254
	255	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	256
	257	func fcntl(fd int, cmd int, arg int) (val int, err error) {
	258	r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	259	val = int(r0)
	260	if e1 != 0 {
	261	err = errnoErr(e1)
	262	}
	263	return
	264	}
	265
	266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	267
	268	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
	269	r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	270	n = int(r0)
	271	if e1 != 0 {
	272	err = errnoErr(e1)
	273	}
	274	return
	275	}
	276
	277	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	278
	279	func Madvise(b []byte, behav int) (err error) {
	280	var _p0 unsafe.Pointer
	281	if len(b) > 0 {
	282	_p0 = unsafe.Pointer(&b[0])
	283	} else {
	284	_p0 = unsafe.Pointer(&_zero)
	285	}
	286	_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
	287	if e1 != 0 {
	288	err = errnoErr(e1)
	289	}
	290	return
	291	}
	292
	293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	294
	295	func Mlock(b []byte) (err error) {
	296	var _p0 unsafe.Pointer
	297	if len(b) > 0 {
	298	_p0 = unsafe.Pointer(&b[0])
	299	} else {
	300	_p0 = unsafe.Pointer(&_zero)
	301	}
	302	_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
	303	if e1 != 0 {
	304	err = errnoErr(e1)
	305	}
	306	return
	307	}
	308
	309	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	310
	311	func Mlockall(flags int) (err error) {
	312	_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
	313	if e1 != 0 {
	314	err = errnoErr(e1)
	315	}
	316	return
	317	}
	318
	319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	320
	321	func Mprotect(b []byte, prot int) (err error) {
	322	var _p0 unsafe.Pointer
	323	if len(b) > 0 {
	324	_p0 = unsafe.Pointer(&b[0])
	325	} else {
	326	_p0 = unsafe.Pointer(&_zero)
	327	}
	328	_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
	329	if e1 != 0 {
	330	err = errnoErr(e1)
	331	}
	332	return
	333	}
	334
	335	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	336
	337	func Msync(b []byte, flags int) (err error) {
	338	var _p0 unsafe.Pointer
	339	if len(b) > 0 {
	340	_p0 = unsafe.Pointer(&b[0])
	341	} else {
	342	_p0 = unsafe.Pointer(&_zero)
	343	}
	344	_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
	345	if e1 != 0 {
	346	err = errnoErr(e1)
	347	}
	348	return
	349	}
	350
	351	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	352
	353	func Munlock(b []byte) (err error) {
	354	var _p0 unsafe.Pointer
	355	if len(b) > 0 {
	356	_p0 = unsafe.Pointer(&b[0])
	357	} else {
	358	_p0 = unsafe.Pointer(&_zero)
	359	}
	360	_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
	361	if e1 != 0 {
	362	err = errnoErr(e1)
	363	}
	364	return
	365	}
	366
	367	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	368
	369	func Munlockall() (err error) {
	370	_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
	371	if e1 != 0 {
	372	err = errnoErr(e1)
	373	}
	374	return
	375	}
	376
	377	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	378
	379	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
	380	_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	381	if e1 != 0 {
	382	err = errnoErr(e1)
	383	}
	384	return
	385	}
	386
	387	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	388
	389	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	390	_, _, e1 := Syscall6(SYS_GETATTRLIST, uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	391	if e1 != 0 {
	392	err = errnoErr(e1)
	393	}
	394	return
	395	}
	396
	397	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	398
	399	func pipe() (r int, w int, err error) {
	400	r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	401	r = int(r0)
	402	w = int(r1)
	403	if e1 != 0 {
	404	err = errnoErr(e1)
	405	}
	406	return
	407	}
	408
	409	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	410
	411	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	412	var _p0 *byte
	413	_p0, err = BytePtrFromString(path)
	414	if err != nil {
	415	return
	416	}
	417	var _p1 *byte
	418	_p1, err = BytePtrFromString(attr)
	419	if err != nil {
	420	return
	421	}
	422	r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	423	sz = int(r0)
	424	if e1 != 0 {
	425	err = errnoErr(e1)
	426	}
	427	return
	428	}
	429
	430	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	431
	432	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {
	433	var _p0 *byte
	434	_p0, err = BytePtrFromString(attr)
	435	if err != nil {
	436	return
	437	}
	438	r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	439	sz = int(r0)
	440	if e1 != 0 {
	441	err = errnoErr(e1)
	442	}
	443	return
	444	}
	445
	446	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	447
	448	func setxattr(path string, attr string, data *byte, size int, position uint32, options int) (err error) {
	449	var _p0 *byte
	450	_p0, err = BytePtrFromString(path)
	451	if err != nil {
	452	return
	453	}
	454	var _p1 *byte
	455	_p1, err = BytePtrFromString(attr)
	456	if err != nil {
	457	return
	458	}
	459	_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	460	if e1 != 0 {
	461	err = errnoErr(e1)
	462	}
	463	return
	464	}
	465
	466	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	467
	468	func fsetxattr(fd int, attr string, data *byte, size int, position uint32, options int) (err error) {
	469	var _p0 *byte
	470	_p0, err = BytePtrFromString(attr)
	471	if err != nil {
	472	return
	473	}
	474	_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	475	if e1 != 0 {
	476	err = errnoErr(e1)
	477	}
	478	return
	479	}
	480
	481	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	482
	483	func removexattr(path string, attr string, options int) (err error) {
	484	var _p0 *byte
	485	_p0, err = BytePtrFromString(path)
	486	if err != nil {
	487	return
	488	}
	489	var _p1 *byte
	490	_p1, err = BytePtrFromString(attr)
	491	if err != nil {
	492	return
	493	}
	494	_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	495	if e1 != 0 {
	496	err = errnoErr(e1)
	497	}
	498	return
	499	}
	500
	501	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	502
	503	func fremovexattr(fd int, attr string, options int) (err error) {
	504	var _p0 *byte
	505	_p0, err = BytePtrFromString(attr)
	506	if err != nil {
	507	return
	508	}
	509	_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	510	if e1 != 0 {
	511	err = errnoErr(e1)
	512	}
	513	return
	514	}
	515
	516	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	517
	518	func listxattr(path string, dest *byte, size int, options int) (sz int, err error) {
	519	var _p0 *byte
	520	_p0, err = BytePtrFromString(path)
	521	if err != nil {
	522	return
	523	}
	524	r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	525	sz = int(r0)
	526	if e1 != 0 {
	527	err = errnoErr(e1)
	528	}
	529	return
	530	}
	531
	532	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	533
	534	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
	535	r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	536	sz = int(r0)
	537	if e1 != 0 {
	538	err = errnoErr(e1)
	539	}
	540	return
	541	}
	542
	543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	544
	545	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	546	_, _, e1 := Syscall6(SYS_SETATTRLIST, 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	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	554
	555	func kill(pid int, signum int, posix int) (err error) {
	556	_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
	557	if e1 != 0 {
	558	err = errnoErr(e1)
	559	}
	560	return
	561	}
	562
	563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	564
	565	func ioctl(fd int, req uint, arg uintptr) (err error) {
	566	_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
	567	if e1 != 0 {
	568	err = errnoErr(e1)
	569	}
	570	return
	571	}
	572
	573	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	574
	575	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	576	_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
	577	if e1 != 0 {
	578	err = errnoErr(e1)
	579	}
	580	return
	581	}
	582
	583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	584
	585	func Access(path string, mode uint32) (err error) {
	586	var _p0 *byte
	587	_p0, err = BytePtrFromString(path)
	588	if err != nil {
	589	return
	590	}
	591	_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	592	if e1 != 0 {
	593	err = errnoErr(e1)
	594	}
	595	return
	596	}
	597
	598	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	599
	600	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
	601	_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	602	if e1 != 0 {
	603	err = errnoErr(e1)
	604	}
	605	return
	606	}
	607
	608	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	609
	610	func Chdir(path string) (err error) {
	611	var _p0 *byte
	612	_p0, err = BytePtrFromString(path)
	613	if err != nil {
	614	return
	615	}
	616	_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	617	if e1 != 0 {
	618	err = errnoErr(e1)
	619	}
	620	return
	621	}
	622
	623	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	624
	625	func Chflags(path string, flags int) (err error) {
	626	var _p0 *byte
	627	_p0, err = BytePtrFromString(path)
	628	if err != nil {
	629	return
	630	}
	631	_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	632	if e1 != 0 {
	633	err = errnoErr(e1)
	634	}
	635	return
	636	}
	637
	638	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	639
	640	func Chmod(path string, mode uint32) (err error) {
	641	var _p0 *byte
	642	_p0, err = BytePtrFromString(path)
	643	if err != nil {
	644	return
	645	}
	646	_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	647	if e1 != 0 {
	648	err = errnoErr(e1)
	649	}
	650	return
	651	}
	652
	653	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	654
	655	func Chown(path string, uid int, gid int) (err error) {
	656	var _p0 *byte
	657	_p0, err = BytePtrFromString(path)
	658	if err != nil {
	659	return
	660	}
	661	_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	662	if e1 != 0 {
	663	err = errnoErr(e1)
	664	}
	665	return
	666	}
	667
	668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	669
	670	func Chroot(path string) (err error) {
	671	var _p0 *byte
	672	_p0, err = BytePtrFromString(path)
	673	if err != nil {
	674	return
	675	}
	676	_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
	677	if e1 != 0 {
	678	err = errnoErr(e1)
	679	}
	680	return
	681	}
	682
	683	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	684
	685	func Close(fd int) (err error) {
	686	_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
	687	if e1 != 0 {
	688	err = errnoErr(e1)
	689	}
	690	return
	691	}
	692
	693	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	694
	695	func Dup(fd int) (nfd int, err error) {
	696	r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	697	nfd = int(r0)
	698	if e1 != 0 {
	699	err = errnoErr(e1)
	700	}
	701	return
	702	}
	703
	704	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	705
	706	func Dup2(from int, to int) (err error) {
	707	_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
	708	if e1 != 0 {
	709	err = errnoErr(e1)
	710	}
	711	return
	712	}
	713
	714	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	715
	716	func Exchangedata(path1 string, path2 string, options int) (err error) {
	717	var _p0 *byte
	718	_p0, err = BytePtrFromString(path1)
	719	if err != nil {
	720	return
	721	}
	722	var _p1 *byte
	723	_p1, err = BytePtrFromString(path2)
	724	if err != nil {
	725	return
	726	}
	727	_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	728	if e1 != 0 {
	729	err = errnoErr(e1)
	730	}
	731	return
	732	}
	733
	734	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	735
	736	func Exit(code int) {
	737	Syscall(SYS_EXIT, uintptr(code), 0, 0)
	738	return
	739	}
	740
	741	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	742
	743	func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) {
	744	var _p0 *byte
	745	_p0, err = BytePtrFromString(path)
	746	if err != nil {
	747	return
	748	}
	749	_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	750	if e1 != 0 {
	751	err = errnoErr(e1)
	752	}
	753	return
	754	}
	755
	756	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	757
	758	func Fchdir(fd int) (err error) {
	759	_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
	760	if e1 != 0 {
	761	err = errnoErr(e1)
	762	}
	763	return
	764	}
	765
	766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	767
	768	func Fchflags(fd int, flags int) (err error) {
	769	_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
	770	if e1 != 0 {
	771	err = errnoErr(e1)
	772	}
	773	return
	774	}
	775
	776	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	777
	778	func Fchmod(fd int, mode uint32) (err error) {
	779	_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
	780	if e1 != 0 {
	781	err = errnoErr(e1)
	782	}
	783	return
	784	}
	785
	786	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	787
	788	func Fchmodat(dirfd int, path string, mode uint32, flags int) (err error) {
	789	var _p0 *byte
	790	_p0, err = BytePtrFromString(path)
	791	if err != nil {
	792	return
	793	}
	794	_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	795	if e1 != 0 {
	796	err = errnoErr(e1)
	797	}
	798	return
	799	}
	800
	801	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	802
	803	func Fchown(fd int, uid int, gid int) (err error) {
	804	_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
	805	if e1 != 0 {
	806	err = errnoErr(e1)
	807	}
	808	return
	809	}
	810
	811	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	812
	813	func Fchownat(dirfd int, path string, uid int, gid int, flags int) (err error) {
	814	var _p0 *byte
	815	_p0, err = BytePtrFromString(path)
	816	if err != nil {
	817	return
	818	}
	819	_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	820	if e1 != 0 {
	821	err = errnoErr(e1)
	822	}
	823	return
	824	}
	825
	826	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	827
	828	func Flock(fd int, how int) (err error) {
	829	_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
	830	if e1 != 0 {
	831	err = errnoErr(e1)
	832	}
	833	return
	834	}
	835
	836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	837
	838	func Fpathconf(fd int, name int) (val int, err error) {
	839	r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	840	val = int(r0)
	841	if e1 != 0 {
	842	err = errnoErr(e1)
	843	}
	844	return
	845	}
	846
	847	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	848
	849	func Fsync(fd int) (err error) {
	850	_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
	851	if e1 != 0 {
	852	err = errnoErr(e1)
	853	}
	854	return
	855	}
	856
	857	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	858
	859	func Ftruncate(fd int, length int64) (err error) {
	860	_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
	861	if e1 != 0 {
	862	err = errnoErr(e1)
	863	}
	864	return
	865	}
	866
	867	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	868
	869	func Getdtablesize() (size int) {
	870	r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	871	size = int(r0)
	872	return
	873	}
	874
	875	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	876
	877	func Getegid() (egid int) {
	878	r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	879	egid = int(r0)
	880	return
	881	}
	882
	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	884
	885	func Geteuid() (uid int) {
	886	r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	887	uid = int(r0)
	888	return
	889	}
	890
	891	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	892
	893	func Getgid() (gid int) {
	894	r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	895	gid = int(r0)
	896	return
	897	}
	898
	899	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	900
	901	func Getpgid(pid int) (pgid int, err error) {
	902	r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	903	pgid = int(r0)
	904	if e1 != 0 {
	905	err = errnoErr(e1)
	906	}
	907	return
	908	}
	909
	910	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	911
	912	func Getpgrp() (pgrp int) {
	913	r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	914	pgrp = int(r0)
	915	return
	916	}
	917
	918	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	919
	920	func Getpid() (pid int) {
	921	r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	922	pid = int(r0)
	923	return
	924	}
	925
	926	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	927
	928	func Getppid() (ppid int) {
	929	r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	930	ppid = int(r0)
	931	return
	932	}
	933
	934	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	935
	936	func Getpriority(which int, who int) (prio int, err error) {
	937	r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	938	prio = int(r0)
	939	if e1 != 0 {
	940	err = errnoErr(e1)
	941	}
	942	return
	943	}
	944
	945	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	946
	947	func Getrlimit(which int, lim *Rlimit) (err error) {
	948	_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	949	if e1 != 0 {
	950	err = errnoErr(e1)
	951	}
	952	return
	953	}
	954
	955	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	956
	957	func Getrusage(who int, rusage *Rusage) (err error) {
	958	_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	959	if e1 != 0 {
	960	err = errnoErr(e1)
	961	}
	962	return
	963	}
	964
	965	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	966
	967	func Getsid(pid int) (sid int, err error) {
	968	r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	969	sid = int(r0)
	970	if e1 != 0 {
	971	err = errnoErr(e1)
	972	}
	973	return
	974	}
	975
	976	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	977
	978	func Getuid() (uid int) {
	979	r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	980	uid = int(r0)
	981	return
	982	}
	983
	984	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	985
	986	func Issetugid() (tainted bool) {
	987	r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	988	tainted = bool(r0 != 0)
	989	return
	990	}
	991
	992	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	993
	994	func Kqueue() (fd int, err error) {
	995	r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	996	fd = int(r0)
	997	if e1 != 0 {
	998	err = errnoErr(e1)
	999	}
	1000	return
	1001	}
	1002
	1003	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1004
	1005	func Lchown(path string, uid int, gid int) (err error) {
	1006	var _p0 *byte
	1007	_p0, err = BytePtrFromString(path)
	1008	if err != nil {
	1009	return
	1010	}
	1011	_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1012	if e1 != 0 {
	1013	err = errnoErr(e1)
	1014	}
	1015	return
	1016	}
	1017
	1018	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1019
	1020	func Link(path string, link string) (err error) {
	1021	var _p0 *byte
	1022	_p0, err = BytePtrFromString(path)
	1023	if err != nil {
	1024	return
	1025	}
	1026	var _p1 *byte
	1027	_p1, err = BytePtrFromString(link)
	1028	if err != nil {
	1029	return
	1030	}
	1031	_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1032	if e1 != 0 {
	1033	err = errnoErr(e1)
	1034	}
	1035	return
	1036	}
	1037
	1038	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1039
	1040	func Linkat(pathfd int, path string, linkfd int, link string, flags int) (err error) {
	1041	var _p0 *byte
	1042	_p0, err = BytePtrFromString(path)
	1043	if err != nil {
	1044	return
	1045	}
	1046	var _p1 *byte
	1047	_p1, err = BytePtrFromString(link)
	1048	if err != nil {
	1049	return
	1050	}
	1051	_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1052	if e1 != 0 {
	1053	err = errnoErr(e1)
	1054	}
	1055	return
	1056	}
	1057
	1058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1059
	1060	func Listen(s int, backlog int) (err error) {
	1061	_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
	1062	if e1 != 0 {
	1063	err = errnoErr(e1)
	1064	}
	1065	return
	1066	}
	1067
	1068	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1069
	1070	func Mkdir(path string, mode uint32) (err error) {
	1071	var _p0 *byte
	1072	_p0, err = BytePtrFromString(path)
	1073	if err != nil {
	1074	return
	1075	}
	1076	_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1077	if e1 != 0 {
	1078	err = errnoErr(e1)
	1079	}
	1080	return
	1081	}
	1082
	1083	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1084
	1085	func Mkdirat(dirfd int, path string, mode uint32) (err error) {
	1086	var _p0 *byte
	1087	_p0, err = BytePtrFromString(path)
	1088	if err != nil {
	1089	return
	1090	}
	1091	_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1092	if e1 != 0 {
	1093	err = errnoErr(e1)
	1094	}
	1095	return
	1096	}
	1097
	1098	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1099
	1100	func Mkfifo(path string, mode uint32) (err error) {
	1101	var _p0 *byte
	1102	_p0, err = BytePtrFromString(path)
	1103	if err != nil {
	1104	return
	1105	}
	1106	_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1107	if e1 != 0 {
	1108	err = errnoErr(e1)
	1109	}
	1110	return
	1111	}
	1112
	1113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1114
	1115	func Mknod(path string, mode uint32, dev int) (err error) {
	1116	var _p0 *byte
	1117	_p0, err = BytePtrFromString(path)
	1118	if err != nil {
	1119	return
	1120	}
	1121	_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1122	if e1 != 0 {
	1123	err = errnoErr(e1)
	1124	}
	1125	return
	1126	}
	1127
	1128	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1129
	1130	func Open(path string, mode int, perm uint32) (fd int, err error) {
	1131	var _p0 *byte
	1132	_p0, err = BytePtrFromString(path)
	1133	if err != nil {
	1134	return
	1135	}
	1136	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1137	fd = int(r0)
	1138	if e1 != 0 {
	1139	err = errnoErr(e1)
	1140	}
	1141	return
	1142	}
	1143
	1144	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1145
	1146	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {
	1147	var _p0 *byte
	1148	_p0, err = BytePtrFromString(path)
	1149	if err != nil {
	1150	return
	1151	}
	1152	r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1153	fd = int(r0)
	1154	if e1 != 0 {
	1155	err = errnoErr(e1)
	1156	}
	1157	return
	1158	}
	1159
	1160	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1161
	1162	func Pathconf(path string, name int) (val int, err error) {
	1163	var _p0 *byte
	1164	_p0, err = BytePtrFromString(path)
	1165	if err != nil {
	1166	return
	1167	}
	1168	r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1169	val = int(r0)
	1170	if e1 != 0 {
	1171	err = errnoErr(e1)
	1172	}
	1173	return
	1174	}
	1175
	1176	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1177
	1178	func Pread(fd int, p []byte, offset int64) (n int, err error) {
	1179	var _p0 unsafe.Pointer
	1180	if len(p) > 0 {
	1181	_p0 = unsafe.Pointer(&p[0])
	1182	} else {
	1183	_p0 = unsafe.Pointer(&_zero)
	1184	}
	1185	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1186	n = int(r0)
	1187	if e1 != 0 {
	1188	err = errnoErr(e1)
	1189	}
	1190	return
	1191	}
	1192
	1193	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1194
	1195	func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
	1196	var _p0 unsafe.Pointer
	1197	if len(p) > 0 {
	1198	_p0 = unsafe.Pointer(&p[0])
	1199	} else {
	1200	_p0 = unsafe.Pointer(&_zero)
	1201	}
	1202	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1203	n = int(r0)
	1204	if e1 != 0 {
	1205	err = errnoErr(e1)
	1206	}
	1207	return
	1208	}
	1209
	1210	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1211
	1212	func read(fd int, p []byte) (n int, err error) {
	1213	var _p0 unsafe.Pointer
	1214	if len(p) > 0 {
	1215	_p0 = unsafe.Pointer(&p[0])
	1216	} else {
	1217	_p0 = unsafe.Pointer(&_zero)
	1218	}
	1219	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1220	n = int(r0)
	1221	if e1 != 0 {
	1222	err = errnoErr(e1)
	1223	}
	1224	return
	1225	}
	1226
	1227	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1228
	1229	func Readlink(path string, buf []byte) (n int, err error) {
	1230	var _p0 *byte
	1231	_p0, err = BytePtrFromString(path)
	1232	if err != nil {
	1233	return
	1234	}
	1235	var _p1 unsafe.Pointer
	1236	if len(buf) > 0 {
	1237	_p1 = unsafe.Pointer(&buf[0])
	1238	} else {
	1239	_p1 = unsafe.Pointer(&_zero)
	1240	}
	1241	r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1242	n = int(r0)
	1243	if e1 != 0 {
	1244	err = errnoErr(e1)
	1245	}
	1246	return
	1247	}
	1248
	1249	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1250
	1251	func Readlinkat(dirfd int, path string, buf []byte) (n int, err error) {
	1252	var _p0 *byte
	1253	_p0, err = BytePtrFromString(path)
	1254	if err != nil {
	1255	return
	1256	}
	1257	var _p1 unsafe.Pointer
	1258	if len(buf) > 0 {
	1259	_p1 = unsafe.Pointer(&buf[0])
	1260	} else {
	1261	_p1 = unsafe.Pointer(&_zero)
	1262	}
	1263	r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1264	n = int(r0)
	1265	if e1 != 0 {
	1266	err = errnoErr(e1)
	1267	}
	1268	return
	1269	}
	1270
	1271	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1272
	1273	func Rename(from string, to string) (err error) {
	1274	var _p0 *byte
	1275	_p0, err = BytePtrFromString(from)
	1276	if err != nil {
	1277	return
	1278	}
	1279	var _p1 *byte
	1280	_p1, err = BytePtrFromString(to)
	1281	if err != nil {
	1282	return
	1283	}
	1284	_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1285	if e1 != 0 {
	1286	err = errnoErr(e1)
	1287	}
	1288	return
	1289	}
	1290
	1291	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1292
	1293	func Renameat(fromfd int, from string, tofd int, to string) (err error) {
	1294	var _p0 *byte
	1295	_p0, err = BytePtrFromString(from)
	1296	if err != nil {
	1297	return
	1298	}
	1299	var _p1 *byte
	1300	_p1, err = BytePtrFromString(to)
	1301	if err != nil {
	1302	return
	1303	}
	1304	_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1305	if e1 != 0 {
	1306	err = errnoErr(e1)
	1307	}
	1308	return
	1309	}
	1310
	1311	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1312
	1313	func Revoke(path string) (err error) {
	1314	var _p0 *byte
	1315	_p0, err = BytePtrFromString(path)
	1316	if err != nil {
	1317	return
	1318	}
	1319	_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1320	if e1 != 0 {
	1321	err = errnoErr(e1)
	1322	}
	1323	return
	1324	}
	1325
	1326	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1327
	1328	func Rmdir(path string) (err error) {
	1329	var _p0 *byte
	1330	_p0, err = BytePtrFromString(path)
	1331	if err != nil {
	1332	return
	1333	}
	1334	_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1335	if e1 != 0 {
	1336	err = errnoErr(e1)
	1337	}
	1338	return
	1339	}
	1340
	1341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1342
	1343	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
	1344	r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
	1345	newoffset = int64(r0)
	1346	if e1 != 0 {
	1347	err = errnoErr(e1)
	1348	}
	1349	return
	1350	}
	1351
	1352	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1353
	1354	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
	1355	_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
	1356	if e1 != 0 {
	1357	err = errnoErr(e1)
	1358	}
	1359	return
	1360	}
	1361
	1362	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1363
	1364	func Setegid(egid int) (err error) {
	1365	_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
	1366	if e1 != 0 {
	1367	err = errnoErr(e1)
	1368	}
	1369	return
	1370	}
	1371
	1372	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1373
	1374	func Seteuid(euid int) (err error) {
	1375	_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
	1376	if e1 != 0 {
	1377	err = errnoErr(e1)
	1378	}
	1379	return
	1380	}
	1381
	1382	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1383
	1384	func Setgid(gid int) (err error) {
	1385	_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
	1386	if e1 != 0 {
	1387	err = errnoErr(e1)
	1388	}
	1389	return
	1390	}
	1391
	1392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1393
	1394	func Setlogin(name string) (err error) {
	1395	var _p0 *byte
	1396	_p0, err = BytePtrFromString(name)
	1397	if err != nil {
	1398	return
	1399	}
	1400	_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1401	if e1 != 0 {
	1402	err = errnoErr(e1)
	1403	}
	1404	return
	1405	}
	1406
	1407	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1408
	1409	func Setpgid(pid int, pgid int) (err error) {
	1410	_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
	1411	if e1 != 0 {
	1412	err = errnoErr(e1)
	1413	}
	1414	return
	1415	}
	1416
	1417	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1418
	1419	func Setpriority(which int, who int, prio int) (err error) {
	1420	_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
	1421	if e1 != 0 {
	1422	err = errnoErr(e1)
	1423	}
	1424	return
	1425	}
	1426
	1427	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1428
	1429	func Setprivexec(flag int) (err error) {
	1430	_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
	1431	if e1 != 0 {
	1432	err = errnoErr(e1)
	1433	}
	1434	return
	1435	}
	1436
	1437	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1438
	1439	func Setregid(rgid int, egid int) (err error) {
	1440	_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
	1441	if e1 != 0 {
	1442	err = errnoErr(e1)
	1443	}
	1444	return
	1445	}
	1446
	1447	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1448
	1449	func Setreuid(ruid int, euid int) (err error) {
	1450	_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
	1451	if e1 != 0 {
	1452	err = errnoErr(e1)
	1453	}
	1454	return
	1455	}
	1456
	1457	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1458
	1459	func Setrlimit(which int, lim *Rlimit) (err error) {
	1460	_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1461	if e1 != 0 {
	1462	err = errnoErr(e1)
	1463	}
	1464	return
	1465	}
	1466
	1467	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1468
	1469	func Setsid() (pid int, err error) {
	1470	r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	1471	pid = int(r0)
	1472	if e1 != 0 {
	1473	err = errnoErr(e1)
	1474	}
	1475	return
	1476	}
	1477
	1478	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1479
	1480	func Settimeofday(tp *Timeval) (err error) {
	1481	_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1482	if e1 != 0 {
	1483	err = errnoErr(e1)
	1484	}
	1485	return
	1486	}
	1487
	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1489
	1490	func Setuid(uid int) (err error) {
	1491	_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1499
	1500	func Symlink(path string, link string) (err error) {
	1501	var _p0 *byte
	1502	_p0, err = BytePtrFromString(path)
	1503	if err != nil {
	1504	return
	1505	}
	1506	var _p1 *byte
	1507	_p1, err = BytePtrFromString(link)
	1508	if err != nil {
	1509	return
	1510	}
	1511	_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1519
	1520	func Symlinkat(oldpath string, newdirfd int, newpath string) (err error) {
	1521	var _p0 *byte
	1522	_p0, err = BytePtrFromString(oldpath)
	1523	if err != nil {
	1524	return
	1525	}
	1526	var _p1 *byte
	1527	_p1, err = BytePtrFromString(newpath)
	1528	if err != nil {
	1529	return
	1530	}
	1531	_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1539
	1540	func Sync() (err error) {
	1541	_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
	1542	if e1 != 0 {
	1543	err = errnoErr(e1)
	1544	}
	1545	return
	1546	}
	1547
	1548	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1549
	1550	func Truncate(path string, length int64) (err error) {
	1551	var _p0 *byte
	1552	_p0, err = BytePtrFromString(path)
	1553	if err != nil {
	1554	return
	1555	}
	1556	_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
	1557	if e1 != 0 {
	1558	err = errnoErr(e1)
	1559	}
	1560	return
	1561	}
	1562
	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1564
	1565	func Umask(newmask int) (oldmask int) {
	1566	r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	1567	oldmask = int(r0)
	1568	return
	1569	}
	1570
	1571	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1572
	1573	func Undelete(path string) (err error) {
	1574	var _p0 *byte
	1575	_p0, err = BytePtrFromString(path)
	1576	if err != nil {
	1577	return
	1578	}
	1579	_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1580	if e1 != 0 {
	1581	err = errnoErr(e1)
	1582	}
	1583	return
	1584	}
	1585
	1586	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1587
	1588	func Unlink(path string) (err error) {
	1589	var _p0 *byte
	1590	_p0, err = BytePtrFromString(path)
	1591	if err != nil {
	1592	return
	1593	}
	1594	_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
	1595	if e1 != 0 {
	1596	err = errnoErr(e1)
	1597	}
	1598	return
	1599	}
	1600
	1601	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1602
	1603	func Unlinkat(dirfd int, path string, flags int) (err error) {
	1604	var _p0 *byte
	1605	_p0, err = BytePtrFromString(path)
	1606	if err != nil {
	1607	return
	1608	}
	1609	_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	1610	if e1 != 0 {
	1611	err = errnoErr(e1)
	1612	}
	1613	return
	1614	}
	1615
	1616	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1617
	1618	func Unmount(path string, flags int) (err error) {
	1619	var _p0 *byte
	1620	_p0, err = BytePtrFromString(path)
	1621	if err != nil {
	1622	return
	1623	}
	1624	_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	1625	if e1 != 0 {
	1626	err = errnoErr(e1)
	1627	}
	1628	return
	1629	}
	1630
	1631	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1632
	1633	func write(fd int, p []byte) (n int, err error) {
	1634	var _p0 unsafe.Pointer
	1635	if len(p) > 0 {
	1636	_p0 = unsafe.Pointer(&p[0])
	1637	} else {
	1638	_p0 = unsafe.Pointer(&_zero)
	1639	}
	1640	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1641	n = int(r0)
	1642	if e1 != 0 {
	1643	err = errnoErr(e1)
	1644	}
	1645	return
	1646	}
	1647
	1648	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1649
	1650	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
	1651	r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
	1652	ret = uintptr(r0)
	1653	if e1 != 0 {
	1654	err = errnoErr(e1)
	1655	}
	1656	return
	1657	}
	1658
	1659	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1660
	1661	func munmap(addr uintptr, length uintptr) (err error) {
	1662	_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
	1663	if e1 != 0 {
	1664	err = errnoErr(e1)
	1665	}
	1666	return
	1667	}
	1668
	1669	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1670
	1671	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
	1672	r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1673	n = int(r0)
	1674	if e1 != 0 {
	1675	err = errnoErr(e1)
	1676	}
	1677	return
	1678	}
	1679
	1680	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1681
	1682	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
	1683	r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	1684	n = int(r0)
	1685	if e1 != 0 {
	1686	err = errnoErr(e1)
	1687	}
	1688	return
	1689	}
	1690
	1691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1692
	1693	func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
	1694	r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	1695	sec = int64(r0)
	1696	usec = int32(r1)
	1697	if e1 != 0 {
	1698	err = errnoErr(e1)
	1699	}
	1700	return
	1701	}
	1702
	1703	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1704
	1705	func Fstat(fd int, stat *Stat_t) (err error) {
	1706	_, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1707	if e1 != 0 {
	1708	err = errnoErr(e1)
	1709	}
	1710	return
	1711	}
	1712
	1713	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1714
	1715	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	1716	var _p0 *byte
	1717	_p0, err = BytePtrFromString(path)
	1718	if err != nil {
	1719	return
	1720	}
	1721	_, _, e1 := Syscall6(SYS_FSTATAT, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	1722	if e1 != 0 {
	1723	err = errnoErr(e1)
	1724	}
	1725	return
	1726	}
	1727
	1728	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1729
	1730	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	1731	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	1732	if e1 != 0 {
	1733	err = errnoErr(e1)
	1734	}
	1735	return
	1736	}
	1737
	1738	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1739
	1740	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	1741	r0, _, e1 := Syscall(SYS_GETFSSTAT, uintptr(buf), uintptr(size), uintptr(flags))
	1742	n = int(r0)
	1743	if e1 != 0 {
	1744	err = errnoErr(e1)
	1745	}
	1746	return
	1747	}
	1748
	1749	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1750
	1751	func Lstat(path string, stat *Stat_t) (err error) {
	1752	var _p0 *byte
	1753	_p0, err = BytePtrFromString(path)
	1754	if err != nil {
	1755	return
	1756	}
	1757	_, _, e1 := Syscall(SYS_LSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1758	if e1 != 0 {
	1759	err = errnoErr(e1)
	1760	}
	1761	return
	1762	}
	1763
	1764	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1765
	1766	func Stat(path string, stat *Stat_t) (err error) {
	1767	var _p0 *byte
	1768	_p0, err = BytePtrFromString(path)
	1769	if err != nil {
	1770	return
	1771	}
	1772	_, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1773	if e1 != 0 {
	1774	err = errnoErr(e1)
	1775	}
	1776	return
	1777	}
	1778
	1779	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	1780
	1781	func Statfs(path string, stat *Statfs_t) (err error) {
	1782	var _p0 *byte
	1783	_p0, err = BytePtrFromString(path)
	1784	if err != nil {
	1785	return
	1786	}
	1787	_, _, e1 := Syscall(SYS_STATFS, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	1788	if e1 != 0 {
	1789	err = errnoErr(e1)
	1790	}
	1791	return
	1792	}

+1359

-645

unix/zsyscall_darwin_arm64.go less more

0		// go run mksyscall.go -tags darwin,arm64 syscall_bsd.go syscall_darwin.go syscall_darwin_arm64.go
	0	// go run mksyscall.go -tags darwin,arm64,go1.12 syscall_bsd.go syscall_darwin.go syscall_darwin_arm64.go
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3		// +build darwin,arm64
	3	// +build darwin,arm64,go1.12
4	4
5	5	package unix
6	6

14	14	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
15	15
16	16	func getgroups(ngid int, gid *_Gid_t) (n int, err error) {
17		r0, _, e1 := RawSyscall(SYS_GETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	17	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
18	18	n = int(r0)
19	19	if e1 != 0 {
20	20	err = errnoErr(e1)

22	22	return
23	23	}
24	24
	25	func libc_getgroups_trampoline()
	26
	27	//go:linkname libc_getgroups libc_getgroups
	28	//go:cgo_import_dynamic libc_getgroups getgroups "/usr/lib/libSystem.B.dylib"
	29
25	30	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
26	31
27	32	func setgroups(ngid int, gid *_Gid_t) (err error) {
28		_, _, e1 := RawSyscall(SYS_SETGROUPS, uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
29		if e1 != 0 {
30		err = errnoErr(e1)
31		}
32		return
33		}
	33	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgroups_trampoline), uintptr(ngid), uintptr(unsafe.Pointer(gid)), 0)
	34	if e1 != 0 {
	35	err = errnoErr(e1)
	36	}
	37	return
	38	}
	39
	40	func libc_setgroups_trampoline()
	41
	42	//go:linkname libc_setgroups libc_setgroups
	43	//go:cgo_import_dynamic libc_setgroups setgroups "/usr/lib/libSystem.B.dylib"
34	44
35	45	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
36	46
37	47	func wait4(pid int, wstatus _C_int, options int, rusage Rusage) (wpid int, err error) {
38		r0, _, e1 := Syscall6(SYS_WAIT4, uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
	48	r0, _, e1 := syscall_syscall6(funcPC(libc_wait4_trampoline), uintptr(pid), uintptr(unsafe.Pointer(wstatus)), uintptr(options), uintptr(unsafe.Pointer(rusage)), 0, 0)
39	49	wpid = int(r0)
40	50	if e1 != 0 {
41	51	err = errnoErr(e1)

43	53	return
44	54	}
45	55
	56	func libc_wait4_trampoline()
	57
	58	//go:linkname libc_wait4 libc_wait4
	59	//go:cgo_import_dynamic libc_wait4 wait4 "/usr/lib/libSystem.B.dylib"
	60
46	61	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
47	62
48	63	func accept(s int, rsa RawSockaddrAny, addrlen _Socklen) (fd int, err error) {
49		r0, _, e1 := Syscall(SYS_ACCEPT, uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	64	r0, _, e1 := syscall_syscall(funcPC(libc_accept_trampoline), uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
50	65	fd = int(r0)
51	66	if e1 != 0 {
52	67	err = errnoErr(e1)

54	69	return
55	70	}
56	71
	72	func libc_accept_trampoline()
	73
	74	//go:linkname libc_accept libc_accept
	75	//go:cgo_import_dynamic libc_accept accept "/usr/lib/libSystem.B.dylib"
	76
57	77	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
58	78
59	79	func bind(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
60		_, _, e1 := Syscall(SYS_BIND, uintptr(s), uintptr(addr), uintptr(addrlen))
61		if e1 != 0 {
62		err = errnoErr(e1)
63		}
64		return
65		}
	80	_, _, e1 := syscall_syscall(funcPC(libc_bind_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	81	if e1 != 0 {
	82	err = errnoErr(e1)
	83	}
	84	return
	85	}
	86
	87	func libc_bind_trampoline()
	88
	89	//go:linkname libc_bind libc_bind
	90	//go:cgo_import_dynamic libc_bind bind "/usr/lib/libSystem.B.dylib"
66	91
67	92	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
68	93
69	94	func connect(s int, addr unsafe.Pointer, addrlen _Socklen) (err error) {
70		_, _, e1 := Syscall(SYS_CONNECT, uintptr(s), uintptr(addr), uintptr(addrlen))
71		if e1 != 0 {
72		err = errnoErr(e1)
73		}
74		return
75		}
	95	_, _, e1 := syscall_syscall(funcPC(libc_connect_trampoline), uintptr(s), uintptr(addr), uintptr(addrlen))
	96	if e1 != 0 {
	97	err = errnoErr(e1)
	98	}
	99	return
	100	}
	101
	102	func libc_connect_trampoline()
	103
	104	//go:linkname libc_connect libc_connect
	105	//go:cgo_import_dynamic libc_connect connect "/usr/lib/libSystem.B.dylib"
76	106
77	107	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
78	108
79	109	func socket(domain int, typ int, proto int) (fd int, err error) {
80		r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto))
	110	r0, _, e1 := syscall_rawSyscall(funcPC(libc_socket_trampoline), uintptr(domain), uintptr(typ), uintptr(proto))
81	111	fd = int(r0)
82	112	if e1 != 0 {
83	113	err = errnoErr(e1)

85	115	return
86	116	}
87	117
	118	func libc_socket_trampoline()
	119
	120	//go:linkname libc_socket libc_socket
	121	//go:cgo_import_dynamic libc_socket socket "/usr/lib/libSystem.B.dylib"
	122
88	123	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
89	124
90	125	func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) {
91		_, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
92		if e1 != 0 {
93		err = errnoErr(e1)
94		}
95		return
96		}
	126	_, _, e1 := syscall_syscall6(funcPC(libc_getsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0)
	127	if e1 != 0 {
	128	err = errnoErr(e1)
	129	}
	130	return
	131	}
	132
	133	func libc_getsockopt_trampoline()
	134
	135	//go:linkname libc_getsockopt libc_getsockopt
	136	//go:cgo_import_dynamic libc_getsockopt getsockopt "/usr/lib/libSystem.B.dylib"
97	137
98	138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
99	139
100	140	func setsockopt(s int, level int, name int, val unsafe.Pointer, vallen uintptr) (err error) {
101		_, _, e1 := Syscall6(SYS_SETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
102		if e1 != 0 {
103		err = errnoErr(e1)
104		}
105		return
106		}
	141	_, _, e1 := syscall_syscall6(funcPC(libc_setsockopt_trampoline), uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(vallen), 0)
	142	if e1 != 0 {
	143	err = errnoErr(e1)
	144	}
	145	return
	146	}
	147
	148	func libc_setsockopt_trampoline()
	149
	150	//go:linkname libc_setsockopt libc_setsockopt
	151	//go:cgo_import_dynamic libc_setsockopt setsockopt "/usr/lib/libSystem.B.dylib"
107	152
108	153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
109	154
110	155	func getpeername(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
111		_, _, e1 := RawSyscall(SYS_GETPEERNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
112		if e1 != 0 {
113		err = errnoErr(e1)
114		}
115		return
116		}
	156	_, _, e1 := syscall_rawSyscall(funcPC(libc_getpeername_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	157	if e1 != 0 {
	158	err = errnoErr(e1)
	159	}
	160	return
	161	}
	162
	163	func libc_getpeername_trampoline()
	164
	165	//go:linkname libc_getpeername libc_getpeername
	166	//go:cgo_import_dynamic libc_getpeername getpeername "/usr/lib/libSystem.B.dylib"
117	167
118	168	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
119	169
120	170	func getsockname(fd int, rsa RawSockaddrAny, addrlen _Socklen) (err error) {
121		_, _, e1 := RawSyscall(SYS_GETSOCKNAME, uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
122		if e1 != 0 {
123		err = errnoErr(e1)
124		}
125		return
126		}
	171	_, _, e1 := syscall_rawSyscall(funcPC(libc_getsockname_trampoline), uintptr(fd), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen)))
	172	if e1 != 0 {
	173	err = errnoErr(e1)
	174	}
	175	return
	176	}
	177
	178	func libc_getsockname_trampoline()
	179
	180	//go:linkname libc_getsockname libc_getsockname
	181	//go:cgo_import_dynamic libc_getsockname getsockname "/usr/lib/libSystem.B.dylib"
127	182
128	183	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
129	184
130	185	func Shutdown(s int, how int) (err error) {
131		_, _, e1 := Syscall(SYS_SHUTDOWN, uintptr(s), uintptr(how), 0)
132		if e1 != 0 {
133		err = errnoErr(e1)
134		}
135		return
136		}
	186	_, _, e1 := syscall_syscall(funcPC(libc_shutdown_trampoline), uintptr(s), uintptr(how), 0)
	187	if e1 != 0 {
	188	err = errnoErr(e1)
	189	}
	190	return
	191	}
	192
	193	func libc_shutdown_trampoline()
	194
	195	//go:linkname libc_shutdown libc_shutdown
	196	//go:cgo_import_dynamic libc_shutdown shutdown "/usr/lib/libSystem.B.dylib"
137	197
138	198	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
139	199
140	200	func socketpair(domain int, typ int, proto int, fd *[2]int32) (err error) {
141		_, _, e1 := RawSyscall6(SYS_SOCKETPAIR, uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
142		if e1 != 0 {
143		err = errnoErr(e1)
144		}
145		return
146		}
	201	_, _, e1 := syscall_rawSyscall6(funcPC(libc_socketpair_trampoline), uintptr(domain), uintptr(typ), uintptr(proto), uintptr(unsafe.Pointer(fd)), 0, 0)
	202	if e1 != 0 {
	203	err = errnoErr(e1)
	204	}
	205	return
	206	}
	207
	208	func libc_socketpair_trampoline()
	209
	210	//go:linkname libc_socketpair libc_socketpair
	211	//go:cgo_import_dynamic libc_socketpair socketpair "/usr/lib/libSystem.B.dylib"
147	212
148	213	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
149	214

154	219	} else {
155	220	_p0 = unsafe.Pointer(&_zero)
156	221	}
157		r0, _, e1 := Syscall6(SYS_RECVFROM, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(flags), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)))
	222	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)))
158	223	n = int(r0)
159	224	if e1 != 0 {
160	225	err = errnoErr(e1)
161	226	}
162	227	return
163	228	}
	229
	230	func libc_recvfrom_trampoline()
	231
	232	//go:linkname libc_recvfrom libc_recvfrom
	233	//go:cgo_import_dynamic libc_recvfrom recvfrom "/usr/lib/libSystem.B.dylib"
164	234
165	235	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
166	236

171	241	} else {
172	242	_p0 = unsafe.Pointer(&_zero)
173	243	}
174		_, _, e1 := Syscall6(SYS_SENDTO, uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
175		if e1 != 0 {
176		err = errnoErr(e1)
177		}
178		return
179		}
	244	_, _, e1 := syscall_syscall6(funcPC(libc_sendto_trampoline), uintptr(s), uintptr(_p0), uintptr(len(buf)), uintptr(flags), uintptr(to), uintptr(addrlen))
	245	if e1 != 0 {
	246	err = errnoErr(e1)
	247	}
	248	return
	249	}
	250
	251	func libc_sendto_trampoline()
	252
	253	//go:linkname libc_sendto libc_sendto
	254	//go:cgo_import_dynamic libc_sendto sendto "/usr/lib/libSystem.B.dylib"
180	255
181	256	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
182	257
183	258	func recvmsg(s int, msg *Msghdr, flags int) (n int, err error) {
184		r0, _, e1 := Syscall(SYS_RECVMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	259	r0, _, e1 := syscall_syscall(funcPC(libc_recvmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
185	260	n = int(r0)
186	261	if e1 != 0 {
187	262	err = errnoErr(e1)

189	264	return
190	265	}
191	266
	267	func libc_recvmsg_trampoline()
	268
	269	//go:linkname libc_recvmsg libc_recvmsg
	270	//go:cgo_import_dynamic libc_recvmsg recvmsg "/usr/lib/libSystem.B.dylib"
	271
192	272	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
193	273
194	274	func sendmsg(s int, msg *Msghdr, flags int) (n int, err error) {
195		r0, _, e1 := Syscall(SYS_SENDMSG, uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
	275	r0, _, e1 := syscall_syscall(funcPC(libc_sendmsg_trampoline), uintptr(s), uintptr(unsafe.Pointer(msg)), uintptr(flags))
196	276	n = int(r0)
197	277	if e1 != 0 {
198	278	err = errnoErr(e1)

200	280	return
201	281	}
202	282
	283	func libc_sendmsg_trampoline()
	284
	285	//go:linkname libc_sendmsg libc_sendmsg
	286	//go:cgo_import_dynamic libc_sendmsg sendmsg "/usr/lib/libSystem.B.dylib"
	287
203	288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
204	289
205	290	func kevent(kq int, change unsafe.Pointer, nchange int, event unsafe.Pointer, nevent int, timeout *Timespec) (n int, err error) {
206		r0, _, e1 := Syscall6(SYS_KEVENT, uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
	291	r0, _, e1 := syscall_syscall6(funcPC(libc_kevent_trampoline), uintptr(kq), uintptr(change), uintptr(nchange), uintptr(event), uintptr(nevent), uintptr(unsafe.Pointer(timeout)))
207	292	n = int(r0)
208	293	if e1 != 0 {
209	294	err = errnoErr(e1)
210	295	}
211	296	return
212	297	}
	298
	299	func libc_kevent_trampoline()
	300
	301	//go:linkname libc_kevent libc_kevent
	302	//go:cgo_import_dynamic libc_kevent kevent "/usr/lib/libSystem.B.dylib"
213	303
214	304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
215	305

220	310	} else {
221	311	_p0 = unsafe.Pointer(&_zero)
222	312	}
223		_, _, e1 := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen))
224		if e1 != 0 {
225		err = errnoErr(e1)
226		}
227		return
228		}
	313	_, _, 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))
	314	if e1 != 0 {
	315	err = errnoErr(e1)
	316	}
	317	return
	318	}
	319
	320	func libc___sysctl_trampoline()
	321
	322	//go:linkname libc___sysctl libc___sysctl
	323	//go:cgo_import_dynamic libc___sysctl __sysctl "/usr/lib/libSystem.B.dylib"
229	324
230	325	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
231	326

235	330	if err != nil {
236	331	return
237	332	}
238		_, _, e1 := Syscall(SYS_UTIMES, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
239		if e1 != 0 {
240		err = errnoErr(e1)
241		}
242		return
243		}
	333	_, _, e1 := syscall_syscall(funcPC(libc_utimes_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(timeval)), 0)
	334	if e1 != 0 {
	335	err = errnoErr(e1)
	336	}
	337	return
	338	}
	339
	340	func libc_utimes_trampoline()
	341
	342	//go:linkname libc_utimes libc_utimes
	343	//go:cgo_import_dynamic libc_utimes utimes "/usr/lib/libSystem.B.dylib"
244	344
245	345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
246	346
247	347	func futimes(fd int, timeval *[2]Timeval) (err error) {
248		_, _, e1 := Syscall(SYS_FUTIMES, uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
249		if e1 != 0 {
250		err = errnoErr(e1)
251		}
252		return
253		}
	348	_, _, e1 := syscall_syscall(funcPC(libc_futimes_trampoline), uintptr(fd), uintptr(unsafe.Pointer(timeval)), 0)
	349	if e1 != 0 {
	350	err = errnoErr(e1)
	351	}
	352	return
	353	}
	354
	355	func libc_futimes_trampoline()
	356
	357	//go:linkname libc_futimes libc_futimes
	358	//go:cgo_import_dynamic libc_futimes futimes "/usr/lib/libSystem.B.dylib"
254	359
255	360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
256	361
257	362	func fcntl(fd int, cmd int, arg int) (val int, err error) {
258		r0, _, e1 := Syscall(SYS_FCNTL, uintptr(fd), uintptr(cmd), uintptr(arg))
	363	r0, _, e1 := syscall_syscall(funcPC(libc_fcntl_trampoline), uintptr(fd), uintptr(cmd), uintptr(arg))
259	364	val = int(r0)
260	365	if e1 != 0 {
261	366	err = errnoErr(e1)

263	368	return
264	369	}
265	370
	371	func libc_fcntl_trampoline()
	372
	373	//go:linkname libc_fcntl libc_fcntl
	374	//go:cgo_import_dynamic libc_fcntl fcntl "/usr/lib/libSystem.B.dylib"
	375
266	376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
267	377
268	378	func poll(fds *PollFd, nfds int, timeout int) (n int, err error) {
269		r0, _, e1 := Syscall(SYS_POLL, uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
	379	r0, _, e1 := syscall_syscall(funcPC(libc_poll_trampoline), uintptr(unsafe.Pointer(fds)), uintptr(nfds), uintptr(timeout))
270	380	n = int(r0)
271	381	if e1 != 0 {
272	382	err = errnoErr(e1)
273	383	}
274	384	return
275	385	}
	386
	387	func libc_poll_trampoline()
	388
	389	//go:linkname libc_poll libc_poll
	390	//go:cgo_import_dynamic libc_poll poll "/usr/lib/libSystem.B.dylib"
276	391
277	392	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
278	393

283	398	} else {
284	399	_p0 = unsafe.Pointer(&_zero)
285	400	}
286		_, _, e1 := Syscall(SYS_MADVISE, uintptr(_p0), uintptr(len(b)), uintptr(behav))
287		if e1 != 0 {
288		err = errnoErr(e1)
289		}
290		return
291		}
	401	_, _, e1 := syscall_syscall(funcPC(libc_madvise_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(behav))
	402	if e1 != 0 {
	403	err = errnoErr(e1)
	404	}
	405	return
	406	}
	407
	408	func libc_madvise_trampoline()
	409
	410	//go:linkname libc_madvise libc_madvise
	411	//go:cgo_import_dynamic libc_madvise madvise "/usr/lib/libSystem.B.dylib"
292	412
293	413	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
294	414

299	419	} else {
300	420	_p0 = unsafe.Pointer(&_zero)
301	421	}
302		_, _, e1 := Syscall(SYS_MLOCK, uintptr(_p0), uintptr(len(b)), 0)
303		if e1 != 0 {
304		err = errnoErr(e1)
305		}
306		return
307		}
	422	_, _, e1 := syscall_syscall(funcPC(libc_mlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	423	if e1 != 0 {
	424	err = errnoErr(e1)
	425	}
	426	return
	427	}
	428
	429	func libc_mlock_trampoline()
	430
	431	//go:linkname libc_mlock libc_mlock
	432	//go:cgo_import_dynamic libc_mlock mlock "/usr/lib/libSystem.B.dylib"
308	433
309	434	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
310	435
311	436	func Mlockall(flags int) (err error) {
312		_, _, e1 := Syscall(SYS_MLOCKALL, uintptr(flags), 0, 0)
313		if e1 != 0 {
314		err = errnoErr(e1)
315		}
316		return
317		}
	437	_, _, e1 := syscall_syscall(funcPC(libc_mlockall_trampoline), uintptr(flags), 0, 0)
	438	if e1 != 0 {
	439	err = errnoErr(e1)
	440	}
	441	return
	442	}
	443
	444	func libc_mlockall_trampoline()
	445
	446	//go:linkname libc_mlockall libc_mlockall
	447	//go:cgo_import_dynamic libc_mlockall mlockall "/usr/lib/libSystem.B.dylib"
318	448
319	449	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
320	450

325	455	} else {
326	456	_p0 = unsafe.Pointer(&_zero)
327	457	}
328		_, _, e1 := Syscall(SYS_MPROTECT, uintptr(_p0), uintptr(len(b)), uintptr(prot))
329		if e1 != 0 {
330		err = errnoErr(e1)
331		}
332		return
333		}
	458	_, _, e1 := syscall_syscall(funcPC(libc_mprotect_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(prot))
	459	if e1 != 0 {
	460	err = errnoErr(e1)
	461	}
	462	return
	463	}
	464
	465	func libc_mprotect_trampoline()
	466
	467	//go:linkname libc_mprotect libc_mprotect
	468	//go:cgo_import_dynamic libc_mprotect mprotect "/usr/lib/libSystem.B.dylib"
334	469
335	470	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
336	471

341	476	} else {
342	477	_p0 = unsafe.Pointer(&_zero)
343	478	}
344		_, _, e1 := Syscall(SYS_MSYNC, uintptr(_p0), uintptr(len(b)), uintptr(flags))
345		if e1 != 0 {
346		err = errnoErr(e1)
347		}
348		return
349		}
	479	_, _, e1 := syscall_syscall(funcPC(libc_msync_trampoline), uintptr(_p0), uintptr(len(b)), uintptr(flags))
	480	if e1 != 0 {
	481	err = errnoErr(e1)
	482	}
	483	return
	484	}
	485
	486	func libc_msync_trampoline()
	487
	488	//go:linkname libc_msync libc_msync
	489	//go:cgo_import_dynamic libc_msync msync "/usr/lib/libSystem.B.dylib"
350	490
351	491	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
352	492

357	497	} else {
358	498	_p0 = unsafe.Pointer(&_zero)
359	499	}
360		_, _, e1 := Syscall(SYS_MUNLOCK, uintptr(_p0), uintptr(len(b)), 0)
361		if e1 != 0 {
362		err = errnoErr(e1)
363		}
364		return
365		}
	500	_, _, e1 := syscall_syscall(funcPC(libc_munlock_trampoline), uintptr(_p0), uintptr(len(b)), 0)
	501	if e1 != 0 {
	502	err = errnoErr(e1)
	503	}
	504	return
	505	}
	506
	507	func libc_munlock_trampoline()
	508
	509	//go:linkname libc_munlock libc_munlock
	510	//go:cgo_import_dynamic libc_munlock munlock "/usr/lib/libSystem.B.dylib"
366	511
367	512	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
368	513
369	514	func Munlockall() (err error) {
370		_, _, e1 := Syscall(SYS_MUNLOCKALL, 0, 0, 0)
371		if e1 != 0 {
372		err = errnoErr(e1)
373		}
374		return
375		}
	515	_, _, e1 := syscall_syscall(funcPC(libc_munlockall_trampoline), 0, 0, 0)
	516	if e1 != 0 {
	517	err = errnoErr(e1)
	518	}
	519	return
	520	}
	521
	522	func libc_munlockall_trampoline()
	523
	524	//go:linkname libc_munlockall libc_munlockall
	525	//go:cgo_import_dynamic libc_munlockall munlockall "/usr/lib/libSystem.B.dylib"
376	526
377	527	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
378	528
379	529	func ptrace(request int, pid int, addr uintptr, data uintptr) (err error) {
380		_, _, e1 := Syscall6(SYS_PTRACE, uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
381		if e1 != 0 {
382		err = errnoErr(e1)
383		}
384		return
385		}
	530	_, _, e1 := syscall_syscall6(funcPC(libc_ptrace_trampoline), uintptr(request), uintptr(pid), uintptr(addr), uintptr(data), 0, 0)
	531	if e1 != 0 {
	532	err = errnoErr(e1)
	533	}
	534	return
	535	}
	536
	537	func libc_ptrace_trampoline()
	538
	539	//go:linkname libc_ptrace libc_ptrace
	540	//go:cgo_import_dynamic libc_ptrace ptrace "/usr/lib/libSystem.B.dylib"
	541
	542	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	543
	544	func getattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	545	_, _, e1 := syscall_syscall6(funcPC(libc_getattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	546	if e1 != 0 {
	547	err = errnoErr(e1)
	548	}
	549	return
	550	}
	551
	552	func libc_getattrlist_trampoline()
	553
	554	//go:linkname libc_getattrlist libc_getattrlist
	555	//go:cgo_import_dynamic libc_getattrlist getattrlist "/usr/lib/libSystem.B.dylib"
386	556
387	557	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
388	558
389	559	func pipe() (r int, w int, err error) {
390		r0, r1, e1 := RawSyscall(SYS_PIPE, 0, 0, 0)
	560	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_pipe_trampoline), 0, 0, 0)
391	561	r = int(r0)
392	562	w = int(r1)
393	563	if e1 != 0 {

396	566	return
397	567	}
398	568
	569	func libc_pipe_trampoline()
	570
	571	//go:linkname libc_pipe libc_pipe
	572	//go:cgo_import_dynamic libc_pipe pipe "/usr/lib/libSystem.B.dylib"
	573
399	574	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
400	575
401	576	func getxattr(path string, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

409	584	if err != nil {
410	585	return
411	586	}
412		r0, _, e1 := Syscall6(SYS_GETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	587	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))
413	588	sz = int(r0)
414	589	if e1 != 0 {
415	590	err = errnoErr(e1)

417	592	return
418	593	}
419	594
	595	func libc_getxattr_trampoline()
	596
	597	//go:linkname libc_getxattr libc_getxattr
	598	//go:cgo_import_dynamic libc_getxattr getxattr "/usr/lib/libSystem.B.dylib"
	599
420	600	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
421	601
422	602	func fgetxattr(fd int, attr string, dest *byte, size int, position uint32, options int) (sz int, err error) {

425	605	if err != nil {
426	606	return
427	607	}
428		r0, _, e1 := Syscall6(SYS_FGETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
	608	r0, _, e1 := syscall_syscall6(funcPC(libc_fgetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(position), uintptr(options))
429	609	sz = int(r0)
430	610	if e1 != 0 {
431	611	err = errnoErr(e1)
432	612	}
433	613	return
434	614	}
	615
	616	func libc_fgetxattr_trampoline()
	617
	618	//go:linkname libc_fgetxattr libc_fgetxattr
	619	//go:cgo_import_dynamic libc_fgetxattr fgetxattr "/usr/lib/libSystem.B.dylib"
435	620
436	621	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
437	622

446	631	if err != nil {
447	632	return
448	633	}
449		_, _, e1 := Syscall6(SYS_SETXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
450		if e1 != 0 {
451		err = errnoErr(e1)
452		}
453		return
454		}
	634	_, _, 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))
	635	if e1 != 0 {
	636	err = errnoErr(e1)
	637	}
	638	return
	639	}
	640
	641	func libc_setxattr_trampoline()
	642
	643	//go:linkname libc_setxattr libc_setxattr
	644	//go:cgo_import_dynamic libc_setxattr setxattr "/usr/lib/libSystem.B.dylib"
455	645
456	646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
457	647

461	651	if err != nil {
462	652	return
463	653	}
464		_, _, e1 := Syscall6(SYS_FSETXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
465		if e1 != 0 {
466		err = errnoErr(e1)
467		}
468		return
469		}
	654	_, _, e1 := syscall_syscall6(funcPC(libc_fsetxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(data)), uintptr(size), uintptr(position), uintptr(options))
	655	if e1 != 0 {
	656	err = errnoErr(e1)
	657	}
	658	return
	659	}
	660
	661	func libc_fsetxattr_trampoline()
	662
	663	//go:linkname libc_fsetxattr libc_fsetxattr
	664	//go:cgo_import_dynamic libc_fsetxattr fsetxattr "/usr/lib/libSystem.B.dylib"
470	665
471	666	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
472	667

481	676	if err != nil {
482	677	return
483	678	}
484		_, _, e1 := Syscall(SYS_REMOVEXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
485		if e1 != 0 {
486		err = errnoErr(e1)
487		}
488		return
489		}
	679	_, _, e1 := syscall_syscall(funcPC(libc_removexattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	680	if e1 != 0 {
	681	err = errnoErr(e1)
	682	}
	683	return
	684	}
	685
	686	func libc_removexattr_trampoline()
	687
	688	//go:linkname libc_removexattr libc_removexattr
	689	//go:cgo_import_dynamic libc_removexattr removexattr "/usr/lib/libSystem.B.dylib"
490	690
491	691	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
492	692

496	696	if err != nil {
497	697	return
498	698	}
499		_, _, e1 := Syscall(SYS_FREMOVEXATTR, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
500		if e1 != 0 {
501		err = errnoErr(e1)
502		}
503		return
504		}
	699	_, _, e1 := syscall_syscall(funcPC(libc_fremovexattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(options))
	700	if e1 != 0 {
	701	err = errnoErr(e1)
	702	}
	703	return
	704	}
	705
	706	func libc_fremovexattr_trampoline()
	707
	708	//go:linkname libc_fremovexattr libc_fremovexattr
	709	//go:cgo_import_dynamic libc_fremovexattr fremovexattr "/usr/lib/libSystem.B.dylib"
505	710
506	711	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
507	712

511	716	if err != nil {
512	717	return
513	718	}
514		r0, _, e1 := Syscall6(SYS_LISTXATTR, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	719	r0, _, e1 := syscall_syscall6(funcPC(libc_listxattr_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
515	720	sz = int(r0)
516	721	if e1 != 0 {
517	722	err = errnoErr(e1)

519	724	return
520	725	}
521	726
	727	func libc_listxattr_trampoline()
	728
	729	//go:linkname libc_listxattr libc_listxattr
	730	//go:cgo_import_dynamic libc_listxattr listxattr "/usr/lib/libSystem.B.dylib"
	731
522	732	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
523	733
524	734	func flistxattr(fd int, dest *byte, size int, options int) (sz int, err error) {
525		r0, _, e1 := Syscall6(SYS_FLISTXATTR, uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
	735	r0, _, e1 := syscall_syscall6(funcPC(libc_flistxattr_trampoline), uintptr(fd), uintptr(unsafe.Pointer(dest)), uintptr(size), uintptr(options), 0, 0)
526	736	sz = int(r0)
527	737	if e1 != 0 {
528	738	err = errnoErr(e1)

530	740	return
531	741	}
532	742
	743	func libc_flistxattr_trampoline()
	744
	745	//go:linkname libc_flistxattr libc_flistxattr
	746	//go:cgo_import_dynamic libc_flistxattr flistxattr "/usr/lib/libSystem.B.dylib"
	747
	748	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	749
	750	func setattrlist(path *byte, list unsafe.Pointer, buf unsafe.Pointer, size uintptr, options int) (err error) {
	751	_, _, e1 := syscall_syscall6(funcPC(libc_setattrlist_trampoline), uintptr(unsafe.Pointer(path)), uintptr(list), uintptr(buf), uintptr(size), uintptr(options), 0)
	752	if e1 != 0 {
	753	err = errnoErr(e1)
	754	}
	755	return
	756	}
	757
	758	func libc_setattrlist_trampoline()
	759
	760	//go:linkname libc_setattrlist libc_setattrlist
	761	//go:cgo_import_dynamic libc_setattrlist setattrlist "/usr/lib/libSystem.B.dylib"
	762
533	763	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
534	764
535	765	func kill(pid int, signum int, posix int) (err error) {
536		_, _, e1 := Syscall(SYS_KILL, uintptr(pid), uintptr(signum), uintptr(posix))
537		if e1 != 0 {
538		err = errnoErr(e1)
539		}
540		return
541		}
	766	_, _, e1 := syscall_syscall(funcPC(libc_kill_trampoline), uintptr(pid), uintptr(signum), uintptr(posix))
	767	if e1 != 0 {
	768	err = errnoErr(e1)
	769	}
	770	return
	771	}
	772
	773	func libc_kill_trampoline()
	774
	775	//go:linkname libc_kill libc_kill
	776	//go:cgo_import_dynamic libc_kill kill "/usr/lib/libSystem.B.dylib"
542	777
543	778	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
544	779
545	780	func ioctl(fd int, req uint, arg uintptr) (err error) {
546		_, _, e1 := Syscall(SYS_IOCTL, uintptr(fd), uintptr(req), uintptr(arg))
547		if e1 != 0 {
548		err = errnoErr(e1)
549		}
550		return
551		}
	781	_, _, e1 := syscall_syscall(funcPC(libc_ioctl_trampoline), uintptr(fd), uintptr(req), uintptr(arg))
	782	if e1 != 0 {
	783	err = errnoErr(e1)
	784	}
	785	return
	786	}
	787
	788	func libc_ioctl_trampoline()
	789
	790	//go:linkname libc_ioctl libc_ioctl
	791	//go:cgo_import_dynamic libc_ioctl ioctl "/usr/lib/libSystem.B.dylib"
	792
	793	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	794
	795	func sendfile(infd int, outfd int, offset int64, len *int64, hdtr unsafe.Pointer, flags int) (err error) {
	796	_, _, e1 := syscall_syscall6(funcPC(libc_sendfile_trampoline), uintptr(infd), uintptr(outfd), uintptr(offset), uintptr(unsafe.Pointer(len)), uintptr(hdtr), uintptr(flags))
	797	if e1 != 0 {
	798	err = errnoErr(e1)
	799	}
	800	return
	801	}
	802
	803	func libc_sendfile_trampoline()
	804
	805	//go:linkname libc_sendfile libc_sendfile
	806	//go:cgo_import_dynamic libc_sendfile sendfile "/usr/lib/libSystem.B.dylib"
552	807
553	808	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
554	809

558	813	if err != nil {
559	814	return
560	815	}
561		_, _, e1 := Syscall(SYS_ACCESS, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
562		if e1 != 0 {
563		err = errnoErr(e1)
564		}
565		return
566		}
	816	_, _, e1 := syscall_syscall(funcPC(libc_access_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	817	if e1 != 0 {
	818	err = errnoErr(e1)
	819	}
	820	return
	821	}
	822
	823	func libc_access_trampoline()
	824
	825	//go:linkname libc_access libc_access
	826	//go:cgo_import_dynamic libc_access access "/usr/lib/libSystem.B.dylib"
567	827
568	828	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
569	829
570	830	func Adjtime(delta Timeval, olddelta Timeval) (err error) {
571		_, _, e1 := Syscall(SYS_ADJTIME, uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
572		if e1 != 0 {
573		err = errnoErr(e1)
574		}
575		return
576		}
	831	_, _, e1 := syscall_syscall(funcPC(libc_adjtime_trampoline), uintptr(unsafe.Pointer(delta)), uintptr(unsafe.Pointer(olddelta)), 0)
	832	if e1 != 0 {
	833	err = errnoErr(e1)
	834	}
	835	return
	836	}
	837
	838	func libc_adjtime_trampoline()
	839
	840	//go:linkname libc_adjtime libc_adjtime
	841	//go:cgo_import_dynamic libc_adjtime adjtime "/usr/lib/libSystem.B.dylib"
577	842
578	843	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
579	844

583	848	if err != nil {
584	849	return
585	850	}
586		_, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
587		if e1 != 0 {
588		err = errnoErr(e1)
589		}
590		return
591		}
	851	_, _, e1 := syscall_syscall(funcPC(libc_chdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	852	if e1 != 0 {
	853	err = errnoErr(e1)
	854	}
	855	return
	856	}
	857
	858	func libc_chdir_trampoline()
	859
	860	//go:linkname libc_chdir libc_chdir
	861	//go:cgo_import_dynamic libc_chdir chdir "/usr/lib/libSystem.B.dylib"
592	862
593	863	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
594	864

598	868	if err != nil {
599	869	return
600	870	}
601		_, _, e1 := Syscall(SYS_CHFLAGS, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
602		if e1 != 0 {
603		err = errnoErr(e1)
604		}
605		return
606		}
	871	_, _, e1 := syscall_syscall(funcPC(libc_chflags_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	872	if e1 != 0 {
	873	err = errnoErr(e1)
	874	}
	875	return
	876	}
	877
	878	func libc_chflags_trampoline()
	879
	880	//go:linkname libc_chflags libc_chflags
	881	//go:cgo_import_dynamic libc_chflags chflags "/usr/lib/libSystem.B.dylib"
607	882
608	883	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
609	884

613	888	if err != nil {
614	889	return
615	890	}
616		_, _, e1 := Syscall(SYS_CHMOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
617		if e1 != 0 {
618		err = errnoErr(e1)
619		}
620		return
621		}
	891	_, _, e1 := syscall_syscall(funcPC(libc_chmod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	892	if e1 != 0 {
	893	err = errnoErr(e1)
	894	}
	895	return
	896	}
	897
	898	func libc_chmod_trampoline()
	899
	900	//go:linkname libc_chmod libc_chmod
	901	//go:cgo_import_dynamic libc_chmod chmod "/usr/lib/libSystem.B.dylib"
622	902
623	903	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
624	904

628	908	if err != nil {
629	909	return
630	910	}
631		_, _, e1 := Syscall(SYS_CHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
632		if e1 != 0 {
633		err = errnoErr(e1)
634		}
635		return
636		}
	911	_, _, e1 := syscall_syscall(funcPC(libc_chown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	912	if e1 != 0 {
	913	err = errnoErr(e1)
	914	}
	915	return
	916	}
	917
	918	func libc_chown_trampoline()
	919
	920	//go:linkname libc_chown libc_chown
	921	//go:cgo_import_dynamic libc_chown chown "/usr/lib/libSystem.B.dylib"
637	922
638	923	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
639	924

643	928	if err != nil {
644	929	return
645	930	}
646		_, _, e1 := Syscall(SYS_CHROOT, uintptr(unsafe.Pointer(_p0)), 0, 0)
647		if e1 != 0 {
648		err = errnoErr(e1)
649		}
650		return
651		}
	931	_, _, e1 := syscall_syscall(funcPC(libc_chroot_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	932	if e1 != 0 {
	933	err = errnoErr(e1)
	934	}
	935	return
	936	}
	937
	938	func libc_chroot_trampoline()
	939
	940	//go:linkname libc_chroot libc_chroot
	941	//go:cgo_import_dynamic libc_chroot chroot "/usr/lib/libSystem.B.dylib"
652	942
653	943	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
654	944
655	945	func Close(fd int) (err error) {
656		_, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
657		if e1 != 0 {
658		err = errnoErr(e1)
659		}
660		return
661		}
	946	_, _, e1 := syscall_syscall(funcPC(libc_close_trampoline), uintptr(fd), 0, 0)
	947	if e1 != 0 {
	948	err = errnoErr(e1)
	949	}
	950	return
	951	}
	952
	953	func libc_close_trampoline()
	954
	955	//go:linkname libc_close libc_close
	956	//go:cgo_import_dynamic libc_close close "/usr/lib/libSystem.B.dylib"
662	957
663	958	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
664	959
665	960	func Dup(fd int) (nfd int, err error) {
666		r0, _, e1 := Syscall(SYS_DUP, uintptr(fd), 0, 0)
	961	r0, _, e1 := syscall_syscall(funcPC(libc_dup_trampoline), uintptr(fd), 0, 0)
667	962	nfd = int(r0)
668	963	if e1 != 0 {
669	964	err = errnoErr(e1)

671	966	return
672	967	}
673	968
	969	func libc_dup_trampoline()
	970
	971	//go:linkname libc_dup libc_dup
	972	//go:cgo_import_dynamic libc_dup dup "/usr/lib/libSystem.B.dylib"
	973
674	974	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
675	975
676	976	func Dup2(from int, to int) (err error) {
677		_, _, e1 := Syscall(SYS_DUP2, uintptr(from), uintptr(to), 0)
678		if e1 != 0 {
679		err = errnoErr(e1)
680		}
681		return
682		}
	977	_, _, e1 := syscall_syscall(funcPC(libc_dup2_trampoline), uintptr(from), uintptr(to), 0)
	978	if e1 != 0 {
	979	err = errnoErr(e1)
	980	}
	981	return
	982	}
	983
	984	func libc_dup2_trampoline()
	985
	986	//go:linkname libc_dup2 libc_dup2
	987	//go:cgo_import_dynamic libc_dup2 dup2 "/usr/lib/libSystem.B.dylib"
683	988
684	989	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
685	990

694	999	if err != nil {
695	1000	return
696	1001	}
697		_, _, e1 := Syscall(SYS_EXCHANGEDATA, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
698		if e1 != 0 {
699		err = errnoErr(e1)
700		}
701		return
702		}
	1002	_, _, e1 := syscall_syscall(funcPC(libc_exchangedata_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(options))
	1003	if e1 != 0 {
	1004	err = errnoErr(e1)
	1005	}
	1006	return
	1007	}
	1008
	1009	func libc_exchangedata_trampoline()
	1010
	1011	//go:linkname libc_exchangedata libc_exchangedata
	1012	//go:cgo_import_dynamic libc_exchangedata exchangedata "/usr/lib/libSystem.B.dylib"
703	1013
704	1014	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
705	1015
706	1016	func Exit(code int) {
707		Syscall(SYS_EXIT, uintptr(code), 0, 0)
708		return
709		}
	1017	syscall_syscall(funcPC(libc_exit_trampoline), uintptr(code), 0, 0)
	1018	return
	1019	}
	1020
	1021	func libc_exit_trampoline()
	1022
	1023	//go:linkname libc_exit libc_exit
	1024	//go:cgo_import_dynamic libc_exit exit "/usr/lib/libSystem.B.dylib"
710	1025
711	1026	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
712	1027

716	1031	if err != nil {
717	1032	return
718	1033	}
719		_, _, e1 := Syscall6(SYS_FACCESSAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
720		if e1 != 0 {
721		err = errnoErr(e1)
722		}
723		return
724		}
	1034	_, _, e1 := syscall_syscall6(funcPC(libc_faccessat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1035	if e1 != 0 {
	1036	err = errnoErr(e1)
	1037	}
	1038	return
	1039	}
	1040
	1041	func libc_faccessat_trampoline()
	1042
	1043	//go:linkname libc_faccessat libc_faccessat
	1044	//go:cgo_import_dynamic libc_faccessat faccessat "/usr/lib/libSystem.B.dylib"
725	1045
726	1046	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
727	1047
728	1048	func Fchdir(fd int) (err error) {
729		_, _, e1 := Syscall(SYS_FCHDIR, uintptr(fd), 0, 0)
730		if e1 != 0 {
731		err = errnoErr(e1)
732		}
733		return
734		}
	1049	_, _, e1 := syscall_syscall(funcPC(libc_fchdir_trampoline), uintptr(fd), 0, 0)
	1050	if e1 != 0 {
	1051	err = errnoErr(e1)
	1052	}
	1053	return
	1054	}
	1055
	1056	func libc_fchdir_trampoline()
	1057
	1058	//go:linkname libc_fchdir libc_fchdir
	1059	//go:cgo_import_dynamic libc_fchdir fchdir "/usr/lib/libSystem.B.dylib"
735	1060
736	1061	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
737	1062
738	1063	func Fchflags(fd int, flags int) (err error) {
739		_, _, e1 := Syscall(SYS_FCHFLAGS, uintptr(fd), uintptr(flags), 0)
740		if e1 != 0 {
741		err = errnoErr(e1)
742		}
743		return
744		}
	1064	_, _, e1 := syscall_syscall(funcPC(libc_fchflags_trampoline), uintptr(fd), uintptr(flags), 0)
	1065	if e1 != 0 {
	1066	err = errnoErr(e1)
	1067	}
	1068	return
	1069	}
	1070
	1071	func libc_fchflags_trampoline()
	1072
	1073	//go:linkname libc_fchflags libc_fchflags
	1074	//go:cgo_import_dynamic libc_fchflags fchflags "/usr/lib/libSystem.B.dylib"
745	1075
746	1076	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
747	1077
748	1078	func Fchmod(fd int, mode uint32) (err error) {
749		_, _, e1 := Syscall(SYS_FCHMOD, uintptr(fd), uintptr(mode), 0)
750		if e1 != 0 {
751		err = errnoErr(e1)
752		}
753		return
754		}
	1079	_, _, e1 := syscall_syscall(funcPC(libc_fchmod_trampoline), uintptr(fd), uintptr(mode), 0)
	1080	if e1 != 0 {
	1081	err = errnoErr(e1)
	1082	}
	1083	return
	1084	}
	1085
	1086	func libc_fchmod_trampoline()
	1087
	1088	//go:linkname libc_fchmod libc_fchmod
	1089	//go:cgo_import_dynamic libc_fchmod fchmod "/usr/lib/libSystem.B.dylib"
755	1090
756	1091	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
757	1092

761	1096	if err != nil {
762	1097	return
763	1098	}
764		_, _, e1 := Syscall6(SYS_FCHMODAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
765		if e1 != 0 {
766		err = errnoErr(e1)
767		}
768		return
769		}
	1099	_, _, e1 := syscall_syscall6(funcPC(libc_fchmodat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(flags), 0, 0)
	1100	if e1 != 0 {
	1101	err = errnoErr(e1)
	1102	}
	1103	return
	1104	}
	1105
	1106	func libc_fchmodat_trampoline()
	1107
	1108	//go:linkname libc_fchmodat libc_fchmodat
	1109	//go:cgo_import_dynamic libc_fchmodat fchmodat "/usr/lib/libSystem.B.dylib"
770	1110
771	1111	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
772	1112
773	1113	func Fchown(fd int, uid int, gid int) (err error) {
774		_, _, e1 := Syscall(SYS_FCHOWN, uintptr(fd), uintptr(uid), uintptr(gid))
775		if e1 != 0 {
776		err = errnoErr(e1)
777		}
778		return
779		}
	1114	_, _, e1 := syscall_syscall(funcPC(libc_fchown_trampoline), uintptr(fd), uintptr(uid), uintptr(gid))
	1115	if e1 != 0 {
	1116	err = errnoErr(e1)
	1117	}
	1118	return
	1119	}
	1120
	1121	func libc_fchown_trampoline()
	1122
	1123	//go:linkname libc_fchown libc_fchown
	1124	//go:cgo_import_dynamic libc_fchown fchown "/usr/lib/libSystem.B.dylib"
780	1125
781	1126	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
782	1127

786	1131	if err != nil {
787	1132	return
788	1133	}
789		_, _, e1 := Syscall6(SYS_FCHOWNAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
790		if e1 != 0 {
791		err = errnoErr(e1)
792		}
793		return
794		}
	1134	_, _, e1 := syscall_syscall6(funcPC(libc_fchownat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid), uintptr(flags), 0)
	1135	if e1 != 0 {
	1136	err = errnoErr(e1)
	1137	}
	1138	return
	1139	}
	1140
	1141	func libc_fchownat_trampoline()
	1142
	1143	//go:linkname libc_fchownat libc_fchownat
	1144	//go:cgo_import_dynamic libc_fchownat fchownat "/usr/lib/libSystem.B.dylib"
795	1145
796	1146	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
797	1147
798	1148	func Flock(fd int, how int) (err error) {
799		_, _, e1 := Syscall(SYS_FLOCK, uintptr(fd), uintptr(how), 0)
800		if e1 != 0 {
801		err = errnoErr(e1)
802		}
803		return
804		}
	1149	_, _, e1 := syscall_syscall(funcPC(libc_flock_trampoline), uintptr(fd), uintptr(how), 0)
	1150	if e1 != 0 {
	1151	err = errnoErr(e1)
	1152	}
	1153	return
	1154	}
	1155
	1156	func libc_flock_trampoline()
	1157
	1158	//go:linkname libc_flock libc_flock
	1159	//go:cgo_import_dynamic libc_flock flock "/usr/lib/libSystem.B.dylib"
805	1160
806	1161	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
807	1162
808	1163	func Fpathconf(fd int, name int) (val int, err error) {
809		r0, _, e1 := Syscall(SYS_FPATHCONF, uintptr(fd), uintptr(name), 0)
	1164	r0, _, e1 := syscall_syscall(funcPC(libc_fpathconf_trampoline), uintptr(fd), uintptr(name), 0)
810	1165	val = int(r0)
811	1166	if e1 != 0 {
812	1167	err = errnoErr(e1)

814	1169	return
815	1170	}
816	1171
817		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
818
819		func Fstat(fd int, stat *Stat_t) (err error) {
820		_, _, e1 := Syscall(SYS_FSTAT64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
821		if e1 != 0 {
822		err = errnoErr(e1)
823		}
824		return
825		}
826
827		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
828
829		func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
830		var _p0 *byte
831		_p0, err = BytePtrFromString(path)
832		if err != nil {
833		return
834		}
835		_, _, e1 := Syscall6(SYS_FSTATAT64, uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
836		if e1 != 0 {
837		err = errnoErr(e1)
838		}
839		return
840		}
841
842		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
843
844		func Fstatfs(fd int, stat *Statfs_t) (err error) {
845		_, _, e1 := Syscall(SYS_FSTATFS64, uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
846		if e1 != 0 {
847		err = errnoErr(e1)
848		}
849		return
850		}
	1172	func libc_fpathconf_trampoline()
	1173
	1174	//go:linkname libc_fpathconf libc_fpathconf
	1175	//go:cgo_import_dynamic libc_fpathconf fpathconf "/usr/lib/libSystem.B.dylib"
851	1176
852	1177	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
853	1178
854	1179	func Fsync(fd int) (err error) {
855		_, _, e1 := Syscall(SYS_FSYNC, uintptr(fd), 0, 0)
856		if e1 != 0 {
857		err = errnoErr(e1)
858		}
859		return
860		}
	1180	_, _, e1 := syscall_syscall(funcPC(libc_fsync_trampoline), uintptr(fd), 0, 0)
	1181	if e1 != 0 {
	1182	err = errnoErr(e1)
	1183	}
	1184	return
	1185	}
	1186
	1187	func libc_fsync_trampoline()
	1188
	1189	//go:linkname libc_fsync libc_fsync
	1190	//go:cgo_import_dynamic libc_fsync fsync "/usr/lib/libSystem.B.dylib"
861	1191
862	1192	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
863	1193
864	1194	func Ftruncate(fd int, length int64) (err error) {
865		_, _, e1 := Syscall(SYS_FTRUNCATE, uintptr(fd), uintptr(length), 0)
866		if e1 != 0 {
867		err = errnoErr(e1)
868		}
869		return
870		}
871
872		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
873
874		func Getdirentries(fd int, buf []byte, basep *uintptr) (n int, err error) {
875		var _p0 unsafe.Pointer
876		if len(buf) > 0 {
877		_p0 = unsafe.Pointer(&buf[0])
878		} else {
879		_p0 = unsafe.Pointer(&_zero)
880		}
881		r0, _, e1 := Syscall6(SYS_GETDIRENTRIES64, uintptr(fd), uintptr(_p0), uintptr(len(buf)), uintptr(unsafe.Pointer(basep)), 0, 0)
882		n = int(r0)
883		if e1 != 0 {
884		err = errnoErr(e1)
885		}
886		return
887		}
	1195	_, _, e1 := syscall_syscall(funcPC(libc_ftruncate_trampoline), uintptr(fd), uintptr(length), 0)
	1196	if e1 != 0 {
	1197	err = errnoErr(e1)
	1198	}
	1199	return
	1200	}
	1201
	1202	func libc_ftruncate_trampoline()
	1203
	1204	//go:linkname libc_ftruncate libc_ftruncate
	1205	//go:cgo_import_dynamic libc_ftruncate ftruncate "/usr/lib/libSystem.B.dylib"
888	1206
889	1207	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
890	1208
891	1209	func Getdtablesize() (size int) {
892		r0, _, _ := Syscall(SYS_GETDTABLESIZE, 0, 0, 0)
	1210	r0, _, _ := syscall_syscall(funcPC(libc_getdtablesize_trampoline), 0, 0, 0)
893	1211	size = int(r0)
894	1212	return
895	1213	}
896	1214
	1215	func libc_getdtablesize_trampoline()
	1216
	1217	//go:linkname libc_getdtablesize libc_getdtablesize
	1218	//go:cgo_import_dynamic libc_getdtablesize getdtablesize "/usr/lib/libSystem.B.dylib"
	1219
897	1220	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
898	1221
899	1222	func Getegid() (egid int) {
900		r0, _, _ := RawSyscall(SYS_GETEGID, 0, 0, 0)
	1223	r0, _, _ := syscall_rawSyscall(funcPC(libc_getegid_trampoline), 0, 0, 0)
901	1224	egid = int(r0)
902	1225	return
903	1226	}
904	1227
	1228	func libc_getegid_trampoline()
	1229
	1230	//go:linkname libc_getegid libc_getegid
	1231	//go:cgo_import_dynamic libc_getegid getegid "/usr/lib/libSystem.B.dylib"
	1232
905	1233	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
906	1234
907	1235	func Geteuid() (uid int) {
908		r0, _, _ := RawSyscall(SYS_GETEUID, 0, 0, 0)
	1236	r0, _, _ := syscall_rawSyscall(funcPC(libc_geteuid_trampoline), 0, 0, 0)
909	1237	uid = int(r0)
910	1238	return
911	1239	}
912	1240
	1241	func libc_geteuid_trampoline()
	1242
	1243	//go:linkname libc_geteuid libc_geteuid
	1244	//go:cgo_import_dynamic libc_geteuid geteuid "/usr/lib/libSystem.B.dylib"
	1245
913	1246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
914	1247
915	1248	func Getgid() (gid int) {
916		r0, _, _ := RawSyscall(SYS_GETGID, 0, 0, 0)
	1249	r0, _, _ := syscall_rawSyscall(funcPC(libc_getgid_trampoline), 0, 0, 0)
917	1250	gid = int(r0)
918	1251	return
919	1252	}
920	1253
	1254	func libc_getgid_trampoline()
	1255
	1256	//go:linkname libc_getgid libc_getgid
	1257	//go:cgo_import_dynamic libc_getgid getgid "/usr/lib/libSystem.B.dylib"
	1258
921	1259	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
922	1260
923	1261	func Getpgid(pid int) (pgid int, err error) {
924		r0, _, e1 := RawSyscall(SYS_GETPGID, uintptr(pid), 0, 0)
	1262	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getpgid_trampoline), uintptr(pid), 0, 0)
925	1263	pgid = int(r0)
926	1264	if e1 != 0 {
927	1265	err = errnoErr(e1)

929	1267	return
930	1268	}
931	1269
	1270	func libc_getpgid_trampoline()
	1271
	1272	//go:linkname libc_getpgid libc_getpgid
	1273	//go:cgo_import_dynamic libc_getpgid getpgid "/usr/lib/libSystem.B.dylib"
	1274
932	1275	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
933	1276
934	1277	func Getpgrp() (pgrp int) {
935		r0, _, _ := RawSyscall(SYS_GETPGRP, 0, 0, 0)
	1278	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpgrp_trampoline), 0, 0, 0)
936	1279	pgrp = int(r0)
937	1280	return
938	1281	}
939	1282
	1283	func libc_getpgrp_trampoline()
	1284
	1285	//go:linkname libc_getpgrp libc_getpgrp
	1286	//go:cgo_import_dynamic libc_getpgrp getpgrp "/usr/lib/libSystem.B.dylib"
	1287
940	1288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
941	1289
942	1290	func Getpid() (pid int) {
943		r0, _, _ := RawSyscall(SYS_GETPID, 0, 0, 0)
	1291	r0, _, _ := syscall_rawSyscall(funcPC(libc_getpid_trampoline), 0, 0, 0)
944	1292	pid = int(r0)
945	1293	return
946	1294	}
947	1295
	1296	func libc_getpid_trampoline()
	1297
	1298	//go:linkname libc_getpid libc_getpid
	1299	//go:cgo_import_dynamic libc_getpid getpid "/usr/lib/libSystem.B.dylib"
	1300
948	1301	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
949	1302
950	1303	func Getppid() (ppid int) {
951		r0, _, _ := RawSyscall(SYS_GETPPID, 0, 0, 0)
	1304	r0, _, _ := syscall_rawSyscall(funcPC(libc_getppid_trampoline), 0, 0, 0)
952	1305	ppid = int(r0)
953	1306	return
954	1307	}
955	1308
	1309	func libc_getppid_trampoline()
	1310
	1311	//go:linkname libc_getppid libc_getppid
	1312	//go:cgo_import_dynamic libc_getppid getppid "/usr/lib/libSystem.B.dylib"
	1313
956	1314	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
957	1315
958	1316	func Getpriority(which int, who int) (prio int, err error) {
959		r0, _, e1 := Syscall(SYS_GETPRIORITY, uintptr(which), uintptr(who), 0)
	1317	r0, _, e1 := syscall_syscall(funcPC(libc_getpriority_trampoline), uintptr(which), uintptr(who), 0)
960	1318	prio = int(r0)
961	1319	if e1 != 0 {
962	1320	err = errnoErr(e1)

964	1322	return
965	1323	}
966	1324
	1325	func libc_getpriority_trampoline()
	1326
	1327	//go:linkname libc_getpriority libc_getpriority
	1328	//go:cgo_import_dynamic libc_getpriority getpriority "/usr/lib/libSystem.B.dylib"
	1329
967	1330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
968	1331
969	1332	func Getrlimit(which int, lim *Rlimit) (err error) {
970		_, _, e1 := RawSyscall(SYS_GETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
971		if e1 != 0 {
972		err = errnoErr(e1)
973		}
974		return
975		}
	1333	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	1334	if e1 != 0 {
	1335	err = errnoErr(e1)
	1336	}
	1337	return
	1338	}
	1339
	1340	func libc_getrlimit_trampoline()
	1341
	1342	//go:linkname libc_getrlimit libc_getrlimit
	1343	//go:cgo_import_dynamic libc_getrlimit getrlimit "/usr/lib/libSystem.B.dylib"
976	1344
977	1345	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
978	1346
979	1347	func Getrusage(who int, rusage *Rusage) (err error) {
980		_, _, e1 := RawSyscall(SYS_GETRUSAGE, uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
981		if e1 != 0 {
982		err = errnoErr(e1)
983		}
984		return
985		}
	1348	_, _, e1 := syscall_rawSyscall(funcPC(libc_getrusage_trampoline), uintptr(who), uintptr(unsafe.Pointer(rusage)), 0)
	1349	if e1 != 0 {
	1350	err = errnoErr(e1)
	1351	}
	1352	return
	1353	}
	1354
	1355	func libc_getrusage_trampoline()
	1356
	1357	//go:linkname libc_getrusage libc_getrusage
	1358	//go:cgo_import_dynamic libc_getrusage getrusage "/usr/lib/libSystem.B.dylib"
986	1359
987	1360	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
988	1361
989	1362	func Getsid(pid int) (sid int, err error) {
990		r0, _, e1 := RawSyscall(SYS_GETSID, uintptr(pid), 0, 0)
	1363	r0, _, e1 := syscall_rawSyscall(funcPC(libc_getsid_trampoline), uintptr(pid), 0, 0)
991	1364	sid = int(r0)
992	1365	if e1 != 0 {
993	1366	err = errnoErr(e1)

995	1368	return
996	1369	}
997	1370
	1371	func libc_getsid_trampoline()
	1372
	1373	//go:linkname libc_getsid libc_getsid
	1374	//go:cgo_import_dynamic libc_getsid getsid "/usr/lib/libSystem.B.dylib"
	1375
998	1376	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
999	1377
1000	1378	func Getuid() (uid int) {
1001		r0, _, _ := RawSyscall(SYS_GETUID, 0, 0, 0)
	1379	r0, _, _ := syscall_rawSyscall(funcPC(libc_getuid_trampoline), 0, 0, 0)
1002	1380	uid = int(r0)
1003	1381	return
1004	1382	}
1005	1383
	1384	func libc_getuid_trampoline()
	1385
	1386	//go:linkname libc_getuid libc_getuid
	1387	//go:cgo_import_dynamic libc_getuid getuid "/usr/lib/libSystem.B.dylib"
	1388
1006	1389	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1007	1390
1008	1391	func Issetugid() (tainted bool) {
1009		r0, _, _ := RawSyscall(SYS_ISSETUGID, 0, 0, 0)
	1392	r0, _, _ := syscall_rawSyscall(funcPC(libc_issetugid_trampoline), 0, 0, 0)
1010	1393	tainted = bool(r0 != 0)
1011	1394	return
1012	1395	}
1013	1396
	1397	func libc_issetugid_trampoline()
	1398
	1399	//go:linkname libc_issetugid libc_issetugid
	1400	//go:cgo_import_dynamic libc_issetugid issetugid "/usr/lib/libSystem.B.dylib"
	1401
1014	1402	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1015	1403
1016	1404	func Kqueue() (fd int, err error) {
1017		r0, _, e1 := Syscall(SYS_KQUEUE, 0, 0, 0)
	1405	r0, _, e1 := syscall_syscall(funcPC(libc_kqueue_trampoline), 0, 0, 0)
1018	1406	fd = int(r0)
1019	1407	if e1 != 0 {
1020	1408	err = errnoErr(e1)

1022	1410	return
1023	1411	}
1024	1412
	1413	func libc_kqueue_trampoline()
	1414
	1415	//go:linkname libc_kqueue libc_kqueue
	1416	//go:cgo_import_dynamic libc_kqueue kqueue "/usr/lib/libSystem.B.dylib"
	1417
1025	1418	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1026	1419
1027	1420	func Lchown(path string, uid int, gid int) (err error) {

1030	1423	if err != nil {
1031	1424	return
1032	1425	}
1033		_, _, e1 := Syscall(SYS_LCHOWN, uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
1034		if e1 != 0 {
1035		err = errnoErr(e1)
1036		}
1037		return
1038		}
	1426	_, _, e1 := syscall_syscall(funcPC(libc_lchown_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(uid), uintptr(gid))
	1427	if e1 != 0 {
	1428	err = errnoErr(e1)
	1429	}
	1430	return
	1431	}
	1432
	1433	func libc_lchown_trampoline()
	1434
	1435	//go:linkname libc_lchown libc_lchown
	1436	//go:cgo_import_dynamic libc_lchown lchown "/usr/lib/libSystem.B.dylib"
1039	1437
1040	1438	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1041	1439

1050	1448	if err != nil {
1051	1449	return
1052	1450	}
1053		_, _, e1 := Syscall(SYS_LINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1054		if e1 != 0 {
1055		err = errnoErr(e1)
1056		}
1057		return
1058		}
	1451	_, _, e1 := syscall_syscall(funcPC(libc_link_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1452	if e1 != 0 {
	1453	err = errnoErr(e1)
	1454	}
	1455	return
	1456	}
	1457
	1458	func libc_link_trampoline()
	1459
	1460	//go:linkname libc_link libc_link
	1461	//go:cgo_import_dynamic libc_link link "/usr/lib/libSystem.B.dylib"
1059	1462
1060	1463	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1061	1464

1070	1473	if err != nil {
1071	1474	return
1072	1475	}
1073		_, _, e1 := Syscall6(SYS_LINKAT, uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
1074		if e1 != 0 {
1075		err = errnoErr(e1)
1076		}
1077		return
1078		}
	1476	_, _, e1 := syscall_syscall6(funcPC(libc_linkat_trampoline), uintptr(pathfd), uintptr(unsafe.Pointer(_p0)), uintptr(linkfd), uintptr(unsafe.Pointer(_p1)), uintptr(flags), 0)
	1477	if e1 != 0 {
	1478	err = errnoErr(e1)
	1479	}
	1480	return
	1481	}
	1482
	1483	func libc_linkat_trampoline()
	1484
	1485	//go:linkname libc_linkat libc_linkat
	1486	//go:cgo_import_dynamic libc_linkat linkat "/usr/lib/libSystem.B.dylib"
1079	1487
1080	1488	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1081	1489
1082	1490	func Listen(s int, backlog int) (err error) {
1083		_, _, e1 := Syscall(SYS_LISTEN, uintptr(s), uintptr(backlog), 0)
1084		if e1 != 0 {
1085		err = errnoErr(e1)
1086		}
1087		return
1088		}
1089
1090		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1091
1092		func Lstat(path string, stat *Stat_t) (err error) {
1093		var _p0 *byte
1094		_p0, err = BytePtrFromString(path)
1095		if err != nil {
1096		return
1097		}
1098		_, _, e1 := Syscall(SYS_LSTAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1099		if e1 != 0 {
1100		err = errnoErr(e1)
1101		}
1102		return
1103		}
	1491	_, _, e1 := syscall_syscall(funcPC(libc_listen_trampoline), uintptr(s), uintptr(backlog), 0)
	1492	if e1 != 0 {
	1493	err = errnoErr(e1)
	1494	}
	1495	return
	1496	}
	1497
	1498	func libc_listen_trampoline()
	1499
	1500	//go:linkname libc_listen libc_listen
	1501	//go:cgo_import_dynamic libc_listen listen "/usr/lib/libSystem.B.dylib"
1104	1502
1105	1503	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1106	1504

1110	1508	if err != nil {
1111	1509	return
1112	1510	}
1113		_, _, e1 := Syscall(SYS_MKDIR, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1114		if e1 != 0 {
1115		err = errnoErr(e1)
1116		}
1117		return
1118		}
	1511	_, _, e1 := syscall_syscall(funcPC(libc_mkdir_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1512	if e1 != 0 {
	1513	err = errnoErr(e1)
	1514	}
	1515	return
	1516	}
	1517
	1518	func libc_mkdir_trampoline()
	1519
	1520	//go:linkname libc_mkdir libc_mkdir
	1521	//go:cgo_import_dynamic libc_mkdir mkdir "/usr/lib/libSystem.B.dylib"
1119	1522
1120	1523	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1121	1524

1125	1528	if err != nil {
1126	1529	return
1127	1530	}
1128		_, _, e1 := Syscall(SYS_MKDIRAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
1129		if e1 != 0 {
1130		err = errnoErr(e1)
1131		}
1132		return
1133		}
	1531	_, _, e1 := syscall_syscall(funcPC(libc_mkdirat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode))
	1532	if e1 != 0 {
	1533	err = errnoErr(e1)
	1534	}
	1535	return
	1536	}
	1537
	1538	func libc_mkdirat_trampoline()
	1539
	1540	//go:linkname libc_mkdirat libc_mkdirat
	1541	//go:cgo_import_dynamic libc_mkdirat mkdirat "/usr/lib/libSystem.B.dylib"
1134	1542
1135	1543	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1136	1544

1140	1548	if err != nil {
1141	1549	return
1142	1550	}
1143		_, _, e1 := Syscall(SYS_MKFIFO, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
1144		if e1 != 0 {
1145		err = errnoErr(e1)
1146		}
1147		return
1148		}
	1551	_, _, e1 := syscall_syscall(funcPC(libc_mkfifo_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
	1552	if e1 != 0 {
	1553	err = errnoErr(e1)
	1554	}
	1555	return
	1556	}
	1557
	1558	func libc_mkfifo_trampoline()
	1559
	1560	//go:linkname libc_mkfifo libc_mkfifo
	1561	//go:cgo_import_dynamic libc_mkfifo mkfifo "/usr/lib/libSystem.B.dylib"
1149	1562
1150	1563	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1151	1564

1155	1568	if err != nil {
1156	1569	return
1157	1570	}
1158		_, _, e1 := Syscall(SYS_MKNOD, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
1159		if e1 != 0 {
1160		err = errnoErr(e1)
1161		}
1162		return
1163		}
	1571	_, _, e1 := syscall_syscall(funcPC(libc_mknod_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(dev))
	1572	if e1 != 0 {
	1573	err = errnoErr(e1)
	1574	}
	1575	return
	1576	}
	1577
	1578	func libc_mknod_trampoline()
	1579
	1580	//go:linkname libc_mknod libc_mknod
	1581	//go:cgo_import_dynamic libc_mknod mknod "/usr/lib/libSystem.B.dylib"
1164	1582
1165	1583	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1166	1584

1170	1588	if err != nil {
1171	1589	return
1172	1590	}
1173		r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
	1591	r0, _, e1 := syscall_syscall(funcPC(libc_open_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
1174	1592	fd = int(r0)
1175	1593	if e1 != 0 {
1176	1594	err = errnoErr(e1)

1178	1596	return
1179	1597	}
1180	1598
	1599	func libc_open_trampoline()
	1600
	1601	//go:linkname libc_open libc_open
	1602	//go:cgo_import_dynamic libc_open open "/usr/lib/libSystem.B.dylib"
	1603
1181	1604	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1182	1605
1183	1606	func Openat(dirfd int, path string, mode int, perm uint32) (fd int, err error) {

1186	1609	if err != nil {
1187	1610	return
1188	1611	}
1189		r0, _, e1 := Syscall6(SYS_OPENAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
	1612	r0, _, e1 := syscall_syscall6(funcPC(libc_openat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm), 0, 0)
1190	1613	fd = int(r0)
1191	1614	if e1 != 0 {
1192	1615	err = errnoErr(e1)

1194	1617	return
1195	1618	}
1196	1619
	1620	func libc_openat_trampoline()
	1621
	1622	//go:linkname libc_openat libc_openat
	1623	//go:cgo_import_dynamic libc_openat openat "/usr/lib/libSystem.B.dylib"
	1624
1197	1625	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1198	1626
1199	1627	func Pathconf(path string, name int) (val int, err error) {

1202	1630	if err != nil {
1203	1631	return
1204	1632	}
1205		r0, _, e1 := Syscall(SYS_PATHCONF, uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
	1633	r0, _, e1 := syscall_syscall(funcPC(libc_pathconf_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(name), 0)
1206	1634	val = int(r0)
1207	1635	if e1 != 0 {
1208	1636	err = errnoErr(e1)
1209	1637	}
1210	1638	return
1211	1639	}
	1640
	1641	func libc_pathconf_trampoline()
	1642
	1643	//go:linkname libc_pathconf libc_pathconf
	1644	//go:cgo_import_dynamic libc_pathconf pathconf "/usr/lib/libSystem.B.dylib"
1212	1645
1213	1646	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1214	1647

1219	1652	} else {
1220	1653	_p0 = unsafe.Pointer(&_zero)
1221	1654	}
1222		r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1655	r0, _, e1 := syscall_syscall6(funcPC(libc_pread_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1223	1656	n = int(r0)
1224	1657	if e1 != 0 {
1225	1658	err = errnoErr(e1)
1226	1659	}
1227	1660	return
1228	1661	}
	1662
	1663	func libc_pread_trampoline()
	1664
	1665	//go:linkname libc_pread libc_pread
	1666	//go:cgo_import_dynamic libc_pread pread "/usr/lib/libSystem.B.dylib"
1229	1667
1230	1668	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1231	1669

1236	1674	} else {
1237	1675	_p0 = unsafe.Pointer(&_zero)
1238	1676	}
1239		r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
	1677	r0, _, e1 := syscall_syscall6(funcPC(libc_pwrite_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), 0, 0)
1240	1678	n = int(r0)
1241	1679	if e1 != 0 {
1242	1680	err = errnoErr(e1)
1243	1681	}
1244	1682	return
1245	1683	}
	1684
	1685	func libc_pwrite_trampoline()
	1686
	1687	//go:linkname libc_pwrite libc_pwrite
	1688	//go:cgo_import_dynamic libc_pwrite pwrite "/usr/lib/libSystem.B.dylib"
1246	1689
1247	1690	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1248	1691

1253	1696	} else {
1254	1697	_p0 = unsafe.Pointer(&_zero)
1255	1698	}
1256		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	1699	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1257	1700	n = int(r0)
1258	1701	if e1 != 0 {
1259	1702	err = errnoErr(e1)
1260	1703	}
1261	1704	return
1262	1705	}
	1706
	1707	func libc_read_trampoline()
	1708
	1709	//go:linkname libc_read libc_read
	1710	//go:cgo_import_dynamic libc_read read "/usr/lib/libSystem.B.dylib"
1263	1711
1264	1712	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1265	1713

1275	1723	} else {
1276	1724	_p1 = unsafe.Pointer(&_zero)
1277	1725	}
1278		r0, _, e1 := Syscall(SYS_READLINK, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
	1726	r0, _, e1 := syscall_syscall(funcPC(libc_readlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)))
1279	1727	n = int(r0)
1280	1728	if e1 != 0 {
1281	1729	err = errnoErr(e1)
1282	1730	}
1283	1731	return
1284	1732	}
	1733
	1734	func libc_readlink_trampoline()
	1735
	1736	//go:linkname libc_readlink libc_readlink
	1737	//go:cgo_import_dynamic libc_readlink readlink "/usr/lib/libSystem.B.dylib"
1285	1738
1286	1739	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1287	1740

1297	1750	} else {
1298	1751	_p1 = unsafe.Pointer(&_zero)
1299	1752	}
1300		r0, _, e1 := Syscall6(SYS_READLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
	1753	r0, _, e1 := syscall_syscall6(funcPC(libc_readlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(buf)), 0, 0)
1301	1754	n = int(r0)
1302	1755	if e1 != 0 {
1303	1756	err = errnoErr(e1)
1304	1757	}
1305	1758	return
1306	1759	}
	1760
	1761	func libc_readlinkat_trampoline()
	1762
	1763	//go:linkname libc_readlinkat libc_readlinkat
	1764	//go:cgo_import_dynamic libc_readlinkat readlinkat "/usr/lib/libSystem.B.dylib"
1307	1765
1308	1766	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1309	1767

1318	1776	if err != nil {
1319	1777	return
1320	1778	}
1321		_, _, e1 := Syscall(SYS_RENAME, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1322		if e1 != 0 {
1323		err = errnoErr(e1)
1324		}
1325		return
1326		}
	1779	_, _, e1 := syscall_syscall(funcPC(libc_rename_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	1780	if e1 != 0 {
	1781	err = errnoErr(e1)
	1782	}
	1783	return
	1784	}
	1785
	1786	func libc_rename_trampoline()
	1787
	1788	//go:linkname libc_rename libc_rename
	1789	//go:cgo_import_dynamic libc_rename rename "/usr/lib/libSystem.B.dylib"
1327	1790
1328	1791	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1329	1792

1338	1801	if err != nil {
1339	1802	return
1340	1803	}
1341		_, _, e1 := Syscall6(SYS_RENAMEAT, uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
1342		if e1 != 0 {
1343		err = errnoErr(e1)
1344		}
1345		return
1346		}
	1804	_, _, e1 := syscall_syscall6(funcPC(libc_renameat_trampoline), uintptr(fromfd), uintptr(unsafe.Pointer(_p0)), uintptr(tofd), uintptr(unsafe.Pointer(_p1)), 0, 0)
	1805	if e1 != 0 {
	1806	err = errnoErr(e1)
	1807	}
	1808	return
	1809	}
	1810
	1811	func libc_renameat_trampoline()
	1812
	1813	//go:linkname libc_renameat libc_renameat
	1814	//go:cgo_import_dynamic libc_renameat renameat "/usr/lib/libSystem.B.dylib"
1347	1815
1348	1816	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1349	1817

1353	1821	if err != nil {
1354	1822	return
1355	1823	}
1356		_, _, e1 := Syscall(SYS_REVOKE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1357		if e1 != 0 {
1358		err = errnoErr(e1)
1359		}
1360		return
1361		}
	1824	_, _, e1 := syscall_syscall(funcPC(libc_revoke_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1825	if e1 != 0 {
	1826	err = errnoErr(e1)
	1827	}
	1828	return
	1829	}
	1830
	1831	func libc_revoke_trampoline()
	1832
	1833	//go:linkname libc_revoke libc_revoke
	1834	//go:cgo_import_dynamic libc_revoke revoke "/usr/lib/libSystem.B.dylib"
1362	1835
1363	1836	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1364	1837

1368	1841	if err != nil {
1369	1842	return
1370	1843	}
1371		_, _, e1 := Syscall(SYS_RMDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
1372		if e1 != 0 {
1373		err = errnoErr(e1)
1374		}
1375		return
1376		}
	1844	_, _, e1 := syscall_syscall(funcPC(libc_rmdir_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1845	if e1 != 0 {
	1846	err = errnoErr(e1)
	1847	}
	1848	return
	1849	}
	1850
	1851	func libc_rmdir_trampoline()
	1852
	1853	//go:linkname libc_rmdir libc_rmdir
	1854	//go:cgo_import_dynamic libc_rmdir rmdir "/usr/lib/libSystem.B.dylib"
1377	1855
1378	1856	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1379	1857
1380	1858	func Seek(fd int, offset int64, whence int) (newoffset int64, err error) {
1381		r0, _, e1 := Syscall(SYS_LSEEK, uintptr(fd), uintptr(offset), uintptr(whence))
	1859	r0, _, e1 := syscall_syscall(funcPC(libc_lseek_trampoline), uintptr(fd), uintptr(offset), uintptr(whence))
1382	1860	newoffset = int64(r0)
1383	1861	if e1 != 0 {
1384	1862	err = errnoErr(e1)

1386	1864	return
1387	1865	}
1388	1866
	1867	func libc_lseek_trampoline()
	1868
	1869	//go:linkname libc_lseek libc_lseek
	1870	//go:cgo_import_dynamic libc_lseek lseek "/usr/lib/libSystem.B.dylib"
	1871
1389	1872	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1390	1873
1391	1874	func Select(n int, r FdSet, w FdSet, e FdSet, timeout Timeval) (err error) {
1392		_, _, e1 := Syscall6(SYS_SELECT, uintptr(n), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0)
1393		if e1 != 0 {
1394		err = errnoErr(e1)
1395		}
1396		return
1397		}
	1875	_, _, 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)
	1876	if e1 != 0 {
	1877	err = errnoErr(e1)
	1878	}
	1879	return
	1880	}
	1881
	1882	func libc_select_trampoline()
	1883
	1884	//go:linkname libc_select libc_select
	1885	//go:cgo_import_dynamic libc_select select "/usr/lib/libSystem.B.dylib"
1398	1886
1399	1887	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1400	1888
1401	1889	func Setegid(egid int) (err error) {
1402		_, _, e1 := Syscall(SYS_SETEGID, uintptr(egid), 0, 0)
1403		if e1 != 0 {
1404		err = errnoErr(e1)
1405		}
1406		return
1407		}
	1890	_, _, e1 := syscall_syscall(funcPC(libc_setegid_trampoline), uintptr(egid), 0, 0)
	1891	if e1 != 0 {
	1892	err = errnoErr(e1)
	1893	}
	1894	return
	1895	}
	1896
	1897	func libc_setegid_trampoline()
	1898
	1899	//go:linkname libc_setegid libc_setegid
	1900	//go:cgo_import_dynamic libc_setegid setegid "/usr/lib/libSystem.B.dylib"
1408	1901
1409	1902	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1410	1903
1411	1904	func Seteuid(euid int) (err error) {
1412		_, _, e1 := RawSyscall(SYS_SETEUID, uintptr(euid), 0, 0)
1413		if e1 != 0 {
1414		err = errnoErr(e1)
1415		}
1416		return
1417		}
	1905	_, _, e1 := syscall_rawSyscall(funcPC(libc_seteuid_trampoline), uintptr(euid), 0, 0)
	1906	if e1 != 0 {
	1907	err = errnoErr(e1)
	1908	}
	1909	return
	1910	}
	1911
	1912	func libc_seteuid_trampoline()
	1913
	1914	//go:linkname libc_seteuid libc_seteuid
	1915	//go:cgo_import_dynamic libc_seteuid seteuid "/usr/lib/libSystem.B.dylib"
1418	1916
1419	1917	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1420	1918
1421	1919	func Setgid(gid int) (err error) {
1422		_, _, e1 := RawSyscall(SYS_SETGID, uintptr(gid), 0, 0)
1423		if e1 != 0 {
1424		err = errnoErr(e1)
1425		}
1426		return
1427		}
	1920	_, _, e1 := syscall_rawSyscall(funcPC(libc_setgid_trampoline), uintptr(gid), 0, 0)
	1921	if e1 != 0 {
	1922	err = errnoErr(e1)
	1923	}
	1924	return
	1925	}
	1926
	1927	func libc_setgid_trampoline()
	1928
	1929	//go:linkname libc_setgid libc_setgid
	1930	//go:cgo_import_dynamic libc_setgid setgid "/usr/lib/libSystem.B.dylib"
1428	1931
1429	1932	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1430	1933

1434	1937	if err != nil {
1435	1938	return
1436	1939	}
1437		_, _, e1 := Syscall(SYS_SETLOGIN, uintptr(unsafe.Pointer(_p0)), 0, 0)
1438		if e1 != 0 {
1439		err = errnoErr(e1)
1440		}
1441		return
1442		}
	1940	_, _, e1 := syscall_syscall(funcPC(libc_setlogin_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	1941	if e1 != 0 {
	1942	err = errnoErr(e1)
	1943	}
	1944	return
	1945	}
	1946
	1947	func libc_setlogin_trampoline()
	1948
	1949	//go:linkname libc_setlogin libc_setlogin
	1950	//go:cgo_import_dynamic libc_setlogin setlogin "/usr/lib/libSystem.B.dylib"
1443	1951
1444	1952	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1445	1953
1446	1954	func Setpgid(pid int, pgid int) (err error) {
1447		_, _, e1 := RawSyscall(SYS_SETPGID, uintptr(pid), uintptr(pgid), 0)
1448		if e1 != 0 {
1449		err = errnoErr(e1)
1450		}
1451		return
1452		}
	1955	_, _, e1 := syscall_rawSyscall(funcPC(libc_setpgid_trampoline), uintptr(pid), uintptr(pgid), 0)
	1956	if e1 != 0 {
	1957	err = errnoErr(e1)
	1958	}
	1959	return
	1960	}
	1961
	1962	func libc_setpgid_trampoline()
	1963
	1964	//go:linkname libc_setpgid libc_setpgid
	1965	//go:cgo_import_dynamic libc_setpgid setpgid "/usr/lib/libSystem.B.dylib"
1453	1966
1454	1967	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1455	1968
1456	1969	func Setpriority(which int, who int, prio int) (err error) {
1457		_, _, e1 := Syscall(SYS_SETPRIORITY, uintptr(which), uintptr(who), uintptr(prio))
1458		if e1 != 0 {
1459		err = errnoErr(e1)
1460		}
1461		return
1462		}
	1970	_, _, e1 := syscall_syscall(funcPC(libc_setpriority_trampoline), uintptr(which), uintptr(who), uintptr(prio))
	1971	if e1 != 0 {
	1972	err = errnoErr(e1)
	1973	}
	1974	return
	1975	}
	1976
	1977	func libc_setpriority_trampoline()
	1978
	1979	//go:linkname libc_setpriority libc_setpriority
	1980	//go:cgo_import_dynamic libc_setpriority setpriority "/usr/lib/libSystem.B.dylib"
1463	1981
1464	1982	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1465	1983
1466	1984	func Setprivexec(flag int) (err error) {
1467		_, _, e1 := Syscall(SYS_SETPRIVEXEC, uintptr(flag), 0, 0)
1468		if e1 != 0 {
1469		err = errnoErr(e1)
1470		}
1471		return
1472		}
	1985	_, _, e1 := syscall_syscall(funcPC(libc_setprivexec_trampoline), uintptr(flag), 0, 0)
	1986	if e1 != 0 {
	1987	err = errnoErr(e1)
	1988	}
	1989	return
	1990	}
	1991
	1992	func libc_setprivexec_trampoline()
	1993
	1994	//go:linkname libc_setprivexec libc_setprivexec
	1995	//go:cgo_import_dynamic libc_setprivexec setprivexec "/usr/lib/libSystem.B.dylib"
1473	1996
1474	1997	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1475	1998
1476	1999	func Setregid(rgid int, egid int) (err error) {
1477		_, _, e1 := RawSyscall(SYS_SETREGID, uintptr(rgid), uintptr(egid), 0)
1478		if e1 != 0 {
1479		err = errnoErr(e1)
1480		}
1481		return
1482		}
	2000	_, _, e1 := syscall_rawSyscall(funcPC(libc_setregid_trampoline), uintptr(rgid), uintptr(egid), 0)
	2001	if e1 != 0 {
	2002	err = errnoErr(e1)
	2003	}
	2004	return
	2005	}
	2006
	2007	func libc_setregid_trampoline()
	2008
	2009	//go:linkname libc_setregid libc_setregid
	2010	//go:cgo_import_dynamic libc_setregid setregid "/usr/lib/libSystem.B.dylib"
1483	2011
1484	2012	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1485	2013
1486	2014	func Setreuid(ruid int, euid int) (err error) {
1487		_, _, e1 := RawSyscall(SYS_SETREUID, uintptr(ruid), uintptr(euid), 0)
1488		if e1 != 0 {
1489		err = errnoErr(e1)
1490		}
1491		return
1492		}
	2015	_, _, e1 := syscall_rawSyscall(funcPC(libc_setreuid_trampoline), uintptr(ruid), uintptr(euid), 0)
	2016	if e1 != 0 {
	2017	err = errnoErr(e1)
	2018	}
	2019	return
	2020	}
	2021
	2022	func libc_setreuid_trampoline()
	2023
	2024	//go:linkname libc_setreuid libc_setreuid
	2025	//go:cgo_import_dynamic libc_setreuid setreuid "/usr/lib/libSystem.B.dylib"
1493	2026
1494	2027	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1495	2028
1496	2029	func Setrlimit(which int, lim *Rlimit) (err error) {
1497		_, _, e1 := RawSyscall(SYS_SETRLIMIT, uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
1498		if e1 != 0 {
1499		err = errnoErr(e1)
1500		}
1501		return
1502		}
	2030	_, _, e1 := syscall_rawSyscall(funcPC(libc_setrlimit_trampoline), uintptr(which), uintptr(unsafe.Pointer(lim)), 0)
	2031	if e1 != 0 {
	2032	err = errnoErr(e1)
	2033	}
	2034	return
	2035	}
	2036
	2037	func libc_setrlimit_trampoline()
	2038
	2039	//go:linkname libc_setrlimit libc_setrlimit
	2040	//go:cgo_import_dynamic libc_setrlimit setrlimit "/usr/lib/libSystem.B.dylib"
1503	2041
1504	2042	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1505	2043
1506	2044	func Setsid() (pid int, err error) {
1507		r0, _, e1 := RawSyscall(SYS_SETSID, 0, 0, 0)
	2045	r0, _, e1 := syscall_rawSyscall(funcPC(libc_setsid_trampoline), 0, 0, 0)
1508	2046	pid = int(r0)
1509	2047	if e1 != 0 {
1510	2048	err = errnoErr(e1)

1512	2050	return
1513	2051	}
1514	2052
	2053	func libc_setsid_trampoline()
	2054
	2055	//go:linkname libc_setsid libc_setsid
	2056	//go:cgo_import_dynamic libc_setsid setsid "/usr/lib/libSystem.B.dylib"
	2057
1515	2058	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1516	2059
1517	2060	func Settimeofday(tp *Timeval) (err error) {
1518		_, _, e1 := RawSyscall(SYS_SETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
1519		if e1 != 0 {
1520		err = errnoErr(e1)
1521		}
1522		return
1523		}
	2061	_, _, e1 := syscall_rawSyscall(funcPC(libc_settimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
	2062	if e1 != 0 {
	2063	err = errnoErr(e1)
	2064	}
	2065	return
	2066	}
	2067
	2068	func libc_settimeofday_trampoline()
	2069
	2070	//go:linkname libc_settimeofday libc_settimeofday
	2071	//go:cgo_import_dynamic libc_settimeofday settimeofday "/usr/lib/libSystem.B.dylib"
1524	2072
1525	2073	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1526	2074
1527	2075	func Setuid(uid int) (err error) {
1528		_, _, e1 := RawSyscall(SYS_SETUID, uintptr(uid), 0, 0)
1529		if e1 != 0 {
1530		err = errnoErr(e1)
1531		}
1532		return
1533		}
1534
1535		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1536
1537		func Stat(path string, stat *Stat_t) (err error) {
1538		var _p0 *byte
1539		_p0, err = BytePtrFromString(path)
1540		if err != nil {
1541		return
1542		}
1543		_, _, e1 := Syscall(SYS_STAT64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1544		if e1 != 0 {
1545		err = errnoErr(e1)
1546		}
1547		return
1548		}
1549
1550		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1551
1552		func Statfs(path string, stat *Statfs_t) (err error) {
1553		var _p0 *byte
1554		_p0, err = BytePtrFromString(path)
1555		if err != nil {
1556		return
1557		}
1558		_, _, e1 := Syscall(SYS_STATFS64, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
1559		if e1 != 0 {
1560		err = errnoErr(e1)
1561		}
1562		return
1563		}
	2076	_, _, e1 := syscall_rawSyscall(funcPC(libc_setuid_trampoline), uintptr(uid), 0, 0)
	2077	if e1 != 0 {
	2078	err = errnoErr(e1)
	2079	}
	2080	return
	2081	}
	2082
	2083	func libc_setuid_trampoline()
	2084
	2085	//go:linkname libc_setuid libc_setuid
	2086	//go:cgo_import_dynamic libc_setuid setuid "/usr/lib/libSystem.B.dylib"
1564	2087
1565	2088	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1566	2089

1575	2098	if err != nil {
1576	2099	return
1577	2100	}
1578		_, _, e1 := Syscall(SYS_SYMLINK, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
1579		if e1 != 0 {
1580		err = errnoErr(e1)
1581		}
1582		return
1583		}
	2101	_, _, e1 := syscall_syscall(funcPC(libc_symlink_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), 0)
	2102	if e1 != 0 {
	2103	err = errnoErr(e1)
	2104	}
	2105	return
	2106	}
	2107
	2108	func libc_symlink_trampoline()
	2109
	2110	//go:linkname libc_symlink libc_symlink
	2111	//go:cgo_import_dynamic libc_symlink symlink "/usr/lib/libSystem.B.dylib"
1584	2112
1585	2113	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1586	2114

1595	2123	if err != nil {
1596	2124	return
1597	2125	}
1598		_, _, e1 := Syscall(SYS_SYMLINKAT, uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
1599		if e1 != 0 {
1600		err = errnoErr(e1)
1601		}
1602		return
1603		}
	2126	_, _, e1 := syscall_syscall(funcPC(libc_symlinkat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(newdirfd), uintptr(unsafe.Pointer(_p1)))
	2127	if e1 != 0 {
	2128	err = errnoErr(e1)
	2129	}
	2130	return
	2131	}
	2132
	2133	func libc_symlinkat_trampoline()
	2134
	2135	//go:linkname libc_symlinkat libc_symlinkat
	2136	//go:cgo_import_dynamic libc_symlinkat symlinkat "/usr/lib/libSystem.B.dylib"
1604	2137
1605	2138	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1606	2139
1607	2140	func Sync() (err error) {
1608		_, _, e1 := Syscall(SYS_SYNC, 0, 0, 0)
1609		if e1 != 0 {
1610		err = errnoErr(e1)
1611		}
1612		return
1613		}
	2141	_, _, e1 := syscall_syscall(funcPC(libc_sync_trampoline), 0, 0, 0)
	2142	if e1 != 0 {
	2143	err = errnoErr(e1)
	2144	}
	2145	return
	2146	}
	2147
	2148	func libc_sync_trampoline()
	2149
	2150	//go:linkname libc_sync libc_sync
	2151	//go:cgo_import_dynamic libc_sync sync "/usr/lib/libSystem.B.dylib"
1614	2152
1615	2153	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1616	2154

1620	2158	if err != nil {
1621	2159	return
1622	2160	}
1623		_, _, e1 := Syscall(SYS_TRUNCATE, uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
1624		if e1 != 0 {
1625		err = errnoErr(e1)
1626		}
1627		return
1628		}
	2161	_, _, e1 := syscall_syscall(funcPC(libc_truncate_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(length), 0)
	2162	if e1 != 0 {
	2163	err = errnoErr(e1)
	2164	}
	2165	return
	2166	}
	2167
	2168	func libc_truncate_trampoline()
	2169
	2170	//go:linkname libc_truncate libc_truncate
	2171	//go:cgo_import_dynamic libc_truncate truncate "/usr/lib/libSystem.B.dylib"
1629	2172
1630	2173	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1631	2174
1632	2175	func Umask(newmask int) (oldmask int) {
1633		r0, _, _ := Syscall(SYS_UMASK, uintptr(newmask), 0, 0)
	2176	r0, _, _ := syscall_syscall(funcPC(libc_umask_trampoline), uintptr(newmask), 0, 0)
1634	2177	oldmask = int(r0)
1635	2178	return
1636	2179	}
1637	2180
	2181	func libc_umask_trampoline()
	2182
	2183	//go:linkname libc_umask libc_umask
	2184	//go:cgo_import_dynamic libc_umask umask "/usr/lib/libSystem.B.dylib"
	2185
1638	2186	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1639	2187
1640	2188	func Undelete(path string) (err error) {

1643	2191	if err != nil {
1644	2192	return
1645	2193	}
1646		_, _, e1 := Syscall(SYS_UNDELETE, uintptr(unsafe.Pointer(_p0)), 0, 0)
1647		if e1 != 0 {
1648		err = errnoErr(e1)
1649		}
1650		return
1651		}
	2194	_, _, e1 := syscall_syscall(funcPC(libc_undelete_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2195	if e1 != 0 {
	2196	err = errnoErr(e1)
	2197	}
	2198	return
	2199	}
	2200
	2201	func libc_undelete_trampoline()
	2202
	2203	//go:linkname libc_undelete libc_undelete
	2204	//go:cgo_import_dynamic libc_undelete undelete "/usr/lib/libSystem.B.dylib"
1652	2205
1653	2206	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1654	2207

1658	2211	if err != nil {
1659	2212	return
1660	2213	}
1661		_, _, e1 := Syscall(SYS_UNLINK, uintptr(unsafe.Pointer(_p0)), 0, 0)
1662		if e1 != 0 {
1663		err = errnoErr(e1)
1664		}
1665		return
1666		}
	2214	_, _, e1 := syscall_syscall(funcPC(libc_unlink_trampoline), uintptr(unsafe.Pointer(_p0)), 0, 0)
	2215	if e1 != 0 {
	2216	err = errnoErr(e1)
	2217	}
	2218	return
	2219	}
	2220
	2221	func libc_unlink_trampoline()
	2222
	2223	//go:linkname libc_unlink libc_unlink
	2224	//go:cgo_import_dynamic libc_unlink unlink "/usr/lib/libSystem.B.dylib"
1667	2225
1668	2226	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1669	2227

1673	2231	if err != nil {
1674	2232	return
1675	2233	}
1676		_, _, e1 := Syscall(SYS_UNLINKAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
1677		if e1 != 0 {
1678		err = errnoErr(e1)
1679		}
1680		return
1681		}
	2234	_, _, e1 := syscall_syscall(funcPC(libc_unlinkat_trampoline), uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(flags))
	2235	if e1 != 0 {
	2236	err = errnoErr(e1)
	2237	}
	2238	return
	2239	}
	2240
	2241	func libc_unlinkat_trampoline()
	2242
	2243	//go:linkname libc_unlinkat libc_unlinkat
	2244	//go:cgo_import_dynamic libc_unlinkat unlinkat "/usr/lib/libSystem.B.dylib"
1682	2245
1683	2246	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1684	2247

1688	2251	if err != nil {
1689	2252	return
1690	2253	}
1691		_, _, e1 := Syscall(SYS_UNMOUNT, uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
1692		if e1 != 0 {
1693		err = errnoErr(e1)
1694		}
1695		return
1696		}
	2254	_, _, e1 := syscall_syscall(funcPC(libc_unmount_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(flags), 0)
	2255	if e1 != 0 {
	2256	err = errnoErr(e1)
	2257	}
	2258	return
	2259	}
	2260
	2261	func libc_unmount_trampoline()
	2262
	2263	//go:linkname libc_unmount libc_unmount
	2264	//go:cgo_import_dynamic libc_unmount unmount "/usr/lib/libSystem.B.dylib"
1697	2265
1698	2266	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1699	2267

1704	2272	} else {
1705	2273	_p0 = unsafe.Pointer(&_zero)
1706	2274	}
1707		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)))
	2275	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(_p0), uintptr(len(p)))
1708	2276	n = int(r0)
1709	2277	if e1 != 0 {
1710	2278	err = errnoErr(e1)

1712	2280	return
1713	2281	}
1714	2282
	2283	func libc_write_trampoline()
	2284
	2285	//go:linkname libc_write libc_write
	2286	//go:cgo_import_dynamic libc_write write "/usr/lib/libSystem.B.dylib"
	2287
1715	2288	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1716	2289
1717	2290	func mmap(addr uintptr, length uintptr, prot int, flag int, fd int, pos int64) (ret uintptr, err error) {
1718		r0, _, e1 := Syscall6(SYS_MMAP, uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
	2291	r0, _, e1 := syscall_syscall6(funcPC(libc_mmap_trampoline), uintptr(addr), uintptr(length), uintptr(prot), uintptr(flag), uintptr(fd), uintptr(pos))
1719	2292	ret = uintptr(r0)
1720	2293	if e1 != 0 {
1721	2294	err = errnoErr(e1)

1723	2296	return
1724	2297	}
1725	2298
	2299	func libc_mmap_trampoline()
	2300
	2301	//go:linkname libc_mmap libc_mmap
	2302	//go:cgo_import_dynamic libc_mmap mmap "/usr/lib/libSystem.B.dylib"
	2303
1726	2304	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1727	2305
1728	2306	func munmap(addr uintptr, length uintptr) (err error) {
1729		_, _, e1 := Syscall(SYS_MUNMAP, uintptr(addr), uintptr(length), 0)
1730		if e1 != 0 {
1731		err = errnoErr(e1)
1732		}
1733		return
1734		}
	2307	_, _, e1 := syscall_syscall(funcPC(libc_munmap_trampoline), uintptr(addr), uintptr(length), 0)
	2308	if e1 != 0 {
	2309	err = errnoErr(e1)
	2310	}
	2311	return
	2312	}
	2313
	2314	func libc_munmap_trampoline()
	2315
	2316	//go:linkname libc_munmap libc_munmap
	2317	//go:cgo_import_dynamic libc_munmap munmap "/usr/lib/libSystem.B.dylib"
1735	2318
1736	2319	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1737	2320
1738	2321	func readlen(fd int, buf *byte, nbuf int) (n int, err error) {
1739		r0, _, e1 := Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2322	r0, _, e1 := syscall_syscall(funcPC(libc_read_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1740	2323	n = int(r0)
1741	2324	if e1 != 0 {
1742	2325	err = errnoErr(e1)

1747	2330	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1748	2331
1749	2332	func writelen(fd int, buf *byte, nbuf int) (n int, err error) {
1750		r0, _, e1 := Syscall(SYS_WRITE, uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
	2333	r0, _, e1 := syscall_syscall(funcPC(libc_write_trampoline), uintptr(fd), uintptr(unsafe.Pointer(buf)), uintptr(nbuf))
1751	2334	n = int(r0)
1752	2335	if e1 != 0 {
1753	2336	err = errnoErr(e1)

1758	2341	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1759	2342
1760	2343	func gettimeofday(tp *Timeval) (sec int64, usec int32, err error) {
1761		r0, r1, e1 := RawSyscall(SYS_GETTIMEOFDAY, uintptr(unsafe.Pointer(tp)), 0, 0)
	2344	r0, r1, e1 := syscall_rawSyscall(funcPC(libc_gettimeofday_trampoline), uintptr(unsafe.Pointer(tp)), 0, 0)
1762	2345	sec = int64(r0)
1763	2346	usec = int32(r1)
1764	2347	if e1 != 0 {

1766	2349	}
1767	2350	return
1768	2351	}
	2352
	2353	func libc_gettimeofday_trampoline()
	2354
	2355	//go:linkname libc_gettimeofday libc_gettimeofday
	2356	//go:cgo_import_dynamic libc_gettimeofday gettimeofday "/usr/lib/libSystem.B.dylib"
	2357
	2358	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2359
	2360	func Fstat(fd int, stat *Stat_t) (err error) {
	2361	_, _, e1 := syscall_syscall(funcPC(libc_fstat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2362	if e1 != 0 {
	2363	err = errnoErr(e1)
	2364	}
	2365	return
	2366	}
	2367
	2368	func libc_fstat_trampoline()
	2369
	2370	//go:linkname libc_fstat libc_fstat
	2371	//go:cgo_import_dynamic libc_fstat fstat "/usr/lib/libSystem.B.dylib"
	2372
	2373	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2374
	2375	func Fstatat(fd int, path string, stat *Stat_t, flags int) (err error) {
	2376	var _p0 *byte
	2377	_p0, err = BytePtrFromString(path)
	2378	if err != nil {
	2379	return
	2380	}
	2381	_, _, e1 := syscall_syscall6(funcPC(libc_fstatat_trampoline), uintptr(fd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
	2382	if e1 != 0 {
	2383	err = errnoErr(e1)
	2384	}
	2385	return
	2386	}
	2387
	2388	func libc_fstatat_trampoline()
	2389
	2390	//go:linkname libc_fstatat libc_fstatat
	2391	//go:cgo_import_dynamic libc_fstatat fstatat "/usr/lib/libSystem.B.dylib"
	2392
	2393	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2394
	2395	func Fstatfs(fd int, stat *Statfs_t) (err error) {
	2396	_, _, e1 := syscall_syscall(funcPC(libc_fstatfs_trampoline), uintptr(fd), uintptr(unsafe.Pointer(stat)), 0)
	2397	if e1 != 0 {
	2398	err = errnoErr(e1)
	2399	}
	2400	return
	2401	}
	2402
	2403	func libc_fstatfs_trampoline()
	2404
	2405	//go:linkname libc_fstatfs libc_fstatfs
	2406	//go:cgo_import_dynamic libc_fstatfs fstatfs "/usr/lib/libSystem.B.dylib"
	2407
	2408	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2409
	2410	func getfsstat(buf unsafe.Pointer, size uintptr, flags int) (n int, err error) {
	2411	r0, _, e1 := syscall_syscall(funcPC(libc_getfsstat_trampoline), uintptr(buf), uintptr(size), uintptr(flags))
	2412	n = int(r0)
	2413	if e1 != 0 {
	2414	err = errnoErr(e1)
	2415	}
	2416	return
	2417	}
	2418
	2419	func libc_getfsstat_trampoline()
	2420
	2421	//go:linkname libc_getfsstat libc_getfsstat
	2422	//go:cgo_import_dynamic libc_getfsstat getfsstat "/usr/lib/libSystem.B.dylib"
	2423
	2424	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2425
	2426	func Lstat(path string, stat *Stat_t) (err error) {
	2427	var _p0 *byte
	2428	_p0, err = BytePtrFromString(path)
	2429	if err != nil {
	2430	return
	2431	}
	2432	_, _, e1 := syscall_syscall(funcPC(libc_lstat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2433	if e1 != 0 {
	2434	err = errnoErr(e1)
	2435	}
	2436	return
	2437	}
	2438
	2439	func libc_lstat_trampoline()
	2440
	2441	//go:linkname libc_lstat libc_lstat
	2442	//go:cgo_import_dynamic libc_lstat lstat "/usr/lib/libSystem.B.dylib"
	2443
	2444	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2445
	2446	func Stat(path string, stat *Stat_t) (err error) {
	2447	var _p0 *byte
	2448	_p0, err = BytePtrFromString(path)
	2449	if err != nil {
	2450	return
	2451	}
	2452	_, _, e1 := syscall_syscall(funcPC(libc_stat_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2453	if e1 != 0 {
	2454	err = errnoErr(e1)
	2455	}
	2456	return
	2457	}
	2458
	2459	func libc_stat_trampoline()
	2460
	2461	//go:linkname libc_stat libc_stat
	2462	//go:cgo_import_dynamic libc_stat stat "/usr/lib/libSystem.B.dylib"
	2463
	2464	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2465
	2466	func Statfs(path string, stat *Statfs_t) (err error) {
	2467	var _p0 *byte
	2468	_p0, err = BytePtrFromString(path)
	2469	if err != nil {
	2470	return
	2471	}
	2472	_, _, e1 := syscall_syscall(funcPC(libc_statfs_trampoline), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), 0)
	2473	if e1 != 0 {
	2474	err = errnoErr(e1)
	2475	}
	2476	return
	2477	}
	2478
	2479	func libc_statfs_trampoline()
	2480
	2481	//go:linkname libc_statfs libc_statfs
	2482	//go:cgo_import_dynamic libc_statfs statfs "/usr/lib/libSystem.B.dylib"

+282

-0

unix/zsyscall_darwin_arm64.s less more

	0	// go run mkasm_darwin.go arm64
	1	// Code generated by the command above; DO NOT EDIT.
	2
	3	// +build go1.12
	4
	5	#include "textflag.h"
	6	TEXT ·libc_getgroups_trampoline(SB),NOSPLIT,$0-0
	7	JMP libc_getgroups(SB)
	8	TEXT ·libc_setgroups_trampoline(SB),NOSPLIT,$0-0
	9	JMP libc_setgroups(SB)
	10	TEXT ·libc_wait4_trampoline(SB),NOSPLIT,$0-0
	11	JMP libc_wait4(SB)
	12	TEXT ·libc_accept_trampoline(SB),NOSPLIT,$0-0
	13	JMP libc_accept(SB)
	14	TEXT ·libc_bind_trampoline(SB),NOSPLIT,$0-0
	15	JMP libc_bind(SB)
	16	TEXT ·libc_connect_trampoline(SB),NOSPLIT,$0-0
	17	JMP libc_connect(SB)
	18	TEXT ·libc_socket_trampoline(SB),NOSPLIT,$0-0
	19	JMP libc_socket(SB)
	20	TEXT ·libc_getsockopt_trampoline(SB),NOSPLIT,$0-0
	21	JMP libc_getsockopt(SB)
	22	TEXT ·libc_setsockopt_trampoline(SB),NOSPLIT,$0-0
	23	JMP libc_setsockopt(SB)
	24	TEXT ·libc_getpeername_trampoline(SB),NOSPLIT,$0-0
	25	JMP libc_getpeername(SB)
	26	TEXT ·libc_getsockname_trampoline(SB),NOSPLIT,$0-0
	27	JMP libc_getsockname(SB)
	28	TEXT ·libc_shutdown_trampoline(SB),NOSPLIT,$0-0
	29	JMP libc_shutdown(SB)
	30	TEXT ·libc_socketpair_trampoline(SB),NOSPLIT,$0-0
	31	JMP libc_socketpair(SB)
	32	TEXT ·libc_recvfrom_trampoline(SB),NOSPLIT,$0-0
	33	JMP libc_recvfrom(SB)
	34	TEXT ·libc_sendto_trampoline(SB),NOSPLIT,$0-0
	35	JMP libc_sendto(SB)
	36	TEXT ·libc_recvmsg_trampoline(SB),NOSPLIT,$0-0
	37	JMP libc_recvmsg(SB)
	38	TEXT ·libc_sendmsg_trampoline(SB),NOSPLIT,$0-0
	39	JMP libc_sendmsg(SB)
	40	TEXT ·libc_kevent_trampoline(SB),NOSPLIT,$0-0
	41	JMP libc_kevent(SB)
	42	TEXT ·libc___sysctl_trampoline(SB),NOSPLIT,$0-0
	43	JMP libc___sysctl(SB)
	44	TEXT ·libc_utimes_trampoline(SB),NOSPLIT,$0-0
	45	JMP libc_utimes(SB)
	46	TEXT ·libc_futimes_trampoline(SB),NOSPLIT,$0-0
	47	JMP libc_futimes(SB)
	48	TEXT ·libc_fcntl_trampoline(SB),NOSPLIT,$0-0
	49	JMP libc_fcntl(SB)
	50	TEXT ·libc_poll_trampoline(SB),NOSPLIT,$0-0
	51	JMP libc_poll(SB)
	52	TEXT ·libc_madvise_trampoline(SB),NOSPLIT,$0-0
	53	JMP libc_madvise(SB)
	54	TEXT ·libc_mlock_trampoline(SB),NOSPLIT,$0-0
	55	JMP libc_mlock(SB)
	56	TEXT ·libc_mlockall_trampoline(SB),NOSPLIT,$0-0
	57	JMP libc_mlockall(SB)
	58	TEXT ·libc_mprotect_trampoline(SB),NOSPLIT,$0-0
	59	JMP libc_mprotect(SB)
	60	TEXT ·libc_msync_trampoline(SB),NOSPLIT,$0-0
	61	JMP libc_msync(SB)
	62	TEXT ·libc_munlock_trampoline(SB),NOSPLIT,$0-0
	63	JMP libc_munlock(SB)
	64	TEXT ·libc_munlockall_trampoline(SB),NOSPLIT,$0-0
	65	JMP libc_munlockall(SB)
	66	TEXT ·libc_ptrace_trampoline(SB),NOSPLIT,$0-0
	67	JMP libc_ptrace(SB)
	68	TEXT ·libc_getattrlist_trampoline(SB),NOSPLIT,$0-0
	69	JMP libc_getattrlist(SB)
	70	TEXT ·libc_pipe_trampoline(SB),NOSPLIT,$0-0
	71	JMP libc_pipe(SB)
	72	TEXT ·libc_getxattr_trampoline(SB),NOSPLIT,$0-0
	73	JMP libc_getxattr(SB)
	74	TEXT ·libc_fgetxattr_trampoline(SB),NOSPLIT,$0-0
	75	JMP libc_fgetxattr(SB)
	76	TEXT ·libc_setxattr_trampoline(SB),NOSPLIT,$0-0
	77	JMP libc_setxattr(SB)
	78	TEXT ·libc_fsetxattr_trampoline(SB),NOSPLIT,$0-0
	79	JMP libc_fsetxattr(SB)
	80	TEXT ·libc_removexattr_trampoline(SB),NOSPLIT,$0-0
	81	JMP libc_removexattr(SB)
	82	TEXT ·libc_fremovexattr_trampoline(SB),NOSPLIT,$0-0
	83	JMP libc_fremovexattr(SB)
	84	TEXT ·libc_listxattr_trampoline(SB),NOSPLIT,$0-0
	85	JMP libc_listxattr(SB)
	86	TEXT ·libc_flistxattr_trampoline(SB),NOSPLIT,$0-0
	87	JMP libc_flistxattr(SB)
	88	TEXT ·libc_setattrlist_trampoline(SB),NOSPLIT,$0-0
	89	JMP libc_setattrlist(SB)
	90	TEXT ·libc_kill_trampoline(SB),NOSPLIT,$0-0
	91	JMP libc_kill(SB)
	92	TEXT ·libc_ioctl_trampoline(SB),NOSPLIT,$0-0
	93	JMP libc_ioctl(SB)
	94	TEXT ·libc_sendfile_trampoline(SB),NOSPLIT,$0-0
	95	JMP libc_sendfile(SB)
	96	TEXT ·libc_access_trampoline(SB),NOSPLIT,$0-0
	97	JMP libc_access(SB)
	98	TEXT ·libc_adjtime_trampoline(SB),NOSPLIT,$0-0
	99	JMP libc_adjtime(SB)
	100	TEXT ·libc_chdir_trampoline(SB),NOSPLIT,$0-0
	101	JMP libc_chdir(SB)
	102	TEXT ·libc_chflags_trampoline(SB),NOSPLIT,$0-0
	103	JMP libc_chflags(SB)
	104	TEXT ·libc_chmod_trampoline(SB),NOSPLIT,$0-0
	105	JMP libc_chmod(SB)
	106	TEXT ·libc_chown_trampoline(SB),NOSPLIT,$0-0
	107	JMP libc_chown(SB)
	108	TEXT ·libc_chroot_trampoline(SB),NOSPLIT,$0-0
	109	JMP libc_chroot(SB)
	110	TEXT ·libc_close_trampoline(SB),NOSPLIT,$0-0
	111	JMP libc_close(SB)
	112	TEXT ·libc_dup_trampoline(SB),NOSPLIT,$0-0
	113	JMP libc_dup(SB)
	114	TEXT ·libc_dup2_trampoline(SB),NOSPLIT,$0-0
	115	JMP libc_dup2(SB)
	116	TEXT ·libc_exchangedata_trampoline(SB),NOSPLIT,$0-0
	117	JMP libc_exchangedata(SB)
	118	TEXT ·libc_exit_trampoline(SB),NOSPLIT,$0-0
	119	JMP libc_exit(SB)
	120	TEXT ·libc_faccessat_trampoline(SB),NOSPLIT,$0-0
	121	JMP libc_faccessat(SB)
	122	TEXT ·libc_fchdir_trampoline(SB),NOSPLIT,$0-0
	123	JMP libc_fchdir(SB)
	124	TEXT ·libc_fchflags_trampoline(SB),NOSPLIT,$0-0
	125	JMP libc_fchflags(SB)
	126	TEXT ·libc_fchmod_trampoline(SB),NOSPLIT,$0-0
	127	JMP libc_fchmod(SB)
	128	TEXT ·libc_fchmodat_trampoline(SB),NOSPLIT,$0-0
	129	JMP libc_fchmodat(SB)
	130	TEXT ·libc_fchown_trampoline(SB),NOSPLIT,$0-0
	131	JMP libc_fchown(SB)
	132	TEXT ·libc_fchownat_trampoline(SB),NOSPLIT,$0-0
	133	JMP libc_fchownat(SB)
	134	TEXT ·libc_flock_trampoline(SB),NOSPLIT,$0-0
	135	JMP libc_flock(SB)
	136	TEXT ·libc_fpathconf_trampoline(SB),NOSPLIT,$0-0
	137	JMP libc_fpathconf(SB)
	138	TEXT ·libc_fsync_trampoline(SB),NOSPLIT,$0-0
	139	JMP libc_fsync(SB)
	140	TEXT ·libc_ftruncate_trampoline(SB),NOSPLIT,$0-0
	141	JMP libc_ftruncate(SB)
	142	TEXT ·libc_getdtablesize_trampoline(SB),NOSPLIT,$0-0
	143	JMP libc_getdtablesize(SB)
	144	TEXT ·libc_getegid_trampoline(SB),NOSPLIT,$0-0
	145	JMP libc_getegid(SB)
	146	TEXT ·libc_geteuid_trampoline(SB),NOSPLIT,$0-0
	147	JMP libc_geteuid(SB)
	148	TEXT ·libc_getgid_trampoline(SB),NOSPLIT,$0-0
	149	JMP libc_getgid(SB)
	150	TEXT ·libc_getpgid_trampoline(SB),NOSPLIT,$0-0
	151	JMP libc_getpgid(SB)
	152	TEXT ·libc_getpgrp_trampoline(SB),NOSPLIT,$0-0
	153	JMP libc_getpgrp(SB)
	154	TEXT ·libc_getpid_trampoline(SB),NOSPLIT,$0-0
	155	JMP libc_getpid(SB)
	156	TEXT ·libc_getppid_trampoline(SB),NOSPLIT,$0-0
	157	JMP libc_getppid(SB)
	158	TEXT ·libc_getpriority_trampoline(SB),NOSPLIT,$0-0
	159	JMP libc_getpriority(SB)
	160	TEXT ·libc_getrlimit_trampoline(SB),NOSPLIT,$0-0
	161	JMP libc_getrlimit(SB)
	162	TEXT ·libc_getrusage_trampoline(SB),NOSPLIT,$0-0
	163	JMP libc_getrusage(SB)
	164	TEXT ·libc_getsid_trampoline(SB),NOSPLIT,$0-0
	165	JMP libc_getsid(SB)
	166	TEXT ·libc_getuid_trampoline(SB),NOSPLIT,$0-0
	167	JMP libc_getuid(SB)
	168	TEXT ·libc_issetugid_trampoline(SB),NOSPLIT,$0-0
	169	JMP libc_issetugid(SB)
	170	TEXT ·libc_kqueue_trampoline(SB),NOSPLIT,$0-0
	171	JMP libc_kqueue(SB)
	172	TEXT ·libc_lchown_trampoline(SB),NOSPLIT,$0-0
	173	JMP libc_lchown(SB)
	174	TEXT ·libc_link_trampoline(SB),NOSPLIT,$0-0
	175	JMP libc_link(SB)
	176	TEXT ·libc_linkat_trampoline(SB),NOSPLIT,$0-0
	177	JMP libc_linkat(SB)
	178	TEXT ·libc_listen_trampoline(SB),NOSPLIT,$0-0
	179	JMP libc_listen(SB)
	180	TEXT ·libc_mkdir_trampoline(SB),NOSPLIT,$0-0
	181	JMP libc_mkdir(SB)
	182	TEXT ·libc_mkdirat_trampoline(SB),NOSPLIT,$0-0
	183	JMP libc_mkdirat(SB)
	184	TEXT ·libc_mkfifo_trampoline(SB),NOSPLIT,$0-0
	185	JMP libc_mkfifo(SB)
	186	TEXT ·libc_mknod_trampoline(SB),NOSPLIT,$0-0
	187	JMP libc_mknod(SB)
	188	TEXT ·libc_open_trampoline(SB),NOSPLIT,$0-0
	189	JMP libc_open(SB)
	190	TEXT ·libc_openat_trampoline(SB),NOSPLIT,$0-0
	191	JMP libc_openat(SB)
	192	TEXT ·libc_pathconf_trampoline(SB),NOSPLIT,$0-0
	193	JMP libc_pathconf(SB)
	194	TEXT ·libc_pread_trampoline(SB),NOSPLIT,$0-0
	195	JMP libc_pread(SB)
	196	TEXT ·libc_pwrite_trampoline(SB),NOSPLIT,$0-0
	197	JMP libc_pwrite(SB)
	198	TEXT ·libc_read_trampoline(SB),NOSPLIT,$0-0
	199	JMP libc_read(SB)
	200	TEXT ·libc_readlink_trampoline(SB),NOSPLIT,$0-0
	201	JMP libc_readlink(SB)
	202	TEXT ·libc_readlinkat_trampoline(SB),NOSPLIT,$0-0
	203	JMP libc_readlinkat(SB)
	204	TEXT ·libc_rename_trampoline(SB),NOSPLIT,$0-0
	205	JMP libc_rename(SB)
	206	TEXT ·libc_renameat_trampoline(SB),NOSPLIT,$0-0
	207	JMP libc_renameat(SB)
	208	TEXT ·libc_revoke_trampoline(SB),NOSPLIT,$0-0
	209	JMP libc_revoke(SB)
	210	TEXT ·libc_rmdir_trampoline(SB),NOSPLIT,$0-0
	211	JMP libc_rmdir(SB)
	212	TEXT ·libc_lseek_trampoline(SB),NOSPLIT,$0-0
	213	JMP libc_lseek(SB)
	214	TEXT ·libc_select_trampoline(SB),NOSPLIT,$0-0
	215	JMP libc_select(SB)
	216	TEXT ·libc_setegid_trampoline(SB),NOSPLIT,$0-0
	217	JMP libc_setegid(SB)
	218	TEXT ·libc_seteuid_trampoline(SB),NOSPLIT,$0-0
	219	JMP libc_seteuid(SB)
	220	TEXT ·libc_setgid_trampoline(SB),NOSPLIT,$0-0
	221	JMP libc_setgid(SB)
	222	TEXT ·libc_setlogin_trampoline(SB),NOSPLIT,$0-0
	223	JMP libc_setlogin(SB)
	224	TEXT ·libc_setpgid_trampoline(SB),NOSPLIT,$0-0
	225	JMP libc_setpgid(SB)
	226	TEXT ·libc_setpriority_trampoline(SB),NOSPLIT,$0-0
	227	JMP libc_setpriority(SB)
	228	TEXT ·libc_setprivexec_trampoline(SB),NOSPLIT,$0-0
	229	JMP libc_setprivexec(SB)
	230	TEXT ·libc_setregid_trampoline(SB),NOSPLIT,$0-0
	231	JMP libc_setregid(SB)
	232	TEXT ·libc_setreuid_trampoline(SB),NOSPLIT,$0-0
	233	JMP libc_setreuid(SB)
	234	TEXT ·libc_setrlimit_trampoline(SB),NOSPLIT,$0-0
	235	JMP libc_setrlimit(SB)
	236	TEXT ·libc_setsid_trampoline(SB),NOSPLIT,$0-0
	237	JMP libc_setsid(SB)
	238	TEXT ·libc_settimeofday_trampoline(SB),NOSPLIT,$0-0
	239	JMP libc_settimeofday(SB)
	240	TEXT ·libc_setuid_trampoline(SB),NOSPLIT,$0-0
	241	JMP libc_setuid(SB)
	242	TEXT ·libc_symlink_trampoline(SB),NOSPLIT,$0-0
	243	JMP libc_symlink(SB)
	244	TEXT ·libc_symlinkat_trampoline(SB),NOSPLIT,$0-0
	245	JMP libc_symlinkat(SB)
	246	TEXT ·libc_sync_trampoline(SB),NOSPLIT,$0-0
	247	JMP libc_sync(SB)
	248	TEXT ·libc_truncate_trampoline(SB),NOSPLIT,$0-0
	249	JMP libc_truncate(SB)
	250	TEXT ·libc_umask_trampoline(SB),NOSPLIT,$0-0
	251	JMP libc_umask(SB)
	252	TEXT ·libc_undelete_trampoline(SB),NOSPLIT,$0-0
	253	JMP libc_undelete(SB)
	254	TEXT ·libc_unlink_trampoline(SB),NOSPLIT,$0-0
	255	JMP libc_unlink(SB)
	256	TEXT ·libc_unlinkat_trampoline(SB),NOSPLIT,$0-0
	257	JMP libc_unlinkat(SB)
	258	TEXT ·libc_unmount_trampoline(SB),NOSPLIT,$0-0
	259	JMP libc_unmount(SB)
	260	TEXT ·libc_write_trampoline(SB),NOSPLIT,$0-0
	261	JMP libc_write(SB)
	262	TEXT ·libc_mmap_trampoline(SB),NOSPLIT,$0-0
	263	JMP libc_mmap(SB)
	264	TEXT ·libc_munmap_trampoline(SB),NOSPLIT,$0-0
	265	JMP libc_munmap(SB)
	266	TEXT ·libc_gettimeofday_trampoline(SB),NOSPLIT,$0-0
	267	JMP libc_gettimeofday(SB)
	268	TEXT ·libc_fstat_trampoline(SB),NOSPLIT,$0-0
	269	JMP libc_fstat(SB)
	270	TEXT ·libc_fstatat_trampoline(SB),NOSPLIT,$0-0
	271	JMP libc_fstatat(SB)
	272	TEXT ·libc_fstatfs_trampoline(SB),NOSPLIT,$0-0
	273	JMP libc_fstatfs(SB)
	274	TEXT ·libc_getfsstat_trampoline(SB),NOSPLIT,$0-0
	275	JMP libc_getfsstat(SB)
	276	TEXT ·libc_lstat_trampoline(SB),NOSPLIT,$0-0
	277	JMP libc_lstat(SB)
	278	TEXT ·libc_stat_trampoline(SB),NOSPLIT,$0-0
	279	JMP libc_stat(SB)
	280	TEXT ·libc_statfs_trampoline(SB),NOSPLIT,$0-0
	281	JMP libc_statfs(SB)

+15

-15

unix/zsyscall_linux_mips64.go less more

1718	1718
1719	1719	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1720	1720
1721		func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) {
1722		var _p0 *byte
1723		_p0, err = BytePtrFromString(path)
1724		if err != nil {
1725		return
1726		}
1727		_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
1728		if e1 != 0 {
1729		err = errnoErr(e1)
1730		}
1731		return
1732		}
1733
1734		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1735
1736	1721	func Fstatfs(fd int, buf *Statfs_t) (err error) {
1737	1722	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
1738	1723	if e1 != 0 {

2292	2277
2293	2278	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
2294	2279
	2280	func fstatat(dirfd int, path string, st *stat_t, flags int) (err error) {
	2281	var _p0 *byte
	2282	_p0, err = BytePtrFromString(path)
	2283	if err != nil {
	2284	return
	2285	}
	2286	_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(st)), uintptr(flags), 0, 0)
	2287	if e1 != 0 {
	2288	err = errnoErr(e1)
	2289	}
	2290	return
	2291	}
	2292
	2293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2294
2295	2295	func lstat(path string, st *stat_t) (err error) {
2296	2296	var _p0 *byte
2297	2297	_p0, err = BytePtrFromString(path)

+15

-15

unix/zsyscall_linux_mips64le.go less more

1718	1718
1719	1719	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1720	1720
1721		func Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) {
1722		var _p0 *byte
1723		_p0, err = BytePtrFromString(path)
1724		if err != nil {
1725		return
1726		}
1727		_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(stat)), uintptr(flags), 0, 0)
1728		if e1 != 0 {
1729		err = errnoErr(e1)
1730		}
1731		return
1732		}
1733
1734		// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
1735
1736	1721	func Fstatfs(fd int, buf *Statfs_t) (err error) {
1737	1722	_, _, e1 := Syscall(SYS_FSTATFS, uintptr(fd), uintptr(unsafe.Pointer(buf)), 0)
1738	1723	if e1 != 0 {

2292	2277
2293	2278	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
2294	2279
	2280	func fstatat(dirfd int, path string, st *stat_t, flags int) (err error) {
	2281	var _p0 *byte
	2282	_p0, err = BytePtrFromString(path)
	2283	if err != nil {
	2284	return
	2285	}
	2286	_, _, e1 := Syscall6(SYS_NEWFSTATAT, uintptr(dirfd), uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(st)), uintptr(flags), 0, 0)
	2287	if e1 != 0 {
	2288	err = errnoErr(e1)
	2289	}
	2290	return
	2291	}
	2292
	2293	// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
	2294
2295	2295	func lstat(path string, st *stat_t) (err error) {
2296	2296	var _p0 *byte
2297	2297	_p0, err = BytePtrFromString(path)

-1

unix/zsysnum_darwin_386.go less more

0		// mksysnum_darwin.pl /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
	0	// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build 386,darwin

-1

unix/zsysnum_darwin_amd64.go less more

0		// mksysnum_darwin.pl /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
	0	// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.13.sdk/usr/include/sys/syscall.h
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build amd64,darwin

-1

unix/zsysnum_darwin_arm.go less more

0		// mksysnum_darwin.pl /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
	0	// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build arm,darwin

-1

unix/zsysnum_darwin_arm64.go less more

0		// mksysnum_darwin.pl /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
	0	// go run mksysnum.go /Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS11.1.sdk/usr/include/sys/syscall.h
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build arm64,darwin

+88

-88

unix/zsysnum_dragonfly_amd64.go less more

0		// mksysnum_dragonfly.pl
	0	// go run mksysnum.go http://gitweb.dragonflybsd.org/dragonfly.git/blob_plain/HEAD:/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build amd64,dragonfly

12	12	SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, size_t nbyte); }
13	13	SYS_OPEN = 5 // { int open(char *path, int flags, int mode); }
14	14	SYS_CLOSE = 6 // { int close(int fd); }
15		SYS_WAIT4 = 7 // { int wait4(int pid, int *status, int options, \
	15	SYS_WAIT4 = 7 // { int wait4(int pid, int status, int options, struct rusage rusage); } wait4 wait_args int
16	16	SYS_LINK = 9 // { int link(char path, char link); }
17	17	SYS_UNLINK = 10 // { int unlink(char *path); }
18	18	SYS_CHDIR = 12 // { int chdir(char *path); }

21	21	SYS_CHMOD = 15 // { int chmod(char *path, int mode); }
22	22	SYS_CHOWN = 16 // { int chown(char *path, int uid, int gid); }
23	23	SYS_OBREAK = 17 // { int obreak(char *nsize); } break obreak_args int
24		SYS_GETFSSTAT = 18 // { int getfsstat(struct statfs *buf, long bufsize, \
	24	SYS_GETFSSTAT = 18 // { int getfsstat(struct statfs *buf, long bufsize, int flags); }
25	25	SYS_GETPID = 20 // { pid_t getpid(void); }
26		SYS_MOUNT = 21 // { int mount(char type, char path, int flags, \
	26	SYS_MOUNT = 21 // { int mount(char type, char path, int flags, caddr_t data); }
27	27	SYS_UNMOUNT = 22 // { int unmount(char *path, int flags); }
28	28	SYS_SETUID = 23 // { int setuid(uid_t uid); }
29	29	SYS_GETUID = 24 // { uid_t getuid(void); }
30	30	SYS_GETEUID = 25 // { uid_t geteuid(void); }
31		SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, \
	31	SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, int data); }
32	32	SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, int flags); }
33	33	SYS_SENDMSG = 28 // { int sendmsg(int s, caddr_t msg, int flags); }
34		SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, \
	34	SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, int flags, caddr_t from, int *fromlenaddr); }
35	35	SYS_ACCEPT = 30 // { int accept(int s, caddr_t name, int *anamelen); }
36	36	SYS_GETPEERNAME = 31 // { int getpeername(int fdes, caddr_t asa, int *alen); }
37	37	SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, caddr_t asa, int *alen); }

44	44	SYS_DUP = 41 // { int dup(int fd); }
45	45	SYS_PIPE = 42 // { int pipe(void); }
46	46	SYS_GETEGID = 43 // { gid_t getegid(void); }
47		SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, \
48		SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, \
	47	SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, size_t offset, u_int scale); }
	48	SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, int pid); }
49	49	SYS_GETGID = 47 // { gid_t getgid(void); }
50	50	SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int namelen); }
51	51	SYS_SETLOGIN = 50 // { int setlogin(char *namebuf); }

66	66	SYS_MUNMAP = 73 // { int munmap(void *addr, size_t len); }
67	67	SYS_MPROTECT = 74 // { int mprotect(void *addr, size_t len, int prot); }
68	68	SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, int behav); }
69		SYS_MINCORE = 78 // { int mincore(const void *addr, size_t len, \
	69	SYS_MINCORE = 78 // { int mincore(const void addr, size_t len, char vec); }
70	70	SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, gid_t *gidset); }
71	71	SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, gid_t *gidset); }
72	72	SYS_GETPGRP = 81 // { int getpgrp(void); }
73	73	SYS_SETPGID = 82 // { int setpgid(int pid, int pgid); }
74		SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval *itv, \
	74	SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval itv, struct itimerval oitv); }
75	75	SYS_SWAPON = 85 // { int swapon(char *name); }
76	76	SYS_GETITIMER = 86 // { int getitimer(u_int which, struct itimerval *itv); }
77	77	SYS_GETDTABLESIZE = 89 // { int getdtablesize(void); }
78	78	SYS_DUP2 = 90 // { int dup2(int from, int to); }
79	79	SYS_FCNTL = 92 // { int fcntl(int fd, int cmd, long arg); }
80		SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, \
	80	SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
81	81	SYS_FSYNC = 95 // { int fsync(int fd); }
82	82	SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, int prio); }
83	83	SYS_SOCKET = 97 // { int socket(int domain, int type, int protocol); }
84	84	SYS_CONNECT = 98 // { int connect(int s, caddr_t name, int namelen); }
85	85	SYS_GETPRIORITY = 100 // { int getpriority(int which, int who); }
86	86	SYS_BIND = 104 // { int bind(int s, caddr_t name, int namelen); }
87		SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, \
	87	SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, caddr_t val, int valsize); }
88	88	SYS_LISTEN = 106 // { int listen(int s, int backlog); }
89		SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval *tp, \
	89	SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval tp, struct timezone tzp); }
90	90	SYS_GETRUSAGE = 117 // { int getrusage(int who, struct rusage *rusage); }
91		SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, \
	91	SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, caddr_t val, int *avalsize); }
92	92	SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
93		SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, \
94		SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval *tv, \
	93	SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
	94	SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval tv, struct timezone tzp); }
95	95	SYS_FCHOWN = 123 // { int fchown(int fd, int uid, int gid); }
96	96	SYS_FCHMOD = 124 // { int fchmod(int fd, int mode); }
97	97	SYS_SETREUID = 126 // { int setreuid(int ruid, int euid); }

99	99	SYS_RENAME = 128 // { int rename(char from, char to); }
100	100	SYS_FLOCK = 131 // { int flock(int fd, int how); }
101	101	SYS_MKFIFO = 132 // { int mkfifo(char *path, int mode); }
102		SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, \
	102	SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen); }
103	103	SYS_SHUTDOWN = 134 // { int shutdown(int s, int how); }
104		SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, \
	104	SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, int *rsv); }
105	105	SYS_MKDIR = 136 // { int mkdir(char *path, int mode); }
106	106	SYS_RMDIR = 137 // { int rmdir(char *path); }
107	107	SYS_UTIMES = 138 // { int utimes(char path, struct timeval tptr); }
108		SYS_ADJTIME = 140 // { int adjtime(struct timeval *delta, \
	108	SYS_ADJTIME = 140 // { int adjtime(struct timeval delta, struct timeval olddelta); }
109	109	SYS_SETSID = 147 // { int setsid(void); }
110		SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, \
	110	SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, caddr_t arg); }
111	111	SYS_STATFS = 157 // { int statfs(char path, struct statfs buf); }
112	112	SYS_FSTATFS = 158 // { int fstatfs(int fd, struct statfs *buf); }
113	113	SYS_GETFH = 161 // { int getfh(char fname, struct fhandle fhp); }

115	115	SYS_SETDOMAINNAME = 163 // { int setdomainname(char *domainname, int len); }
116	116	SYS_UNAME = 164 // { int uname(struct utsname *name); }
117	117	SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); }
118		SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \
119		SYS_EXTPREAD = 173 // { ssize_t extpread(int fd, void *buf, \
120		SYS_EXTPWRITE = 174 // { ssize_t extpwrite(int fd, const void *buf, \
	118	SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, struct rtprio *rtp); }
	119	SYS_EXTPREAD = 173 // { ssize_t extpread(int fd, void *buf, size_t nbyte, int flags, off_t offset); }
	120	SYS_EXTPWRITE = 174 // { ssize_t extpwrite(int fd, const void *buf, size_t nbyte, int flags, off_t offset); }
121	121	SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); }
122	122	SYS_SETGID = 181 // { int setgid(gid_t gid); }
123	123	SYS_SETEGID = 182 // { int setegid(gid_t egid); }
124	124	SYS_SETEUID = 183 // { int seteuid(uid_t euid); }
125	125	SYS_PATHCONF = 191 // { int pathconf(char *path, int name); }
126	126	SYS_FPATHCONF = 192 // { int fpathconf(int fd, int name); }
127		SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, \
128		SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, \
129		SYS_MMAP = 197 // { caddr_t mmap(caddr_t addr, size_t len, int prot, \
	127	SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, struct rlimit *rlp); } getrlimit __getrlimit_args int
	128	SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, struct rlimit *rlp); } setrlimit __setrlimit_args int
	129	SYS_MMAP = 197 // { caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, int pad, off_t pos); }
130	130	// SYS_NOSYS = 198; // { int nosys(void); } __syscall __syscall_args int
131		SYS_LSEEK = 199 // { off_t lseek(int fd, int pad, off_t offset, \
	131	SYS_LSEEK = 199 // { off_t lseek(int fd, int pad, off_t offset, int whence); }
132	132	SYS_TRUNCATE = 200 // { int truncate(char *path, int pad, off_t length); }
133	133	SYS_FTRUNCATE = 201 // { int ftruncate(int fd, int pad, off_t length); }
134		SYS___SYSCTL = 202 // { int __sysctl(int name, u_int namelen, void old, \
	134	SYS___SYSCTL = 202 // { int __sysctl(int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); } __sysctl sysctl_args int
135	135	SYS_MLOCK = 203 // { int mlock(const void *addr, size_t len); }
136	136	SYS_MUNLOCK = 204 // { int munlock(const void *addr, size_t len); }
137	137	SYS_UNDELETE = 205 // { int undelete(char *path); }
138	138	SYS_FUTIMES = 206 // { int futimes(int fd, struct timeval *tptr); }
139	139	SYS_GETPGID = 207 // { int getpgid(pid_t pid); }
140		SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, \
141		SYS___SEMCTL = 220 // { int __semctl(int semid, int semnum, int cmd, \
	140	SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, int timeout); }
	141	SYS___SEMCTL = 220 // { int __semctl(int semid, int semnum, int cmd, union semun *arg); }
142	142	SYS_SEMGET = 221 // { int semget(key_t key, int nsems, int semflg); }
143		SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, \
144		SYS_MSGCTL = 224 // { int msgctl(int msqid, int cmd, \
	143	SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, u_int nsops); }
	144	SYS_MSGCTL = 224 // { int msgctl(int msqid, int cmd, struct msqid_ds *buf); }
145	145	SYS_MSGGET = 225 // { int msgget(key_t key, int msgflg); }
146		SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, \
147		SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, size_t msgsz, \
148		SYS_SHMAT = 228 // { caddr_t shmat(int shmid, const void *shmaddr, \
149		SYS_SHMCTL = 229 // { int shmctl(int shmid, int cmd, \
	146	SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	147	SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	148	SYS_SHMAT = 228 // { caddr_t shmat(int shmid, const void *shmaddr, int shmflg); }
	149	SYS_SHMCTL = 229 // { int shmctl(int shmid, int cmd, struct shmid_ds *buf); }
150	150	SYS_SHMDT = 230 // { int shmdt(const void *shmaddr); }
151	151	SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, int shmflg); }
152		SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, \
153		SYS_CLOCK_SETTIME = 233 // { int clock_settime(clockid_t clock_id, \
154		SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, \
155		SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec *rqtp, \
	152	SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, struct timespec *tp); }
	153	SYS_CLOCK_SETTIME = 233 // { int clock_settime(clockid_t clock_id, const struct timespec *tp); }
	154	SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, struct timespec *tp); }
	155	SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec rqtp, struct timespec rmtp); }
156	156	SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, int inherit); }
157	157	SYS_RFORK = 251 // { int rfork(int flags); }
158		SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, u_int nfds, \
	158	SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, u_int nfds, int timeout); }
159	159	SYS_ISSETUGID = 253 // { int issetugid(void); }
160	160	SYS_LCHOWN = 254 // { int lchown(char *path, int uid, int gid); }
161	161	SYS_LCHMOD = 274 // { int lchmod(char *path, mode_t mode); }
162	162	SYS_LUTIMES = 276 // { int lutimes(char path, struct timeval tptr); }
163		SYS_EXTPREADV = 289 // { ssize_t extpreadv(int fd, struct iovec *iovp, \
164		SYS_EXTPWRITEV = 290 // { ssize_t extpwritev(int fd, struct iovec *iovp,\
	163	SYS_EXTPREADV = 289 // { ssize_t extpreadv(int fd, struct iovec *iovp, u_int iovcnt, int flags, off_t offset); }
	164	SYS_EXTPWRITEV = 290 // { ssize_t extpwritev(int fd, struct iovec *iovp,u_int iovcnt, int flags, off_t offset); }
165	165	SYS_FHSTATFS = 297 // { int fhstatfs(const struct fhandle u_fhp, struct statfs buf); }
166	166	SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, int flags); }
167	167	SYS_MODNEXT = 300 // { int modnext(int modid); }

199	199	SYS_UTRACE = 335 // { int utrace(const void *addr, size_t len); }
200	200	SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, void *data); }
201	201	SYS_JAIL = 338 // { int jail(struct jail *jail); }
202		SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t *set, \
	202	SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t set, sigset_t oset); }
203	203	SYS_SIGSUSPEND = 341 // { int sigsuspend(const sigset_t *sigmask); }
204		SYS_SIGACTION = 342 // { int sigaction(int sig, const struct sigaction *act, \
	204	SYS_SIGACTION = 342 // { int sigaction(int sig, const struct sigaction act, struct sigaction oact); }
205	205	SYS_SIGPENDING = 343 // { int sigpending(sigset_t *set); }
206	206	SYS_SIGRETURN = 344 // { int sigreturn(ucontext_t *sigcntxp); }
207		SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t *set,\
208		SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t *set,\
209		SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char *path, \
210		SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char *path, \
211		SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, \
212		SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, \
213		SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, \
	207	SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t set,siginfo_t info, const struct timespec *timeout); }
	208	SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t set,siginfo_t info); }
	209	SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char path, acl_type_t type, struct acl aclp); }
	210	SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char path, acl_type_t type, struct acl aclp); }
	211	SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp); }
	212	SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp); }
	213	SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, acl_type_t type); }
214	214	SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, acl_type_t type); }
215		SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \
216		SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, \
217		SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \
218		SYS_EXTATTR_SET_FILE = 356 // { int extattr_set_file(const char *path, \
219		SYS_EXTATTR_GET_FILE = 357 // { int extattr_get_file(const char *path, \
220		SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \
	215	SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char path, acl_type_t type, struct acl aclp); }
	216	SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp); }
	217	SYS_EXTATTRCTL = 355 // { int extattrctl(const char path, int cmd, const char filename, int attrnamespace, const char *attrname); }
	218	SYS_EXTATTR_SET_FILE = 356 // { int extattr_set_file(const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	219	SYS_EXTATTR_GET_FILE = 357 // { int extattr_get_file(const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	220	SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char path, int attrnamespace, const char attrname); }
221	221	SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete(struct aiocb *aiocbp, struct timespec timeout); }
222	222	SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
223	223	SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
224	224	SYS_KQUEUE = 362 // { int kqueue(void); }
225		SYS_KEVENT = 363 // { int kevent(int fd, \
	225	SYS_KEVENT = 363 // { int kevent(int fd, const struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
226	226	SYS_KENV = 390 // { int kenv(int what, const char name, char value, int len); }
227	227	SYS_LCHFLAGS = 391 // { int lchflags(char *path, int flags); }
228	228	SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, int count); }
229		SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, \
	229	SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, struct sf_hdtr hdtr, off_t sbytes, int flags); }
230	230	SYS_VARSYM_SET = 450 // { int varsym_set(int level, const char name, const char data); }
231	231	SYS_VARSYM_GET = 451 // { int varsym_get(int mask, const char wild, char buf, int bufsize); }
232	232	SYS_VARSYM_LIST = 452 // { int varsym_list(int level, char buf, int maxsize, int marker); }

244	244	SYS_FSTAT = 476 // { int fstat(int fd, struct stat *sb); }
245	245	SYS_LSTAT = 477 // { int lstat(const char path, struct stat ub); }
246	246	SYS_FHSTAT = 478 // { int fhstat(const struct fhandle u_fhp, struct stat sb); }
247		SYS_GETDIRENTRIES = 479 // { int getdirentries(int fd, char *buf, u_int count, \
	247	SYS_GETDIRENTRIES = 479 // { int getdirentries(int fd, char buf, u_int count, long basep); }
248	248	SYS_GETDENTS = 480 // { int getdents(int fd, char *buf, size_t count); }
249		SYS_USCHED_SET = 481 // { int usched_set(pid_t pid, int cmd, void *data, \
	249	SYS_USCHED_SET = 481 // { int usched_set(pid_t pid, int cmd, void *data, int bytes); }
250	250	SYS_EXTACCEPT = 482 // { int extaccept(int s, int flags, caddr_t name, int *anamelen); }
251	251	SYS_EXTCONNECT = 483 // { int extconnect(int s, int flags, caddr_t name, int namelen); }
252	252	SYS_MCONTROL = 485 // { int mcontrol(void *addr, size_t len, int behav, off_t value); }
253	253	SYS_VMSPACE_CREATE = 486 // { int vmspace_create(void id, int type, void data); }
254	254	SYS_VMSPACE_DESTROY = 487 // { int vmspace_destroy(void *id); }
255		SYS_VMSPACE_CTL = 488 // { int vmspace_ctl(void *id, int cmd, \
256		SYS_VMSPACE_MMAP = 489 // { int vmspace_mmap(void id, void addr, size_t len, \
257		SYS_VMSPACE_MUNMAP = 490 // { int vmspace_munmap(void id, void addr, \
258		SYS_VMSPACE_MCONTROL = 491 // { int vmspace_mcontrol(void id, void addr, \
259		SYS_VMSPACE_PREAD = 492 // { ssize_t vmspace_pread(void id, void buf, \
260		SYS_VMSPACE_PWRITE = 493 // { ssize_t vmspace_pwrite(void id, const void buf, \
	255	SYS_VMSPACE_CTL = 488 // { int vmspace_ctl(void id, int cmd, struct trapframe tframe, struct vextframe *vframe); }
	256	SYS_VMSPACE_MMAP = 489 // { int vmspace_mmap(void id, void addr, size_t len, int prot, int flags, int fd, off_t offset); }
	257	SYS_VMSPACE_MUNMAP = 490 // { int vmspace_munmap(void id, void addr, size_t len); }
	258	SYS_VMSPACE_MCONTROL = 491 // { int vmspace_mcontrol(void id, void addr, size_t len, int behav, off_t value); }
	259	SYS_VMSPACE_PREAD = 492 // { ssize_t vmspace_pread(void id, void buf, size_t nbyte, int flags, off_t offset); }
	260	SYS_VMSPACE_PWRITE = 493 // { ssize_t vmspace_pwrite(void id, const void buf, size_t nbyte, int flags, off_t offset); }
261	261	SYS_EXTEXIT = 494 // { void extexit(int how, int status, void *addr); }
262	262	SYS_LWP_CREATE = 495 // { int lwp_create(struct lwp_params *params); }
263	263	SYS_LWP_GETTID = 496 // { lwpid_t lwp_gettid(void); }
264	264	SYS_LWP_KILL = 497 // { int lwp_kill(pid_t pid, lwpid_t tid, int signum); }
265	265	SYS_LWP_RTPRIO = 498 // { int lwp_rtprio(int function, pid_t pid, lwpid_t tid, struct rtprio *rtp); }
266		SYS_PSELECT = 499 // { int pselect(int nd, fd_set in, fd_set ou, \
	266	SYS_PSELECT = 499 // { int pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *sigmask); }
267	267	SYS_STATVFS = 500 // { int statvfs(const char path, struct statvfs buf); }
268	268	SYS_FSTATVFS = 501 // { int fstatvfs(int fd, struct statvfs *buf); }
269	269	SYS_FHSTATVFS = 502 // { int fhstatvfs(const struct fhandle u_fhp, struct statvfs buf); }
270		SYS_GETVFSSTAT = 503 // { int getvfsstat(struct statfs *buf, \
	270	SYS_GETVFSSTAT = 503 // { int getvfsstat(struct statfs buf, struct statvfs vbuf, long vbufsize, int flags); }
271	271	SYS_OPENAT = 504 // { int openat(int fd, char *path, int flags, int mode); }
272		SYS_FSTATAT = 505 // { int fstatat(int fd, char *path, \
273		SYS_FCHMODAT = 506 // { int fchmodat(int fd, char *path, int mode, \
274		SYS_FCHOWNAT = 507 // { int fchownat(int fd, char *path, int uid, int gid, \
	272	SYS_FSTATAT = 505 // { int fstatat(int fd, char path, struct stat sb, int flags); }
	273	SYS_FCHMODAT = 506 // { int fchmodat(int fd, char *path, int mode, int flags); }
	274	SYS_FCHOWNAT = 507 // { int fchownat(int fd, char *path, int uid, int gid, int flags); }
275	275	SYS_UNLINKAT = 508 // { int unlinkat(int fd, char *path, int flags); }
276		SYS_FACCESSAT = 509 // { int faccessat(int fd, char *path, int amode, \
277		SYS_MQ_OPEN = 510 // { mqd_t mq_open(const char * name, int oflag, \
	276	SYS_FACCESSAT = 509 // { int faccessat(int fd, char *path, int amode, int flags); }
	277	SYS_MQ_OPEN = 510 // { mqd_t mq_open(const char * name, int oflag, mode_t mode, struct mq_attr *attr); }
278	278	SYS_MQ_CLOSE = 511 // { int mq_close(mqd_t mqdes); }
279	279	SYS_MQ_UNLINK = 512 // { int mq_unlink(const char *name); }
280		SYS_MQ_GETATTR = 513 // { int mq_getattr(mqd_t mqdes, \
281		SYS_MQ_SETATTR = 514 // { int mq_setattr(mqd_t mqdes, \
282		SYS_MQ_NOTIFY = 515 // { int mq_notify(mqd_t mqdes, \
283		SYS_MQ_SEND = 516 // { int mq_send(mqd_t mqdes, const char *msg_ptr, \
284		SYS_MQ_RECEIVE = 517 // { ssize_t mq_receive(mqd_t mqdes, char *msg_ptr, \
285		SYS_MQ_TIMEDSEND = 518 // { int mq_timedsend(mqd_t mqdes, \
286		SYS_MQ_TIMEDRECEIVE = 519 // { ssize_t mq_timedreceive(mqd_t mqdes, \
	280	SYS_MQ_GETATTR = 513 // { int mq_getattr(mqd_t mqdes, struct mq_attr *mqstat); }
	281	SYS_MQ_SETATTR = 514 // { int mq_setattr(mqd_t mqdes, const struct mq_attr mqstat, struct mq_attr omqstat); }
	282	SYS_MQ_NOTIFY = 515 // { int mq_notify(mqd_t mqdes, const struct sigevent *notification); }
	283	SYS_MQ_SEND = 516 // { int mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio); }
	284	SYS_MQ_RECEIVE = 517 // { ssize_t mq_receive(mqd_t mqdes, char msg_ptr, size_t msg_len, unsigned msg_prio); }
	285	SYS_MQ_TIMEDSEND = 518 // { int mq_timedsend(mqd_t mqdes, const char msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec abs_timeout); }
	286	SYS_MQ_TIMEDRECEIVE = 519 // { ssize_t mq_timedreceive(mqd_t mqdes, char msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout); }
287	287	SYS_IOPRIO_SET = 520 // { int ioprio_set(int which, int who, int prio); }
288	288	SYS_IOPRIO_GET = 521 // { int ioprio_get(int which, int who); }
289	289	SYS_CHROOT_KERNEL = 522 // { int chroot_kernel(char *path); }
290		SYS_RENAMEAT = 523 // { int renameat(int oldfd, char *old, int newfd, \
	290	SYS_RENAMEAT = 523 // { int renameat(int oldfd, char old, int newfd, char new); }
291	291	SYS_MKDIRAT = 524 // { int mkdirat(int fd, char *path, mode_t mode); }
292	292	SYS_MKFIFOAT = 525 // { int mkfifoat(int fd, char *path, mode_t mode); }
293		SYS_MKNODAT = 526 // { int mknodat(int fd, char *path, mode_t mode, \
294		SYS_READLINKAT = 527 // { int readlinkat(int fd, char path, char buf, \
	293	SYS_MKNODAT = 526 // { int mknodat(int fd, char *path, mode_t mode, dev_t dev); }
	294	SYS_READLINKAT = 527 // { int readlinkat(int fd, char path, char buf, size_t bufsize); }
295	295	SYS_SYMLINKAT = 528 // { int symlinkat(char path1, int fd, char path2); }
296	296	SYS_SWAPOFF = 529 // { int swapoff(char *name); }
297		SYS_VQUOTACTL = 530 // { int vquotactl(const char *path, \
298		SYS_LINKAT = 531 // { int linkat(int fd1, char *path1, int fd2, \
	297	SYS_VQUOTACTL = 530 // { int vquotactl(const char path, struct plistref pref); }
	298	SYS_LINKAT = 531 // { int linkat(int fd1, char path1, int fd2, char path2, int flags); }
299	299	SYS_EACCESS = 532 // { int eaccess(char *path, int flags); }
300	300	SYS_LPATHCONF = 533 // { int lpathconf(char *path, int name); }
301	301	SYS_VMM_GUEST_CTL = 534 // { int vmm_guest_ctl(int op, struct vmm_guest_options *options); }

307	307	SYS_FUTIMENS = 540 // { int futimens(int fd, const struct timespec *ts); }
308	308	SYS_ACCEPT4 = 541 // { int accept4(int s, caddr_t name, int *anamelen, int flags); }
309	309	SYS_LWP_SETNAME = 542 // { int lwp_setname(lwpid_t tid, const char *name); }
310		SYS_PPOLL = 543 // { int ppoll(struct pollfd *fds, u_int nfds, \
	310	SYS_PPOLL = 543 // { int ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *sigmask); }
311	311	SYS_LWP_SETAFFINITY = 544 // { int lwp_setaffinity(pid_t pid, lwpid_t tid, const cpumask_t *mask); }
312	312	SYS_LWP_GETAFFINITY = 545 // { int lwp_getaffinity(pid_t pid, lwpid_t tid, cpumask_t *mask); }
313	313	SYS_LWP_CREATE2 = 546 // { int lwp_create2(struct lwp_params params, const cpumask_t mask); }

+226

-226

unix/zsysnum_freebsd_386.go less more

0		// mksysnum_freebsd.pl
	0	// go run mksysnum.go http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build 386,freebsd

6	6
7	7	const (
8	8	// SYS_NOSYS = 0; // { int nosys(void); } syscall nosys_args int
9		SYS_EXIT = 1 // { void sys_exit(int rval); } exit \
	9	SYS_EXIT = 1 // { void sys_exit(int rval); } exit sys_exit_args void
10	10	SYS_FORK = 2 // { int fork(void); }
11		SYS_READ = 3 // { ssize_t read(int fd, void *buf, \
12		SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, \
	11	SYS_READ = 3 // { ssize_t read(int fd, void *buf, size_t nbyte); }
	12	SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, size_t nbyte); }
13	13	SYS_OPEN = 5 // { int open(char *path, int flags, int mode); }
14	14	SYS_CLOSE = 6 // { int close(int fd); }
15		SYS_WAIT4 = 7 // { int wait4(int pid, int *status, \
	15	SYS_WAIT4 = 7 // { int wait4(int pid, int status, int options, struct rusage rusage); }
16	16	SYS_LINK = 9 // { int link(char path, char link); }
17	17	SYS_UNLINK = 10 // { int unlink(char *path); }
18	18	SYS_CHDIR = 12 // { int chdir(char *path); }

20	20	SYS_MKNOD = 14 // { int mknod(char *path, int mode, int dev); }
21	21	SYS_CHMOD = 15 // { int chmod(char *path, int mode); }
22	22	SYS_CHOWN = 16 // { int chown(char *path, int uid, int gid); }
23		SYS_OBREAK = 17 // { int obreak(char *nsize); } break \
	23	SYS_OBREAK = 17 // { int obreak(char *nsize); } break obreak_args int
24	24	SYS_GETPID = 20 // { pid_t getpid(void); }
25		SYS_MOUNT = 21 // { int mount(char type, char path, \
	25	SYS_MOUNT = 21 // { int mount(char type, char path, int flags, caddr_t data); }
26	26	SYS_UNMOUNT = 22 // { int unmount(char *path, int flags); }
27	27	SYS_SETUID = 23 // { int setuid(uid_t uid); }
28	28	SYS_GETUID = 24 // { uid_t getuid(void); }
29	29	SYS_GETEUID = 25 // { uid_t geteuid(void); }
30		SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, \
31		SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, \
32		SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, \
33		SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, \
34		SYS_ACCEPT = 30 // { int accept(int s, \
35		SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \
36		SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \
	30	SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, int data); }
	31	SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, int flags); }
	32	SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, int flags); }
	33	SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, int flags, struct sockaddr * __restrict from, __socklen_t * __restrict fromlenaddr); }
	34	SYS_ACCEPT = 30 // { int accept(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen); }
	35	SYS_GETPEERNAME = 31 // { int getpeername(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
	36	SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
37	37	SYS_ACCESS = 33 // { int access(char *path, int amode); }
38	38	SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); }
39	39	SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); }

43	43	SYS_DUP = 41 // { int dup(u_int fd); }
44	44	SYS_PIPE = 42 // { int pipe(void); }
45	45	SYS_GETEGID = 43 // { gid_t getegid(void); }
46		SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, \
47		SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, \
	46	SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, size_t offset, u_int scale); }
	47	SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, int pid); }
48	48	SYS_GETGID = 47 // { gid_t getgid(void); }
49		SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int \
	49	SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int namelen); }
50	50	SYS_SETLOGIN = 50 // { int setlogin(char *namebuf); }
51	51	SYS_ACCT = 51 // { int acct(char *path); }
52		SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t *ss, \
53		SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, \
	52	SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t ss, stack_t oss); }
	53	SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, caddr_t data); }
54	54	SYS_REBOOT = 55 // { int reboot(int opt); }
55	55	SYS_REVOKE = 56 // { int revoke(char *path); }
56	56	SYS_SYMLINK = 57 // { int symlink(char path, char link); }
57		SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, \
58		SYS_EXECVE = 59 // { int execve(char fname, char *argv, \
59		SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args \
	57	SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, size_t count); }
	58	SYS_EXECVE = 59 // { int execve(char fname, char argv, char *envv); }
	59	SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args int
60	60	SYS_CHROOT = 61 // { int chroot(char *path); }
61		SYS_MSYNC = 65 // { int msync(void *addr, size_t len, \
	61	SYS_MSYNC = 65 // { int msync(void *addr, size_t len, int flags); }
62	62	SYS_VFORK = 66 // { int vfork(void); }
63	63	SYS_SBRK = 69 // { int sbrk(int incr); }
64	64	SYS_SSTK = 70 // { int sstk(int incr); }
65		SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise \
	65	SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise ovadvise_args int
66	66	SYS_MUNMAP = 73 // { int munmap(void *addr, size_t len); }
67		SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, \
68		SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, \
69		SYS_MINCORE = 78 // { int mincore(const void *addr, size_t len, \
70		SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, \
71		SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, \
	67	SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, int prot); }
	68	SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, int behav); }
	69	SYS_MINCORE = 78 // { int mincore(const void addr, size_t len, char vec); }
	70	SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, gid_t *gidset); }
	71	SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, gid_t *gidset); }
72	72	SYS_GETPGRP = 81 // { int getpgrp(void); }
73	73	SYS_SETPGID = 82 // { int setpgid(int pid, int pgid); }
74		SYS_SETITIMER = 83 // { int setitimer(u_int which, struct \
	74	SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval itv, struct itimerval oitv); }
75	75	SYS_SWAPON = 85 // { int swapon(char *name); }
76		SYS_GETITIMER = 86 // { int getitimer(u_int which, \
	76	SYS_GETITIMER = 86 // { int getitimer(u_int which, struct itimerval *itv); }
77	77	SYS_GETDTABLESIZE = 89 // { int getdtablesize(void); }
78	78	SYS_DUP2 = 90 // { int dup2(u_int from, u_int to); }
79	79	SYS_FCNTL = 92 // { int fcntl(int fd, int cmd, long arg); }
80		SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, \
	80	SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
81	81	SYS_FSYNC = 95 // { int fsync(int fd); }
82		SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, \
83		SYS_SOCKET = 97 // { int socket(int domain, int type, \
84		SYS_CONNECT = 98 // { int connect(int s, caddr_t name, \
	82	SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, int prio); }
	83	SYS_SOCKET = 97 // { int socket(int domain, int type, int protocol); }
	84	SYS_CONNECT = 98 // { int connect(int s, caddr_t name, int namelen); }
85	85	SYS_GETPRIORITY = 100 // { int getpriority(int which, int who); }
86		SYS_BIND = 104 // { int bind(int s, caddr_t name, \
87		SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, \
	86	SYS_BIND = 104 // { int bind(int s, caddr_t name, int namelen); }
	87	SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, caddr_t val, int valsize); }
88	88	SYS_LISTEN = 106 // { int listen(int s, int backlog); }
89		SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval *tp, \
90		SYS_GETRUSAGE = 117 // { int getrusage(int who, \
91		SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, \
92		SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, \
93		SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, \
94		SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval *tv, \
	89	SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval tp, struct timezone tzp); }
	90	SYS_GETRUSAGE = 117 // { int getrusage(int who, struct rusage *rusage); }
	91	SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, caddr_t val, int *avalsize); }
	92	SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
	93	SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
	94	SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval tv, struct timezone tzp); }
95	95	SYS_FCHOWN = 123 // { int fchown(int fd, int uid, int gid); }
96	96	SYS_FCHMOD = 124 // { int fchmod(int fd, int mode); }
97	97	SYS_SETREUID = 126 // { int setreuid(int ruid, int euid); }

99	99	SYS_RENAME = 128 // { int rename(char from, char to); }
100	100	SYS_FLOCK = 131 // { int flock(int fd, int how); }
101	101	SYS_MKFIFO = 132 // { int mkfifo(char *path, int mode); }
102		SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, \
	102	SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen); }
103	103	SYS_SHUTDOWN = 134 // { int shutdown(int s, int how); }
104		SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, \
	104	SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, int *rsv); }
105	105	SYS_MKDIR = 136 // { int mkdir(char *path, int mode); }
106	106	SYS_RMDIR = 137 // { int rmdir(char *path); }
107		SYS_UTIMES = 138 // { int utimes(char *path, \
108		SYS_ADJTIME = 140 // { int adjtime(struct timeval *delta, \
	107	SYS_UTIMES = 138 // { int utimes(char path, struct timeval tptr); }
	108	SYS_ADJTIME = 140 // { int adjtime(struct timeval delta, struct timeval olddelta); }
109	109	SYS_SETSID = 147 // { int setsid(void); }
110		SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, \
	110	SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, caddr_t arg); }
111	111	SYS_NLM_SYSCALL = 154 // { int nlm_syscall(int debug_level, int grace_period, int addr_count, char **addrs); }
112	112	SYS_NFSSVC = 155 // { int nfssvc(int flag, caddr_t argp); }
113		SYS_LGETFH = 160 // { int lgetfh(char *fname, \
114		SYS_GETFH = 161 // { int getfh(char *fname, \
	113	SYS_LGETFH = 160 // { int lgetfh(char fname, struct fhandle fhp); }
	114	SYS_GETFH = 161 // { int getfh(char fname, struct fhandle fhp); }
115	115	SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); }
116		SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \
117		SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, \
118		SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, \
119		SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, \
120		SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, \
121		SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, \
	116	SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, struct rtprio *rtp); }
	117	SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, int a5); }
	118	SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, int a5, int a6); }
	119	SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); }
	120	SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	121	SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
122	122	SYS_SETFIB = 175 // { int setfib(int fibnum); }
123	123	SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); }
124	124	SYS_SETGID = 181 // { int setgid(gid_t gid); }

129	129	SYS_LSTAT = 190 // { int lstat(char path, struct stat ub); }
130	130	SYS_PATHCONF = 191 // { int pathconf(char *path, int name); }
131	131	SYS_FPATHCONF = 192 // { int fpathconf(int fd, int name); }
132		SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, \
133		SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, \
134		SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char *buf, \
135		SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, \
136		SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, \
137		SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, \
138		SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, \
139		SYS___SYSCTL = 202 // { int __sysctl(int *name, u_int namelen, \
	132	SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, struct rlimit *rlp); } getrlimit __getrlimit_args int
	133	SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, struct rlimit *rlp); } setrlimit __setrlimit_args int
	134	SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char buf, u_int count, long basep); }
	135	SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, size_t len, int prot, int flags, int fd, int pad, off_t pos); }
	136	SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, off_t offset, int whence); }
	137	SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, off_t length); }
	138	SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, off_t length); }
	139	SYS___SYSCTL = 202 // { int __sysctl(int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); } __sysctl sysctl_args int
140	140	SYS_MLOCK = 203 // { int mlock(const void *addr, size_t len); }
141	141	SYS_MUNLOCK = 204 // { int munlock(const void *addr, size_t len); }
142	142	SYS_UNDELETE = 205 // { int undelete(char *path); }
143	143	SYS_FUTIMES = 206 // { int futimes(int fd, struct timeval *tptr); }
144	144	SYS_GETPGID = 207 // { int getpgid(pid_t pid); }
145		SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, \
146		SYS_SEMGET = 221 // { int semget(key_t key, int nsems, \
147		SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, \
	145	SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, int timeout); }
	146	SYS_SEMGET = 221 // { int semget(key_t key, int nsems, int semflg); }
	147	SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, size_t nsops); }
148	148	SYS_MSGGET = 225 // { int msgget(key_t key, int msgflg); }
149		SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, \
150		SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, \
151		SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, \
	149	SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	150	SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	151	SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, int shmflg); }
152	152	SYS_SHMDT = 230 // { int shmdt(const void *shmaddr); }
153		SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, \
154		SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, \
155		SYS_CLOCK_SETTIME = 233 // { int clock_settime( \
156		SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, \
157		SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, \
	153	SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, int shmflg); }
	154	SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, struct timespec *tp); }
	155	SYS_CLOCK_SETTIME = 233 // { int clock_settime( clockid_t clock_id, const struct timespec *tp); }
	156	SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, struct timespec *tp); }
	157	SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, struct sigevent evp, int timerid); }
158	158	SYS_KTIMER_DELETE = 236 // { int ktimer_delete(int timerid); }
159		SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, \
160		SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct \
	159	SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, const struct itimerspec value, struct itimerspec ovalue); }
	160	SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct itimerspec *value); }
161	161	SYS_KTIMER_GETOVERRUN = 239 // { int ktimer_getoverrun(int timerid); }
162		SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec *rqtp, \
	162	SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec rqtp, struct timespec rmtp); }
163	163	SYS_FFCLOCK_GETCOUNTER = 241 // { int ffclock_getcounter(ffcounter *ffcount); }
164		SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( \
165		SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( \
166		SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,\
	164	SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( struct ffclock_estimate *cest); }
	165	SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( struct ffclock_estimate *cest); }
	166	SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,int which, clockid_t *clock_id); }
167	167	SYS_NTP_GETTIME = 248 // { int ntp_gettime(struct ntptimeval *ntvp); }
168		SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, \
	168	SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, int inherit); }
169	169	SYS_RFORK = 251 // { int rfork(int flags); }
170		SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, \
	170	SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, u_int nfds, int timeout); }
171	171	SYS_ISSETUGID = 253 // { int issetugid(void); }
172	172	SYS_LCHOWN = 254 // { int lchown(char *path, int uid, int gid); }
173	173	SYS_AIO_READ = 255 // { int aio_read(struct aiocb *aiocbp); }
174	174	SYS_AIO_WRITE = 256 // { int aio_write(struct aiocb *aiocbp); }
175		SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, \
176		SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, \
	175	SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, struct aiocb * const acb_list, int nent, struct sigevent sig); }
	176	SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, size_t count); }
177	177	SYS_LCHMOD = 274 // { int lchmod(char *path, mode_t mode); }
178		SYS_LUTIMES = 276 // { int lutimes(char *path, \
	178	SYS_LUTIMES = 276 // { int lutimes(char path, struct timeval tptr); }
179	179	SYS_NSTAT = 278 // { int nstat(char path, struct nstat ub); }
180	180	SYS_NFSTAT = 279 // { int nfstat(int fd, struct nstat *sb); }
181	181	SYS_NLSTAT = 280 // { int nlstat(char path, struct nstat ub); }
182		SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, \
183		SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, \
184		SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, \
185		SYS_FHSTAT = 299 // { int fhstat(const struct fhandle *u_fhp, \
	182	SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	183	SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	184	SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, int flags); }
	185	SYS_FHSTAT = 299 // { int fhstat(const struct fhandle u_fhp, struct stat sb); }
186	186	SYS_MODNEXT = 300 // { int modnext(int modid); }
187		SYS_MODSTAT = 301 // { int modstat(int modid, \
	187	SYS_MODSTAT = 301 // { int modstat(int modid, struct module_stat *stat); }
188	188	SYS_MODFNEXT = 302 // { int modfnext(int modid); }
189	189	SYS_MODFIND = 303 // { int modfind(const char *name); }
190	190	SYS_KLDLOAD = 304 // { int kldload(const char *file); }
191	191	SYS_KLDUNLOAD = 305 // { int kldunload(int fileid); }
192	192	SYS_KLDFIND = 306 // { int kldfind(const char *file); }
193	193	SYS_KLDNEXT = 307 // { int kldnext(int fileid); }
194		SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct \
	194	SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct kld_file_stat* stat); }
195	195	SYS_KLDFIRSTMOD = 309 // { int kldfirstmod(int fileid); }
196	196	SYS_GETSID = 310 // { int getsid(pid_t pid); }
197		SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, \
198		SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, \
	197	SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	198	SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
199	199	SYS_AIO_RETURN = 314 // { int aio_return(struct aiocb *aiocbp); }
200		SYS_AIO_SUSPEND = 315 // { int aio_suspend( \
201		SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, \
	200	SYS_AIO_SUSPEND = 315 // { int aio_suspend( struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
	201	SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, struct aiocb *aiocbp); }
202	202	SYS_AIO_ERROR = 317 // { int aio_error(struct aiocb *aiocbp); }
203	203	SYS_OAIO_READ = 318 // { int oaio_read(struct oaiocb *aiocbp); }
204	204	SYS_OAIO_WRITE = 319 // { int oaio_write(struct oaiocb *aiocbp); }
205		SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, \
	205	SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, struct oaiocb * const acb_list, int nent, struct osigevent sig); }
206	206	SYS_YIELD = 321 // { int yield(void); }
207	207	SYS_MLOCKALL = 324 // { int mlockall(int how); }
208	208	SYS_MUNLOCKALL = 325 // { int munlockall(void); }
209	209	SYS___GETCWD = 326 // { int __getcwd(char *buf, u_int buflen); }
210		SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, \
211		SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct \
212		SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int \
	210	SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, const struct sched_param *param); }
	211	SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct sched_param *param); }
	212	SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
213	213	SYS_SCHED_GETSCHEDULER = 330 // { int sched_getscheduler (pid_t pid); }
214	214	SYS_SCHED_YIELD = 331 // { int sched_yield (void); }
215	215	SYS_SCHED_GET_PRIORITY_MAX = 332 // { int sched_get_priority_max (int policy); }
216	216	SYS_SCHED_GET_PRIORITY_MIN = 333 // { int sched_get_priority_min (int policy); }
217		SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, \
	217	SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
218	218	SYS_UTRACE = 335 // { int utrace(const void *addr, size_t len); }
219		SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, \
	219	SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, void *data); }
220	220	SYS_JAIL = 338 // { int jail(struct jail *jail); }
221		SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, \
	221	SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t set, sigset_t oset); }
222	222	SYS_SIGSUSPEND = 341 // { int sigsuspend(const sigset_t *sigmask); }
223	223	SYS_SIGPENDING = 343 // { int sigpending(sigset_t *set); }
224		SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t *set, \
225		SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t *set, \
226		SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char *path, \
227		SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char *path, \
228		SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, \
229		SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, \
230		SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, \
231		SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, \
232		SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \
233		SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \
234		SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \
235		SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \
236		SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \
237		SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \
238		SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( \
239		SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, \
240		SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, \
	224	SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t set, siginfo_t info, const struct timespec *timeout); }
	225	SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t set, siginfo_t info); }
	226	SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char path, acl_type_t type, struct acl aclp); }
	227	SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char path, acl_type_t type, struct acl aclp); }
	228	SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp); }
	229	SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp); }
	230	SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, acl_type_t type); }
	231	SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, acl_type_t type); }
	232	SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char path, acl_type_t type, struct acl aclp); }
	233	SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp); }
	234	SYS_EXTATTRCTL = 355 // { int extattrctl(const char path, int cmd, const char filename, int attrnamespace, const char *attrname); }
	235	SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	236	SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	237	SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char path, int attrnamespace, const char attrname); }
	238	SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( struct aiocb *aiocbp, struct timespec timeout); }
	239	SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	240	SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
241	241	SYS_KQUEUE = 362 // { int kqueue(void); }
242		SYS_KEVENT = 363 // { int kevent(int fd, \
243		SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \
244		SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \
245		SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \
	242	SYS_KEVENT = 363 // { int kevent(int fd, struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
	243	SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	244	SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	245	SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, int attrnamespace, const char *attrname); }
246	246	SYS___SETUGID = 374 // { int __setugid(int flag); }
247	247	SYS_EACCESS = 376 // { int eaccess(char *path, int amode); }
248		SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, \
	248	SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, unsigned int iovcnt, int flags); }
249	249	SYS___MAC_GET_PROC = 384 // { int __mac_get_proc(struct mac *mac_p); }
250	250	SYS___MAC_SET_PROC = 385 // { int __mac_set_proc(struct mac *mac_p); }
251		SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, \
252		SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char *path_p, \
253		SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \
254		SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \
255		SYS_KENV = 390 // { int kenv(int what, const char *name, \
256		SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \
257		SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \
258		SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \
259		SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \
260		SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, \
261		SYS_STATFS = 396 // { int statfs(char *path, \
	251	SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, struct mac *mac_p); }
	252	SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char path_p, struct mac mac_p); }
	253	SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, struct mac *mac_p); }
	254	SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char path_p, struct mac mac_p); }
	255	SYS_KENV = 390 // { int kenv(int what, const char name, char value, int len); }
	256	SYS_LCHFLAGS = 391 // { int lchflags(const char *path, u_long flags); }
	257	SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, int count); }
	258	SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, struct sf_hdtr hdtr, off_t sbytes, int flags); }
	259	SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char policy, int call, void arg); }
	260	SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, long bufsize, int flags); }
	261	SYS_STATFS = 396 // { int statfs(char path, struct statfs buf); }
262	262	SYS_FSTATFS = 397 // { int fstatfs(int fd, struct statfs *buf); }
263		SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle *u_fhp, \
	263	SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle u_fhp, struct statfs buf); }
264	264	SYS_KSEM_CLOSE = 400 // { int ksem_close(semid_t id); }
265	265	SYS_KSEM_POST = 401 // { int ksem_post(semid_t id); }
266	266	SYS_KSEM_WAIT = 402 // { int ksem_wait(semid_t id); }
267	267	SYS_KSEM_TRYWAIT = 403 // { int ksem_trywait(semid_t id); }
268		SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, \
269		SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t *idp, \
	268	SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, unsigned int value); }
	269	SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t idp, const char name, int oflag, mode_t mode, unsigned int value); }
270	270	SYS_KSEM_UNLINK = 406 // { int ksem_unlink(const char *name); }
271	271	SYS_KSEM_GETVALUE = 407 // { int ksem_getvalue(semid_t id, int *val); }
272	272	SYS_KSEM_DESTROY = 408 // { int ksem_destroy(semid_t id); }
273		SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \
274		SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \
275		SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \
276		SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \
277		SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \
278		SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \
279		SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char *argv, \
280		SYS_SIGACTION = 416 // { int sigaction(int sig, \
281		SYS_SIGRETURN = 417 // { int sigreturn( \
	273	SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, struct mac *mac_p); }
	274	SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char path_p, struct mac mac_p); }
	275	SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char path_p, struct mac mac_p); }
	276	SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	277	SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	278	SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( const char path, int attrnamespace, const char attrname); }
	279	SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char argv, char envv, struct mac mac_p); }
	280	SYS_SIGACTION = 416 // { int sigaction(int sig, const struct sigaction act, struct sigaction oact); }
	281	SYS_SIGRETURN = 417 // { int sigreturn( const struct __ucontext *sigcntxp); }
282	282	SYS_GETCONTEXT = 421 // { int getcontext(struct __ucontext *ucp); }
283		SYS_SETCONTEXT = 422 // { int setcontext( \
284		SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext *oucp, \
	283	SYS_SETCONTEXT = 422 // { int setcontext( const struct __ucontext *ucp); }
	284	SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext oucp, const struct __ucontext ucp); }
285	285	SYS_SWAPOFF = 424 // { int swapoff(const char *name); }
286		SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char *path, \
287		SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char *path, \
288		SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, \
289		SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char *path, \
290		SYS_SIGWAIT = 429 // { int sigwait(const sigset_t *set, \
291		SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, \
	286	SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char path, acl_type_t type, struct acl aclp); }
	287	SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char path, acl_type_t type, struct acl aclp); }
	288	SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, acl_type_t type); }
	289	SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char path, acl_type_t type, struct acl aclp); }
	290	SYS_SIGWAIT = 429 // { int sigwait(const sigset_t set, int sig); }
	291	SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, int flags); }
292	292	SYS_THR_EXIT = 431 // { void thr_exit(long *state); }
293	293	SYS_THR_SELF = 432 // { int thr_self(long *id); }
294	294	SYS_THR_KILL = 433 // { int thr_kill(long id, int sig); }
295	295	SYS__UMTX_LOCK = 434 // { int _umtx_lock(struct umtx *umtx); }
296	296	SYS__UMTX_UNLOCK = 435 // { int _umtx_unlock(struct umtx *umtx); }
297	297	SYS_JAIL_ATTACH = 436 // { int jail_attach(int jid); }
298		SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, \
299		SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( \
300		SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( \
301		SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, \
302		SYS_THR_SUSPEND = 442 // { int thr_suspend( \
	298	SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes); }
	299	SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( const char path, int attrnamespace, void data, size_t nbytes); }
	300	SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( const char path, int attrnamespace, void data, size_t nbytes); }
	301	SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, const struct timespec *abstime); }
	302	SYS_THR_SUSPEND = 442 // { int thr_suspend( const struct timespec *timeout); }
303	303	SYS_THR_WAKE = 443 // { int thr_wake(long id); }
304	304	SYS_KLDUNLOADF = 444 // { int kldunloadf(int fileid, int flags); }
305		SYS_AUDIT = 445 // { int audit(const void *record, \
306		SYS_AUDITON = 446 // { int auditon(int cmd, void *data, \
	305	SYS_AUDIT = 445 // { int audit(const void *record, u_int length); }
	306	SYS_AUDITON = 446 // { int auditon(int cmd, void *data, u_int length); }
307	307	SYS_GETAUID = 447 // { int getauid(uid_t *auid); }
308	308	SYS_SETAUID = 448 // { int setauid(uid_t *auid); }
309	309	SYS_GETAUDIT = 449 // { int getaudit(struct auditinfo *auditinfo); }
310	310	SYS_SETAUDIT = 450 // { int setaudit(struct auditinfo *auditinfo); }
311		SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( \
312		SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( \
	311	SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
	312	SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
313	313	SYS_AUDITCTL = 453 // { int auditctl(char *path); }
314		SYS__UMTX_OP = 454 // { int _umtx_op(void *obj, int op, \
315		SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, \
	314	SYS__UMTX_OP = 454 // { int _umtx_op(void obj, int op, u_long val, void uaddr1, void *uaddr2); }
	315	SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, int param_size); }
316	316	SYS_SIGQUEUE = 456 // { int sigqueue(pid_t pid, int signum, void *value); }
317		SYS_KMQ_OPEN = 457 // { int kmq_open(const char *path, int flags, \
318		SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, \
319		SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, \
320		SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, \
321		SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, \
	317	SYS_KMQ_OPEN = 457 // { int kmq_open(const char path, int flags, mode_t mode, const struct mq_attr attr); }
	318	SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, const struct mq_attr attr, struct mq_attr oattr); }
	319	SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, char msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout); }
	320	SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, const char msg_ptr, size_t msg_len,unsigned msg_prio, const struct timespec abs_timeout);}
	321	SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, const struct sigevent *sigev); }
322	322	SYS_KMQ_UNLINK = 462 // { int kmq_unlink(const char *path); }
323	323	SYS_ABORT2 = 463 // { int abort2(const char why, int nargs, void *args); }
324	324	SYS_THR_SET_NAME = 464 // { int thr_set_name(long id, const char *name); }
325	325	SYS_AIO_FSYNC = 465 // { int aio_fsync(int op, struct aiocb *aiocbp); }
326		SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, \
	326	SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp); }
327	327	SYS_SCTP_PEELOFF = 471 // { int sctp_peeloff(int sd, uint32_t name); }
328		SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, \
329		SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec *iov, int iovlen, \
330		SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec *iov, int iovlen, \
331		SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, \
332		SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, \
333		SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, \
334		SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, \
	328	SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo *sinfo, int flags); }
	329	SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec iov, int iovlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo sinfo, int flags); }
	330	SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec iov, int iovlen, struct sockaddr from, __socklen_t fromlenaddr, struct sctp_sndrcvinfo sinfo, int *msg_flags); }
	331	SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset); }
	332	SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset); }
	333	SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos); }
	334	SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, int whence); }
335	335	SYS_TRUNCATE = 479 // { int truncate(char *path, off_t length); }
336	336	SYS_FTRUNCATE = 480 // { int ftruncate(int fd, off_t length); }
337	337	SYS_THR_KILL2 = 481 // { int thr_kill2(pid_t pid, long id, int sig); }
338		SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, \
	338	SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, mode_t mode); }
339	339	SYS_SHM_UNLINK = 483 // { int shm_unlink(const char *path); }
340	340	SYS_CPUSET = 484 // { int cpuset(cpusetid_t *setid); }
341		SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, \
342		SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, \
343		SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, \
344		SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, \
345		SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, \
346		SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, \
347		SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, \
348		SYS_FEXECVE = 492 // { int fexecve(int fd, char **argv, \
349		SYS_FSTATAT = 493 // { int fstatat(int fd, char *path, \
350		SYS_FUTIMESAT = 494 // { int futimesat(int fd, char *path, \
351		SYS_LINKAT = 495 // { int linkat(int fd1, char *path1, int fd2, \
	341	SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, cpusetid_t setid); }
	342	SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, cpuwhich_t which, id_t id, cpusetid_t *setid); }
	343	SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, cpuset_t *mask); }
	344	SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, const cpuset_t *mask); }
	345	SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, int flag); }
	346	SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, int flag); }
	347	SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, gid_t gid, int flag); }
	348	SYS_FEXECVE = 492 // { int fexecve(int fd, char argv, char envv); }
	349	SYS_FSTATAT = 493 // { int fstatat(int fd, char path, struct stat buf, int flag); }
	350	SYS_FUTIMESAT = 494 // { int futimesat(int fd, char path, struct timeval times); }
	351	SYS_LINKAT = 495 // { int linkat(int fd1, char path1, int fd2, char path2, int flag); }
352	352	SYS_MKDIRAT = 496 // { int mkdirat(int fd, char *path, mode_t mode); }
353	353	SYS_MKFIFOAT = 497 // { int mkfifoat(int fd, char *path, mode_t mode); }
354		SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, \
355		SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, \
356		SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, \
357		SYS_RENAMEAT = 501 // { int renameat(int oldfd, char *old, int newfd, \
358		SYS_SYMLINKAT = 502 // { int symlinkat(char *path1, int fd, \
	354	SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, dev_t dev); }
	355	SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, mode_t mode); }
	356	SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, size_t bufsize); }
	357	SYS_RENAMEAT = 501 // { int renameat(int oldfd, char old, int newfd, char new); }
	358	SYS_SYMLINKAT = 502 // { int symlinkat(char path1, int fd, char path2); }
359	359	SYS_UNLINKAT = 503 // { int unlinkat(int fd, char *path, int flag); }
360	360	SYS_POSIX_OPENPT = 504 // { int posix_openpt(int flags); }
361	361	SYS_GSSD_SYSCALL = 505 // { int gssd_syscall(char *path); }
362		SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, \
363		SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, \
	362	SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, unsigned int iovcnt, int flags); }
	363	SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, unsigned int iovcnt, int flags); }
364	364	SYS_JAIL_REMOVE = 508 // { int jail_remove(int jid); }
365	365	SYS_CLOSEFROM = 509 // { int closefrom(int lowfd); }
366		SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, \
367		SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, \
368		SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, \
	366	SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, int cmd, union semun *arg); }
	367	SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, struct msqid_ds *buf); }
	368	SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, struct shmid_ds *buf); }
369	369	SYS_LPATHCONF = 513 // { int lpathconf(char *path, int name); }
370		SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, \
	370	SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, int fd, cap_rights_t *rightsp); }
371	371	SYS_CAP_ENTER = 516 // { int cap_enter(void); }
372	372	SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }
373	373	SYS_PDFORK = 518 // { int pdfork(int *fdp, int flags); }
374	374	SYS_PDKILL = 519 // { int pdkill(int fd, int signum); }
375	375	SYS_PDGETPID = 520 // { int pdgetpid(int fd, pid_t *pidp); }
376		SYS_PSELECT = 522 // { int pselect(int nd, fd_set *in, \
377		SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, \
	376	SYS_PSELECT = 522 // { int pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *sm); }
	377	SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, size_t namelen); }
378	378	SYS_SETLOGINCLASS = 524 // { int setloginclass(const char *namebuf); }
379		SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void *inbufp, \
380		SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void *inbufp, \
381		SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void *inbufp, \
382		SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void *inbufp, \
383		SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \
384		SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \
385		SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \
386		SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \
387		SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, \
388		SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, \
389		SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, \
390		SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, \
391		SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, \
392		SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \
393		SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \
394		SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \
395		SYS_ACCEPT4 = 541 // { int accept4(int s, \
	379	SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	380	SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	381	SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	382	SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	383	SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	384	SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, off_t offset, off_t len); }
	385	SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, off_t len, int advice); }
	386	SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, int status, int options, struct __wrusage wrusage, siginfo_t *info); }
	387	SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, cap_rights_t *rightsp); }
	388	SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, const u_long *cmds, size_t ncmds); }
	389	SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, u_long *cmds, size_t maxcmds); }
	390	SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, uint32_t fcntlrights); }
	391	SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, uint32_t *fcntlrightsp); }
	392	SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, int namelen); }
	393	SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, int namelen); }
	394	SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, u_long flags, int atflag); }
	395	SYS_ACCEPT4 = 541 // { int accept4(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen, int flags); }
396	396	SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); }
397	397	SYS_AIO_MLOCK = 543 // { int aio_mlock(struct aiocb *aiocbp); }
398		SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \
399		SYS_PPOLL = 545 // { int ppoll(struct pollfd *fds, u_int nfds, \
400		SYS_FUTIMENS = 546 // { int futimens(int fd, \
401		SYS_UTIMENSAT = 547 // { int utimensat(int fd, \
	398	SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, int com, void *data); }
	399	SYS_PPOLL = 545 // { int ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *set); }
	400	SYS_FUTIMENS = 546 // { int futimens(int fd, struct timespec *times); }
	401	SYS_UTIMENSAT = 547 // { int utimensat(int fd, char path, struct timespec times, int flag); }
402	402	)

+226

-226

unix/zsysnum_freebsd_amd64.go less more

0		// mksysnum_freebsd.pl
	0	// go run mksysnum.go http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build amd64,freebsd

6	6
7	7	const (
8	8	// SYS_NOSYS = 0; // { int nosys(void); } syscall nosys_args int
9		SYS_EXIT = 1 // { void sys_exit(int rval); } exit \
	9	SYS_EXIT = 1 // { void sys_exit(int rval); } exit sys_exit_args void
10	10	SYS_FORK = 2 // { int fork(void); }
11		SYS_READ = 3 // { ssize_t read(int fd, void *buf, \
12		SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, \
	11	SYS_READ = 3 // { ssize_t read(int fd, void *buf, size_t nbyte); }
	12	SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, size_t nbyte); }
13	13	SYS_OPEN = 5 // { int open(char *path, int flags, int mode); }
14	14	SYS_CLOSE = 6 // { int close(int fd); }
15		SYS_WAIT4 = 7 // { int wait4(int pid, int *status, \
	15	SYS_WAIT4 = 7 // { int wait4(int pid, int status, int options, struct rusage rusage); }
16	16	SYS_LINK = 9 // { int link(char path, char link); }
17	17	SYS_UNLINK = 10 // { int unlink(char *path); }
18	18	SYS_CHDIR = 12 // { int chdir(char *path); }

20	20	SYS_MKNOD = 14 // { int mknod(char *path, int mode, int dev); }
21	21	SYS_CHMOD = 15 // { int chmod(char *path, int mode); }
22	22	SYS_CHOWN = 16 // { int chown(char *path, int uid, int gid); }
23		SYS_OBREAK = 17 // { int obreak(char *nsize); } break \
	23	SYS_OBREAK = 17 // { int obreak(char *nsize); } break obreak_args int
24	24	SYS_GETPID = 20 // { pid_t getpid(void); }
25		SYS_MOUNT = 21 // { int mount(char type, char path, \
	25	SYS_MOUNT = 21 // { int mount(char type, char path, int flags, caddr_t data); }
26	26	SYS_UNMOUNT = 22 // { int unmount(char *path, int flags); }
27	27	SYS_SETUID = 23 // { int setuid(uid_t uid); }
28	28	SYS_GETUID = 24 // { uid_t getuid(void); }
29	29	SYS_GETEUID = 25 // { uid_t geteuid(void); }
30		SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, \
31		SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, \
32		SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, \
33		SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, \
34		SYS_ACCEPT = 30 // { int accept(int s, \
35		SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \
36		SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \
	30	SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, int data); }
	31	SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, int flags); }
	32	SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, int flags); }
	33	SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, int flags, struct sockaddr * __restrict from, __socklen_t * __restrict fromlenaddr); }
	34	SYS_ACCEPT = 30 // { int accept(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen); }
	35	SYS_GETPEERNAME = 31 // { int getpeername(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
	36	SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
37	37	SYS_ACCESS = 33 // { int access(char *path, int amode); }
38	38	SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); }
39	39	SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); }

43	43	SYS_DUP = 41 // { int dup(u_int fd); }
44	44	SYS_PIPE = 42 // { int pipe(void); }
45	45	SYS_GETEGID = 43 // { gid_t getegid(void); }
46		SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, \
47		SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, \
	46	SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, size_t offset, u_int scale); }
	47	SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, int pid); }
48	48	SYS_GETGID = 47 // { gid_t getgid(void); }
49		SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int \
	49	SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int namelen); }
50	50	SYS_SETLOGIN = 50 // { int setlogin(char *namebuf); }
51	51	SYS_ACCT = 51 // { int acct(char *path); }
52		SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t *ss, \
53		SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, \
	52	SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t ss, stack_t oss); }
	53	SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, caddr_t data); }
54	54	SYS_REBOOT = 55 // { int reboot(int opt); }
55	55	SYS_REVOKE = 56 // { int revoke(char *path); }
56	56	SYS_SYMLINK = 57 // { int symlink(char path, char link); }
57		SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, \
58		SYS_EXECVE = 59 // { int execve(char fname, char *argv, \
59		SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args \
	57	SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, size_t count); }
	58	SYS_EXECVE = 59 // { int execve(char fname, char argv, char *envv); }
	59	SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args int
60	60	SYS_CHROOT = 61 // { int chroot(char *path); }
61		SYS_MSYNC = 65 // { int msync(void *addr, size_t len, \
	61	SYS_MSYNC = 65 // { int msync(void *addr, size_t len, int flags); }
62	62	SYS_VFORK = 66 // { int vfork(void); }
63	63	SYS_SBRK = 69 // { int sbrk(int incr); }
64	64	SYS_SSTK = 70 // { int sstk(int incr); }
65		SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise \
	65	SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise ovadvise_args int
66	66	SYS_MUNMAP = 73 // { int munmap(void *addr, size_t len); }
67		SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, \
68		SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, \
69		SYS_MINCORE = 78 // { int mincore(const void *addr, size_t len, \
70		SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, \
71		SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, \
	67	SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, int prot); }
	68	SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, int behav); }
	69	SYS_MINCORE = 78 // { int mincore(const void addr, size_t len, char vec); }
	70	SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, gid_t *gidset); }
	71	SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, gid_t *gidset); }
72	72	SYS_GETPGRP = 81 // { int getpgrp(void); }
73	73	SYS_SETPGID = 82 // { int setpgid(int pid, int pgid); }
74		SYS_SETITIMER = 83 // { int setitimer(u_int which, struct \
	74	SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval itv, struct itimerval oitv); }
75	75	SYS_SWAPON = 85 // { int swapon(char *name); }
76		SYS_GETITIMER = 86 // { int getitimer(u_int which, \
	76	SYS_GETITIMER = 86 // { int getitimer(u_int which, struct itimerval *itv); }
77	77	SYS_GETDTABLESIZE = 89 // { int getdtablesize(void); }
78	78	SYS_DUP2 = 90 // { int dup2(u_int from, u_int to); }
79	79	SYS_FCNTL = 92 // { int fcntl(int fd, int cmd, long arg); }
80		SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, \
	80	SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
81	81	SYS_FSYNC = 95 // { int fsync(int fd); }
82		SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, \
83		SYS_SOCKET = 97 // { int socket(int domain, int type, \
84		SYS_CONNECT = 98 // { int connect(int s, caddr_t name, \
	82	SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, int prio); }
	83	SYS_SOCKET = 97 // { int socket(int domain, int type, int protocol); }
	84	SYS_CONNECT = 98 // { int connect(int s, caddr_t name, int namelen); }
85	85	SYS_GETPRIORITY = 100 // { int getpriority(int which, int who); }
86		SYS_BIND = 104 // { int bind(int s, caddr_t name, \
87		SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, \
	86	SYS_BIND = 104 // { int bind(int s, caddr_t name, int namelen); }
	87	SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, caddr_t val, int valsize); }
88	88	SYS_LISTEN = 106 // { int listen(int s, int backlog); }
89		SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval *tp, \
90		SYS_GETRUSAGE = 117 // { int getrusage(int who, \
91		SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, \
92		SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, \
93		SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, \
94		SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval *tv, \
	89	SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval tp, struct timezone tzp); }
	90	SYS_GETRUSAGE = 117 // { int getrusage(int who, struct rusage *rusage); }
	91	SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, caddr_t val, int *avalsize); }
	92	SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
	93	SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
	94	SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval tv, struct timezone tzp); }
95	95	SYS_FCHOWN = 123 // { int fchown(int fd, int uid, int gid); }
96	96	SYS_FCHMOD = 124 // { int fchmod(int fd, int mode); }
97	97	SYS_SETREUID = 126 // { int setreuid(int ruid, int euid); }

99	99	SYS_RENAME = 128 // { int rename(char from, char to); }
100	100	SYS_FLOCK = 131 // { int flock(int fd, int how); }
101	101	SYS_MKFIFO = 132 // { int mkfifo(char *path, int mode); }
102		SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, \
	102	SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen); }
103	103	SYS_SHUTDOWN = 134 // { int shutdown(int s, int how); }
104		SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, \
	104	SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, int *rsv); }
105	105	SYS_MKDIR = 136 // { int mkdir(char *path, int mode); }
106	106	SYS_RMDIR = 137 // { int rmdir(char *path); }
107		SYS_UTIMES = 138 // { int utimes(char *path, \
108		SYS_ADJTIME = 140 // { int adjtime(struct timeval *delta, \
	107	SYS_UTIMES = 138 // { int utimes(char path, struct timeval tptr); }
	108	SYS_ADJTIME = 140 // { int adjtime(struct timeval delta, struct timeval olddelta); }
109	109	SYS_SETSID = 147 // { int setsid(void); }
110		SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, \
	110	SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, caddr_t arg); }
111	111	SYS_NLM_SYSCALL = 154 // { int nlm_syscall(int debug_level, int grace_period, int addr_count, char **addrs); }
112	112	SYS_NFSSVC = 155 // { int nfssvc(int flag, caddr_t argp); }
113		SYS_LGETFH = 160 // { int lgetfh(char *fname, \
114		SYS_GETFH = 161 // { int getfh(char *fname, \
	113	SYS_LGETFH = 160 // { int lgetfh(char fname, struct fhandle fhp); }
	114	SYS_GETFH = 161 // { int getfh(char fname, struct fhandle fhp); }
115	115	SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); }
116		SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \
117		SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, \
118		SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, \
119		SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, \
120		SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, \
121		SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, \
	116	SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, struct rtprio *rtp); }
	117	SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, int a5); }
	118	SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, int a5, int a6); }
	119	SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); }
	120	SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	121	SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
122	122	SYS_SETFIB = 175 // { int setfib(int fibnum); }
123	123	SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); }
124	124	SYS_SETGID = 181 // { int setgid(gid_t gid); }

129	129	SYS_LSTAT = 190 // { int lstat(char path, struct stat ub); }
130	130	SYS_PATHCONF = 191 // { int pathconf(char *path, int name); }
131	131	SYS_FPATHCONF = 192 // { int fpathconf(int fd, int name); }
132		SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, \
133		SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, \
134		SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char *buf, \
135		SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, \
136		SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, \
137		SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, \
138		SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, \
139		SYS___SYSCTL = 202 // { int __sysctl(int *name, u_int namelen, \
	132	SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, struct rlimit *rlp); } getrlimit __getrlimit_args int
	133	SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, struct rlimit *rlp); } setrlimit __setrlimit_args int
	134	SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char buf, u_int count, long basep); }
	135	SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, size_t len, int prot, int flags, int fd, int pad, off_t pos); }
	136	SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, off_t offset, int whence); }
	137	SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, off_t length); }
	138	SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, off_t length); }
	139	SYS___SYSCTL = 202 // { int __sysctl(int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); } __sysctl sysctl_args int
140	140	SYS_MLOCK = 203 // { int mlock(const void *addr, size_t len); }
141	141	SYS_MUNLOCK = 204 // { int munlock(const void *addr, size_t len); }
142	142	SYS_UNDELETE = 205 // { int undelete(char *path); }
143	143	SYS_FUTIMES = 206 // { int futimes(int fd, struct timeval *tptr); }
144	144	SYS_GETPGID = 207 // { int getpgid(pid_t pid); }
145		SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, \
146		SYS_SEMGET = 221 // { int semget(key_t key, int nsems, \
147		SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, \
	145	SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, int timeout); }
	146	SYS_SEMGET = 221 // { int semget(key_t key, int nsems, int semflg); }
	147	SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, size_t nsops); }
148	148	SYS_MSGGET = 225 // { int msgget(key_t key, int msgflg); }
149		SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, \
150		SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, \
151		SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, \
	149	SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	150	SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	151	SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, int shmflg); }
152	152	SYS_SHMDT = 230 // { int shmdt(const void *shmaddr); }
153		SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, \
154		SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, \
155		SYS_CLOCK_SETTIME = 233 // { int clock_settime( \
156		SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, \
157		SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, \
	153	SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, int shmflg); }
	154	SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, struct timespec *tp); }
	155	SYS_CLOCK_SETTIME = 233 // { int clock_settime( clockid_t clock_id, const struct timespec *tp); }
	156	SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, struct timespec *tp); }
	157	SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, struct sigevent evp, int timerid); }
158	158	SYS_KTIMER_DELETE = 236 // { int ktimer_delete(int timerid); }
159		SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, \
160		SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct \
	159	SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, const struct itimerspec value, struct itimerspec ovalue); }
	160	SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct itimerspec *value); }
161	161	SYS_KTIMER_GETOVERRUN = 239 // { int ktimer_getoverrun(int timerid); }
162		SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec *rqtp, \
	162	SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec rqtp, struct timespec rmtp); }
163	163	SYS_FFCLOCK_GETCOUNTER = 241 // { int ffclock_getcounter(ffcounter *ffcount); }
164		SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( \
165		SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( \
166		SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,\
	164	SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( struct ffclock_estimate *cest); }
	165	SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( struct ffclock_estimate *cest); }
	166	SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,int which, clockid_t *clock_id); }
167	167	SYS_NTP_GETTIME = 248 // { int ntp_gettime(struct ntptimeval *ntvp); }
168		SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, \
	168	SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, int inherit); }
169	169	SYS_RFORK = 251 // { int rfork(int flags); }
170		SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, \
	170	SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, u_int nfds, int timeout); }
171	171	SYS_ISSETUGID = 253 // { int issetugid(void); }
172	172	SYS_LCHOWN = 254 // { int lchown(char *path, int uid, int gid); }
173	173	SYS_AIO_READ = 255 // { int aio_read(struct aiocb *aiocbp); }
174	174	SYS_AIO_WRITE = 256 // { int aio_write(struct aiocb *aiocbp); }
175		SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, \
176		SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, \
	175	SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, struct aiocb * const acb_list, int nent, struct sigevent sig); }
	176	SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, size_t count); }
177	177	SYS_LCHMOD = 274 // { int lchmod(char *path, mode_t mode); }
178		SYS_LUTIMES = 276 // { int lutimes(char *path, \
	178	SYS_LUTIMES = 276 // { int lutimes(char path, struct timeval tptr); }
179	179	SYS_NSTAT = 278 // { int nstat(char path, struct nstat ub); }
180	180	SYS_NFSTAT = 279 // { int nfstat(int fd, struct nstat *sb); }
181	181	SYS_NLSTAT = 280 // { int nlstat(char path, struct nstat ub); }
182		SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, \
183		SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, \
184		SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, \
185		SYS_FHSTAT = 299 // { int fhstat(const struct fhandle *u_fhp, \
	182	SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	183	SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	184	SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, int flags); }
	185	SYS_FHSTAT = 299 // { int fhstat(const struct fhandle u_fhp, struct stat sb); }
186	186	SYS_MODNEXT = 300 // { int modnext(int modid); }
187		SYS_MODSTAT = 301 // { int modstat(int modid, \
	187	SYS_MODSTAT = 301 // { int modstat(int modid, struct module_stat *stat); }
188	188	SYS_MODFNEXT = 302 // { int modfnext(int modid); }
189	189	SYS_MODFIND = 303 // { int modfind(const char *name); }
190	190	SYS_KLDLOAD = 304 // { int kldload(const char *file); }
191	191	SYS_KLDUNLOAD = 305 // { int kldunload(int fileid); }
192	192	SYS_KLDFIND = 306 // { int kldfind(const char *file); }
193	193	SYS_KLDNEXT = 307 // { int kldnext(int fileid); }
194		SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct \
	194	SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct kld_file_stat* stat); }
195	195	SYS_KLDFIRSTMOD = 309 // { int kldfirstmod(int fileid); }
196	196	SYS_GETSID = 310 // { int getsid(pid_t pid); }
197		SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, \
198		SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, \
	197	SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	198	SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
199	199	SYS_AIO_RETURN = 314 // { int aio_return(struct aiocb *aiocbp); }
200		SYS_AIO_SUSPEND = 315 // { int aio_suspend( \
201		SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, \
	200	SYS_AIO_SUSPEND = 315 // { int aio_suspend( struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
	201	SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, struct aiocb *aiocbp); }
202	202	SYS_AIO_ERROR = 317 // { int aio_error(struct aiocb *aiocbp); }
203	203	SYS_OAIO_READ = 318 // { int oaio_read(struct oaiocb *aiocbp); }
204	204	SYS_OAIO_WRITE = 319 // { int oaio_write(struct oaiocb *aiocbp); }
205		SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, \
	205	SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, struct oaiocb * const acb_list, int nent, struct osigevent sig); }
206	206	SYS_YIELD = 321 // { int yield(void); }
207	207	SYS_MLOCKALL = 324 // { int mlockall(int how); }
208	208	SYS_MUNLOCKALL = 325 // { int munlockall(void); }
209	209	SYS___GETCWD = 326 // { int __getcwd(char *buf, u_int buflen); }
210		SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, \
211		SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct \
212		SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int \
	210	SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, const struct sched_param *param); }
	211	SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct sched_param *param); }
	212	SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
213	213	SYS_SCHED_GETSCHEDULER = 330 // { int sched_getscheduler (pid_t pid); }
214	214	SYS_SCHED_YIELD = 331 // { int sched_yield (void); }
215	215	SYS_SCHED_GET_PRIORITY_MAX = 332 // { int sched_get_priority_max (int policy); }
216	216	SYS_SCHED_GET_PRIORITY_MIN = 333 // { int sched_get_priority_min (int policy); }
217		SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, \
	217	SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
218	218	SYS_UTRACE = 335 // { int utrace(const void *addr, size_t len); }
219		SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, \
	219	SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, void *data); }
220	220	SYS_JAIL = 338 // { int jail(struct jail *jail); }
221		SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, \
	221	SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t set, sigset_t oset); }
222	222	SYS_SIGSUSPEND = 341 // { int sigsuspend(const sigset_t *sigmask); }
223	223	SYS_SIGPENDING = 343 // { int sigpending(sigset_t *set); }
224		SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t *set, \
225		SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t *set, \
226		SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char *path, \
227		SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char *path, \
228		SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, \
229		SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, \
230		SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, \
231		SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, \
232		SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \
233		SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \
234		SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \
235		SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \
236		SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \
237		SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \
238		SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( \
239		SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, \
240		SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, \
	224	SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t set, siginfo_t info, const struct timespec *timeout); }
	225	SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t set, siginfo_t info); }
	226	SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char path, acl_type_t type, struct acl aclp); }
	227	SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char path, acl_type_t type, struct acl aclp); }
	228	SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp); }
	229	SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp); }
	230	SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, acl_type_t type); }
	231	SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, acl_type_t type); }
	232	SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char path, acl_type_t type, struct acl aclp); }
	233	SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp); }
	234	SYS_EXTATTRCTL = 355 // { int extattrctl(const char path, int cmd, const char filename, int attrnamespace, const char *attrname); }
	235	SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	236	SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	237	SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char path, int attrnamespace, const char attrname); }
	238	SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( struct aiocb *aiocbp, struct timespec timeout); }
	239	SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	240	SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
241	241	SYS_KQUEUE = 362 // { int kqueue(void); }
242		SYS_KEVENT = 363 // { int kevent(int fd, \
243		SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \
244		SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \
245		SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \
	242	SYS_KEVENT = 363 // { int kevent(int fd, struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
	243	SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	244	SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	245	SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, int attrnamespace, const char *attrname); }
246	246	SYS___SETUGID = 374 // { int __setugid(int flag); }
247	247	SYS_EACCESS = 376 // { int eaccess(char *path, int amode); }
248		SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, \
	248	SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, unsigned int iovcnt, int flags); }
249	249	SYS___MAC_GET_PROC = 384 // { int __mac_get_proc(struct mac *mac_p); }
250	250	SYS___MAC_SET_PROC = 385 // { int __mac_set_proc(struct mac *mac_p); }
251		SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, \
252		SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char *path_p, \
253		SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \
254		SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \
255		SYS_KENV = 390 // { int kenv(int what, const char *name, \
256		SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \
257		SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \
258		SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \
259		SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \
260		SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, \
261		SYS_STATFS = 396 // { int statfs(char *path, \
	251	SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, struct mac *mac_p); }
	252	SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char path_p, struct mac mac_p); }
	253	SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, struct mac *mac_p); }
	254	SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char path_p, struct mac mac_p); }
	255	SYS_KENV = 390 // { int kenv(int what, const char name, char value, int len); }
	256	SYS_LCHFLAGS = 391 // { int lchflags(const char *path, u_long flags); }
	257	SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, int count); }
	258	SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, struct sf_hdtr hdtr, off_t sbytes, int flags); }
	259	SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char policy, int call, void arg); }
	260	SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, long bufsize, int flags); }
	261	SYS_STATFS = 396 // { int statfs(char path, struct statfs buf); }
262	262	SYS_FSTATFS = 397 // { int fstatfs(int fd, struct statfs *buf); }
263		SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle *u_fhp, \
	263	SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle u_fhp, struct statfs buf); }
264	264	SYS_KSEM_CLOSE = 400 // { int ksem_close(semid_t id); }
265	265	SYS_KSEM_POST = 401 // { int ksem_post(semid_t id); }
266	266	SYS_KSEM_WAIT = 402 // { int ksem_wait(semid_t id); }
267	267	SYS_KSEM_TRYWAIT = 403 // { int ksem_trywait(semid_t id); }
268		SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, \
269		SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t *idp, \
	268	SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, unsigned int value); }
	269	SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t idp, const char name, int oflag, mode_t mode, unsigned int value); }
270	270	SYS_KSEM_UNLINK = 406 // { int ksem_unlink(const char *name); }
271	271	SYS_KSEM_GETVALUE = 407 // { int ksem_getvalue(semid_t id, int *val); }
272	272	SYS_KSEM_DESTROY = 408 // { int ksem_destroy(semid_t id); }
273		SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \
274		SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \
275		SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \
276		SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \
277		SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \
278		SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \
279		SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char *argv, \
280		SYS_SIGACTION = 416 // { int sigaction(int sig, \
281		SYS_SIGRETURN = 417 // { int sigreturn( \
	273	SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, struct mac *mac_p); }
	274	SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char path_p, struct mac mac_p); }
	275	SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char path_p, struct mac mac_p); }
	276	SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	277	SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	278	SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( const char path, int attrnamespace, const char attrname); }
	279	SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char argv, char envv, struct mac mac_p); }
	280	SYS_SIGACTION = 416 // { int sigaction(int sig, const struct sigaction act, struct sigaction oact); }
	281	SYS_SIGRETURN = 417 // { int sigreturn( const struct __ucontext *sigcntxp); }
282	282	SYS_GETCONTEXT = 421 // { int getcontext(struct __ucontext *ucp); }
283		SYS_SETCONTEXT = 422 // { int setcontext( \
284		SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext *oucp, \
	283	SYS_SETCONTEXT = 422 // { int setcontext( const struct __ucontext *ucp); }
	284	SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext oucp, const struct __ucontext ucp); }
285	285	SYS_SWAPOFF = 424 // { int swapoff(const char *name); }
286		SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char *path, \
287		SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char *path, \
288		SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, \
289		SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char *path, \
290		SYS_SIGWAIT = 429 // { int sigwait(const sigset_t *set, \
291		SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, \
	286	SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char path, acl_type_t type, struct acl aclp); }
	287	SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char path, acl_type_t type, struct acl aclp); }
	288	SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, acl_type_t type); }
	289	SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char path, acl_type_t type, struct acl aclp); }
	290	SYS_SIGWAIT = 429 // { int sigwait(const sigset_t set, int sig); }
	291	SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, int flags); }
292	292	SYS_THR_EXIT = 431 // { void thr_exit(long *state); }
293	293	SYS_THR_SELF = 432 // { int thr_self(long *id); }
294	294	SYS_THR_KILL = 433 // { int thr_kill(long id, int sig); }
295	295	SYS__UMTX_LOCK = 434 // { int _umtx_lock(struct umtx *umtx); }
296	296	SYS__UMTX_UNLOCK = 435 // { int _umtx_unlock(struct umtx *umtx); }
297	297	SYS_JAIL_ATTACH = 436 // { int jail_attach(int jid); }
298		SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, \
299		SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( \
300		SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( \
301		SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, \
302		SYS_THR_SUSPEND = 442 // { int thr_suspend( \
	298	SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes); }
	299	SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( const char path, int attrnamespace, void data, size_t nbytes); }
	300	SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( const char path, int attrnamespace, void data, size_t nbytes); }
	301	SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, const struct timespec *abstime); }
	302	SYS_THR_SUSPEND = 442 // { int thr_suspend( const struct timespec *timeout); }
303	303	SYS_THR_WAKE = 443 // { int thr_wake(long id); }
304	304	SYS_KLDUNLOADF = 444 // { int kldunloadf(int fileid, int flags); }
305		SYS_AUDIT = 445 // { int audit(const void *record, \
306		SYS_AUDITON = 446 // { int auditon(int cmd, void *data, \
	305	SYS_AUDIT = 445 // { int audit(const void *record, u_int length); }
	306	SYS_AUDITON = 446 // { int auditon(int cmd, void *data, u_int length); }
307	307	SYS_GETAUID = 447 // { int getauid(uid_t *auid); }
308	308	SYS_SETAUID = 448 // { int setauid(uid_t *auid); }
309	309	SYS_GETAUDIT = 449 // { int getaudit(struct auditinfo *auditinfo); }
310	310	SYS_SETAUDIT = 450 // { int setaudit(struct auditinfo *auditinfo); }
311		SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( \
312		SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( \
	311	SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
	312	SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
313	313	SYS_AUDITCTL = 453 // { int auditctl(char *path); }
314		SYS__UMTX_OP = 454 // { int _umtx_op(void *obj, int op, \
315		SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, \
	314	SYS__UMTX_OP = 454 // { int _umtx_op(void obj, int op, u_long val, void uaddr1, void *uaddr2); }
	315	SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, int param_size); }
316	316	SYS_SIGQUEUE = 456 // { int sigqueue(pid_t pid, int signum, void *value); }
317		SYS_KMQ_OPEN = 457 // { int kmq_open(const char *path, int flags, \
318		SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, \
319		SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, \
320		SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, \
321		SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, \
	317	SYS_KMQ_OPEN = 457 // { int kmq_open(const char path, int flags, mode_t mode, const struct mq_attr attr); }
	318	SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, const struct mq_attr attr, struct mq_attr oattr); }
	319	SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, char msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout); }
	320	SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, const char msg_ptr, size_t msg_len,unsigned msg_prio, const struct timespec abs_timeout);}
	321	SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, const struct sigevent *sigev); }
322	322	SYS_KMQ_UNLINK = 462 // { int kmq_unlink(const char *path); }
323	323	SYS_ABORT2 = 463 // { int abort2(const char why, int nargs, void *args); }
324	324	SYS_THR_SET_NAME = 464 // { int thr_set_name(long id, const char *name); }
325	325	SYS_AIO_FSYNC = 465 // { int aio_fsync(int op, struct aiocb *aiocbp); }
326		SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, \
	326	SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp); }
327	327	SYS_SCTP_PEELOFF = 471 // { int sctp_peeloff(int sd, uint32_t name); }
328		SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, \
329		SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec *iov, int iovlen, \
330		SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec *iov, int iovlen, \
331		SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, \
332		SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, \
333		SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, \
334		SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, \
	328	SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo *sinfo, int flags); }
	329	SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec iov, int iovlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo sinfo, int flags); }
	330	SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec iov, int iovlen, struct sockaddr from, __socklen_t fromlenaddr, struct sctp_sndrcvinfo sinfo, int *msg_flags); }
	331	SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset); }
	332	SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset); }
	333	SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos); }
	334	SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, int whence); }
335	335	SYS_TRUNCATE = 479 // { int truncate(char *path, off_t length); }
336	336	SYS_FTRUNCATE = 480 // { int ftruncate(int fd, off_t length); }
337	337	SYS_THR_KILL2 = 481 // { int thr_kill2(pid_t pid, long id, int sig); }
338		SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, \
	338	SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, mode_t mode); }
339	339	SYS_SHM_UNLINK = 483 // { int shm_unlink(const char *path); }
340	340	SYS_CPUSET = 484 // { int cpuset(cpusetid_t *setid); }
341		SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, \
342		SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, \
343		SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, \
344		SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, \
345		SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, \
346		SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, \
347		SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, \
348		SYS_FEXECVE = 492 // { int fexecve(int fd, char **argv, \
349		SYS_FSTATAT = 493 // { int fstatat(int fd, char *path, \
350		SYS_FUTIMESAT = 494 // { int futimesat(int fd, char *path, \
351		SYS_LINKAT = 495 // { int linkat(int fd1, char *path1, int fd2, \
	341	SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, cpusetid_t setid); }
	342	SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, cpuwhich_t which, id_t id, cpusetid_t *setid); }
	343	SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, cpuset_t *mask); }
	344	SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, const cpuset_t *mask); }
	345	SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, int flag); }
	346	SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, int flag); }
	347	SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, gid_t gid, int flag); }
	348	SYS_FEXECVE = 492 // { int fexecve(int fd, char argv, char envv); }
	349	SYS_FSTATAT = 493 // { int fstatat(int fd, char path, struct stat buf, int flag); }
	350	SYS_FUTIMESAT = 494 // { int futimesat(int fd, char path, struct timeval times); }
	351	SYS_LINKAT = 495 // { int linkat(int fd1, char path1, int fd2, char path2, int flag); }
352	352	SYS_MKDIRAT = 496 // { int mkdirat(int fd, char *path, mode_t mode); }
353	353	SYS_MKFIFOAT = 497 // { int mkfifoat(int fd, char *path, mode_t mode); }
354		SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, \
355		SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, \
356		SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, \
357		SYS_RENAMEAT = 501 // { int renameat(int oldfd, char *old, int newfd, \
358		SYS_SYMLINKAT = 502 // { int symlinkat(char *path1, int fd, \
	354	SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, dev_t dev); }
	355	SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, mode_t mode); }
	356	SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, size_t bufsize); }
	357	SYS_RENAMEAT = 501 // { int renameat(int oldfd, char old, int newfd, char new); }
	358	SYS_SYMLINKAT = 502 // { int symlinkat(char path1, int fd, char path2); }
359	359	SYS_UNLINKAT = 503 // { int unlinkat(int fd, char *path, int flag); }
360	360	SYS_POSIX_OPENPT = 504 // { int posix_openpt(int flags); }
361	361	SYS_GSSD_SYSCALL = 505 // { int gssd_syscall(char *path); }
362		SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, \
363		SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, \
	362	SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, unsigned int iovcnt, int flags); }
	363	SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, unsigned int iovcnt, int flags); }
364	364	SYS_JAIL_REMOVE = 508 // { int jail_remove(int jid); }
365	365	SYS_CLOSEFROM = 509 // { int closefrom(int lowfd); }
366		SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, \
367		SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, \
368		SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, \
	366	SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, int cmd, union semun *arg); }
	367	SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, struct msqid_ds *buf); }
	368	SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, struct shmid_ds *buf); }
369	369	SYS_LPATHCONF = 513 // { int lpathconf(char *path, int name); }
370		SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, \
	370	SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, int fd, cap_rights_t *rightsp); }
371	371	SYS_CAP_ENTER = 516 // { int cap_enter(void); }
372	372	SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }
373	373	SYS_PDFORK = 518 // { int pdfork(int *fdp, int flags); }
374	374	SYS_PDKILL = 519 // { int pdkill(int fd, int signum); }
375	375	SYS_PDGETPID = 520 // { int pdgetpid(int fd, pid_t *pidp); }
376		SYS_PSELECT = 522 // { int pselect(int nd, fd_set *in, \
377		SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, \
	376	SYS_PSELECT = 522 // { int pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *sm); }
	377	SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, size_t namelen); }
378	378	SYS_SETLOGINCLASS = 524 // { int setloginclass(const char *namebuf); }
379		SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void *inbufp, \
380		SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void *inbufp, \
381		SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void *inbufp, \
382		SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void *inbufp, \
383		SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \
384		SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \
385		SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \
386		SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \
387		SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, \
388		SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, \
389		SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, \
390		SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, \
391		SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, \
392		SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \
393		SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \
394		SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \
395		SYS_ACCEPT4 = 541 // { int accept4(int s, \
	379	SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	380	SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	381	SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	382	SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	383	SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	384	SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, off_t offset, off_t len); }
	385	SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, off_t len, int advice); }
	386	SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, int status, int options, struct __wrusage wrusage, siginfo_t *info); }
	387	SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, cap_rights_t *rightsp); }
	388	SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, const u_long *cmds, size_t ncmds); }
	389	SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, u_long *cmds, size_t maxcmds); }
	390	SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, uint32_t fcntlrights); }
	391	SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, uint32_t *fcntlrightsp); }
	392	SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, int namelen); }
	393	SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, int namelen); }
	394	SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, u_long flags, int atflag); }
	395	SYS_ACCEPT4 = 541 // { int accept4(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen, int flags); }
396	396	SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); }
397	397	SYS_AIO_MLOCK = 543 // { int aio_mlock(struct aiocb *aiocbp); }
398		SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \
399		SYS_PPOLL = 545 // { int ppoll(struct pollfd *fds, u_int nfds, \
400		SYS_FUTIMENS = 546 // { int futimens(int fd, \
401		SYS_UTIMENSAT = 547 // { int utimensat(int fd, \
	398	SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, int com, void *data); }
	399	SYS_PPOLL = 545 // { int ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *set); }
	400	SYS_FUTIMENS = 546 // { int futimens(int fd, struct timespec *times); }
	401	SYS_UTIMENSAT = 547 // { int utimensat(int fd, char path, struct timespec times, int flag); }
402	402	)

+226

-226

unix/zsysnum_freebsd_arm.go less more

0		// mksysnum_freebsd.pl
	0	// go run mksysnum.go http://svn.freebsd.org/base/stable/10/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build arm,freebsd

6	6
7	7	const (
8	8	// SYS_NOSYS = 0; // { int nosys(void); } syscall nosys_args int
9		SYS_EXIT = 1 // { void sys_exit(int rval); } exit \
	9	SYS_EXIT = 1 // { void sys_exit(int rval); } exit sys_exit_args void
10	10	SYS_FORK = 2 // { int fork(void); }
11		SYS_READ = 3 // { ssize_t read(int fd, void *buf, \
12		SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, \
	11	SYS_READ = 3 // { ssize_t read(int fd, void *buf, size_t nbyte); }
	12	SYS_WRITE = 4 // { ssize_t write(int fd, const void *buf, size_t nbyte); }
13	13	SYS_OPEN = 5 // { int open(char *path, int flags, int mode); }
14	14	SYS_CLOSE = 6 // { int close(int fd); }
15		SYS_WAIT4 = 7 // { int wait4(int pid, int *status, \
	15	SYS_WAIT4 = 7 // { int wait4(int pid, int status, int options, struct rusage rusage); }
16	16	SYS_LINK = 9 // { int link(char path, char link); }
17	17	SYS_UNLINK = 10 // { int unlink(char *path); }
18	18	SYS_CHDIR = 12 // { int chdir(char *path); }

20	20	SYS_MKNOD = 14 // { int mknod(char *path, int mode, int dev); }
21	21	SYS_CHMOD = 15 // { int chmod(char *path, int mode); }
22	22	SYS_CHOWN = 16 // { int chown(char *path, int uid, int gid); }
23		SYS_OBREAK = 17 // { int obreak(char *nsize); } break \
	23	SYS_OBREAK = 17 // { int obreak(char *nsize); } break obreak_args int
24	24	SYS_GETPID = 20 // { pid_t getpid(void); }
25		SYS_MOUNT = 21 // { int mount(char type, char path, \
	25	SYS_MOUNT = 21 // { int mount(char type, char path, int flags, caddr_t data); }
26	26	SYS_UNMOUNT = 22 // { int unmount(char *path, int flags); }
27	27	SYS_SETUID = 23 // { int setuid(uid_t uid); }
28	28	SYS_GETUID = 24 // { uid_t getuid(void); }
29	29	SYS_GETEUID = 25 // { uid_t geteuid(void); }
30		SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, \
31		SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, \
32		SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, \
33		SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, \
34		SYS_ACCEPT = 30 // { int accept(int s, \
35		SYS_GETPEERNAME = 31 // { int getpeername(int fdes, \
36		SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, \
	30	SYS_PTRACE = 26 // { int ptrace(int req, pid_t pid, caddr_t addr, int data); }
	31	SYS_RECVMSG = 27 // { int recvmsg(int s, struct msghdr *msg, int flags); }
	32	SYS_SENDMSG = 28 // { int sendmsg(int s, struct msghdr *msg, int flags); }
	33	SYS_RECVFROM = 29 // { int recvfrom(int s, caddr_t buf, size_t len, int flags, struct sockaddr * __restrict from, __socklen_t * __restrict fromlenaddr); }
	34	SYS_ACCEPT = 30 // { int accept(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen); }
	35	SYS_GETPEERNAME = 31 // { int getpeername(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
	36	SYS_GETSOCKNAME = 32 // { int getsockname(int fdes, struct sockaddr * __restrict asa, __socklen_t * __restrict alen); }
37	37	SYS_ACCESS = 33 // { int access(char *path, int amode); }
38	38	SYS_CHFLAGS = 34 // { int chflags(const char *path, u_long flags); }
39	39	SYS_FCHFLAGS = 35 // { int fchflags(int fd, u_long flags); }

43	43	SYS_DUP = 41 // { int dup(u_int fd); }
44	44	SYS_PIPE = 42 // { int pipe(void); }
45	45	SYS_GETEGID = 43 // { gid_t getegid(void); }
46		SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, \
47		SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, \
	46	SYS_PROFIL = 44 // { int profil(caddr_t samples, size_t size, size_t offset, u_int scale); }
	47	SYS_KTRACE = 45 // { int ktrace(const char *fname, int ops, int facs, int pid); }
48	48	SYS_GETGID = 47 // { gid_t getgid(void); }
49		SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int \
	49	SYS_GETLOGIN = 49 // { int getlogin(char *namebuf, u_int namelen); }
50	50	SYS_SETLOGIN = 50 // { int setlogin(char *namebuf); }
51	51	SYS_ACCT = 51 // { int acct(char *path); }
52		SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t *ss, \
53		SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, \
	52	SYS_SIGALTSTACK = 53 // { int sigaltstack(stack_t ss, stack_t oss); }
	53	SYS_IOCTL = 54 // { int ioctl(int fd, u_long com, caddr_t data); }
54	54	SYS_REBOOT = 55 // { int reboot(int opt); }
55	55	SYS_REVOKE = 56 // { int revoke(char *path); }
56	56	SYS_SYMLINK = 57 // { int symlink(char path, char link); }
57		SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, \
58		SYS_EXECVE = 59 // { int execve(char fname, char *argv, \
59		SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args \
	57	SYS_READLINK = 58 // { ssize_t readlink(char path, char buf, size_t count); }
	58	SYS_EXECVE = 59 // { int execve(char fname, char argv, char *envv); }
	59	SYS_UMASK = 60 // { int umask(int newmask); } umask umask_args int
60	60	SYS_CHROOT = 61 // { int chroot(char *path); }
61		SYS_MSYNC = 65 // { int msync(void *addr, size_t len, \
	61	SYS_MSYNC = 65 // { int msync(void *addr, size_t len, int flags); }
62	62	SYS_VFORK = 66 // { int vfork(void); }
63	63	SYS_SBRK = 69 // { int sbrk(int incr); }
64	64	SYS_SSTK = 70 // { int sstk(int incr); }
65		SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise \
	65	SYS_OVADVISE = 72 // { int ovadvise(int anom); } vadvise ovadvise_args int
66	66	SYS_MUNMAP = 73 // { int munmap(void *addr, size_t len); }
67		SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, \
68		SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, \
69		SYS_MINCORE = 78 // { int mincore(const void *addr, size_t len, \
70		SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, \
71		SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, \
	67	SYS_MPROTECT = 74 // { int mprotect(const void *addr, size_t len, int prot); }
	68	SYS_MADVISE = 75 // { int madvise(void *addr, size_t len, int behav); }
	69	SYS_MINCORE = 78 // { int mincore(const void addr, size_t len, char vec); }
	70	SYS_GETGROUPS = 79 // { int getgroups(u_int gidsetsize, gid_t *gidset); }
	71	SYS_SETGROUPS = 80 // { int setgroups(u_int gidsetsize, gid_t *gidset); }
72	72	SYS_GETPGRP = 81 // { int getpgrp(void); }
73	73	SYS_SETPGID = 82 // { int setpgid(int pid, int pgid); }
74		SYS_SETITIMER = 83 // { int setitimer(u_int which, struct \
	74	SYS_SETITIMER = 83 // { int setitimer(u_int which, struct itimerval itv, struct itimerval oitv); }
75	75	SYS_SWAPON = 85 // { int swapon(char *name); }
76		SYS_GETITIMER = 86 // { int getitimer(u_int which, \
	76	SYS_GETITIMER = 86 // { int getitimer(u_int which, struct itimerval *itv); }
77	77	SYS_GETDTABLESIZE = 89 // { int getdtablesize(void); }
78	78	SYS_DUP2 = 90 // { int dup2(u_int from, u_int to); }
79	79	SYS_FCNTL = 92 // { int fcntl(int fd, int cmd, long arg); }
80		SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, \
	80	SYS_SELECT = 93 // { int select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
81	81	SYS_FSYNC = 95 // { int fsync(int fd); }
82		SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, \
83		SYS_SOCKET = 97 // { int socket(int domain, int type, \
84		SYS_CONNECT = 98 // { int connect(int s, caddr_t name, \
	82	SYS_SETPRIORITY = 96 // { int setpriority(int which, int who, int prio); }
	83	SYS_SOCKET = 97 // { int socket(int domain, int type, int protocol); }
	84	SYS_CONNECT = 98 // { int connect(int s, caddr_t name, int namelen); }
85	85	SYS_GETPRIORITY = 100 // { int getpriority(int which, int who); }
86		SYS_BIND = 104 // { int bind(int s, caddr_t name, \
87		SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, \
	86	SYS_BIND = 104 // { int bind(int s, caddr_t name, int namelen); }
	87	SYS_SETSOCKOPT = 105 // { int setsockopt(int s, int level, int name, caddr_t val, int valsize); }
88	88	SYS_LISTEN = 106 // { int listen(int s, int backlog); }
89		SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval *tp, \
90		SYS_GETRUSAGE = 117 // { int getrusage(int who, \
91		SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, \
92		SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, \
93		SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, \
94		SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval *tv, \
	89	SYS_GETTIMEOFDAY = 116 // { int gettimeofday(struct timeval tp, struct timezone tzp); }
	90	SYS_GETRUSAGE = 117 // { int getrusage(int who, struct rusage *rusage); }
	91	SYS_GETSOCKOPT = 118 // { int getsockopt(int s, int level, int name, caddr_t val, int *avalsize); }
	92	SYS_READV = 120 // { int readv(int fd, struct iovec *iovp, u_int iovcnt); }
	93	SYS_WRITEV = 121 // { int writev(int fd, struct iovec *iovp, u_int iovcnt); }
	94	SYS_SETTIMEOFDAY = 122 // { int settimeofday(struct timeval tv, struct timezone tzp); }
95	95	SYS_FCHOWN = 123 // { int fchown(int fd, int uid, int gid); }
96	96	SYS_FCHMOD = 124 // { int fchmod(int fd, int mode); }
97	97	SYS_SETREUID = 126 // { int setreuid(int ruid, int euid); }

99	99	SYS_RENAME = 128 // { int rename(char from, char to); }
100	100	SYS_FLOCK = 131 // { int flock(int fd, int how); }
101	101	SYS_MKFIFO = 132 // { int mkfifo(char *path, int mode); }
102		SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, \
	102	SYS_SENDTO = 133 // { int sendto(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen); }
103	103	SYS_SHUTDOWN = 134 // { int shutdown(int s, int how); }
104		SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, \
	104	SYS_SOCKETPAIR = 135 // { int socketpair(int domain, int type, int protocol, int *rsv); }
105	105	SYS_MKDIR = 136 // { int mkdir(char *path, int mode); }
106	106	SYS_RMDIR = 137 // { int rmdir(char *path); }
107		SYS_UTIMES = 138 // { int utimes(char *path, \
108		SYS_ADJTIME = 140 // { int adjtime(struct timeval *delta, \
	107	SYS_UTIMES = 138 // { int utimes(char path, struct timeval tptr); }
	108	SYS_ADJTIME = 140 // { int adjtime(struct timeval delta, struct timeval olddelta); }
109	109	SYS_SETSID = 147 // { int setsid(void); }
110		SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, \
	110	SYS_QUOTACTL = 148 // { int quotactl(char *path, int cmd, int uid, caddr_t arg); }
111	111	SYS_NLM_SYSCALL = 154 // { int nlm_syscall(int debug_level, int grace_period, int addr_count, char **addrs); }
112	112	SYS_NFSSVC = 155 // { int nfssvc(int flag, caddr_t argp); }
113		SYS_LGETFH = 160 // { int lgetfh(char *fname, \
114		SYS_GETFH = 161 // { int getfh(char *fname, \
	113	SYS_LGETFH = 160 // { int lgetfh(char fname, struct fhandle fhp); }
	114	SYS_GETFH = 161 // { int getfh(char fname, struct fhandle fhp); }
115	115	SYS_SYSARCH = 165 // { int sysarch(int op, char *parms); }
116		SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, \
117		SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, \
118		SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, \
119		SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, \
120		SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, \
121		SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, \
	116	SYS_RTPRIO = 166 // { int rtprio(int function, pid_t pid, struct rtprio *rtp); }
	117	SYS_SEMSYS = 169 // { int semsys(int which, int a2, int a3, int a4, int a5); }
	118	SYS_MSGSYS = 170 // { int msgsys(int which, int a2, int a3, int a4, int a5, int a6); }
	119	SYS_SHMSYS = 171 // { int shmsys(int which, int a2, int a3, int a4); }
	120	SYS_FREEBSD6_PREAD = 173 // { ssize_t freebsd6_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	121	SYS_FREEBSD6_PWRITE = 174 // { ssize_t freebsd6_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
122	122	SYS_SETFIB = 175 // { int setfib(int fibnum); }
123	123	SYS_NTP_ADJTIME = 176 // { int ntp_adjtime(struct timex *tp); }
124	124	SYS_SETGID = 181 // { int setgid(gid_t gid); }

129	129	SYS_LSTAT = 190 // { int lstat(char path, struct stat ub); }
130	130	SYS_PATHCONF = 191 // { int pathconf(char *path, int name); }
131	131	SYS_FPATHCONF = 192 // { int fpathconf(int fd, int name); }
132		SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, \
133		SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, \
134		SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char *buf, \
135		SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, \
136		SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, \
137		SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, \
138		SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, \
139		SYS___SYSCTL = 202 // { int __sysctl(int *name, u_int namelen, \
	132	SYS_GETRLIMIT = 194 // { int getrlimit(u_int which, struct rlimit *rlp); } getrlimit __getrlimit_args int
	133	SYS_SETRLIMIT = 195 // { int setrlimit(u_int which, struct rlimit *rlp); } setrlimit __setrlimit_args int
	134	SYS_GETDIRENTRIES = 196 // { int getdirentries(int fd, char buf, u_int count, long basep); }
	135	SYS_FREEBSD6_MMAP = 197 // { caddr_t freebsd6_mmap(caddr_t addr, size_t len, int prot, int flags, int fd, int pad, off_t pos); }
	136	SYS_FREEBSD6_LSEEK = 199 // { off_t freebsd6_lseek(int fd, int pad, off_t offset, int whence); }
	137	SYS_FREEBSD6_TRUNCATE = 200 // { int freebsd6_truncate(char *path, int pad, off_t length); }
	138	SYS_FREEBSD6_FTRUNCATE = 201 // { int freebsd6_ftruncate(int fd, int pad, off_t length); }
	139	SYS___SYSCTL = 202 // { int __sysctl(int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); } __sysctl sysctl_args int
140	140	SYS_MLOCK = 203 // { int mlock(const void *addr, size_t len); }
141	141	SYS_MUNLOCK = 204 // { int munlock(const void *addr, size_t len); }
142	142	SYS_UNDELETE = 205 // { int undelete(char *path); }
143	143	SYS_FUTIMES = 206 // { int futimes(int fd, struct timeval *tptr); }
144	144	SYS_GETPGID = 207 // { int getpgid(pid_t pid); }
145		SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, \
146		SYS_SEMGET = 221 // { int semget(key_t key, int nsems, \
147		SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, \
	145	SYS_POLL = 209 // { int poll(struct pollfd *fds, u_int nfds, int timeout); }
	146	SYS_SEMGET = 221 // { int semget(key_t key, int nsems, int semflg); }
	147	SYS_SEMOP = 222 // { int semop(int semid, struct sembuf *sops, size_t nsops); }
148	148	SYS_MSGGET = 225 // { int msgget(key_t key, int msgflg); }
149		SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, \
150		SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, \
151		SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, \
	149	SYS_MSGSND = 226 // { int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	150	SYS_MSGRCV = 227 // { int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	151	SYS_SHMAT = 228 // { int shmat(int shmid, const void *shmaddr, int shmflg); }
152	152	SYS_SHMDT = 230 // { int shmdt(const void *shmaddr); }
153		SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, \
154		SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, \
155		SYS_CLOCK_SETTIME = 233 // { int clock_settime( \
156		SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, \
157		SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, \
	153	SYS_SHMGET = 231 // { int shmget(key_t key, size_t size, int shmflg); }
	154	SYS_CLOCK_GETTIME = 232 // { int clock_gettime(clockid_t clock_id, struct timespec *tp); }
	155	SYS_CLOCK_SETTIME = 233 // { int clock_settime( clockid_t clock_id, const struct timespec *tp); }
	156	SYS_CLOCK_GETRES = 234 // { int clock_getres(clockid_t clock_id, struct timespec *tp); }
	157	SYS_KTIMER_CREATE = 235 // { int ktimer_create(clockid_t clock_id, struct sigevent evp, int timerid); }
158	158	SYS_KTIMER_DELETE = 236 // { int ktimer_delete(int timerid); }
159		SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, \
160		SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct \
	159	SYS_KTIMER_SETTIME = 237 // { int ktimer_settime(int timerid, int flags, const struct itimerspec value, struct itimerspec ovalue); }
	160	SYS_KTIMER_GETTIME = 238 // { int ktimer_gettime(int timerid, struct itimerspec *value); }
161	161	SYS_KTIMER_GETOVERRUN = 239 // { int ktimer_getoverrun(int timerid); }
162		SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec *rqtp, \
	162	SYS_NANOSLEEP = 240 // { int nanosleep(const struct timespec rqtp, struct timespec rmtp); }
163	163	SYS_FFCLOCK_GETCOUNTER = 241 // { int ffclock_getcounter(ffcounter *ffcount); }
164		SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( \
165		SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( \
166		SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,\
	164	SYS_FFCLOCK_SETESTIMATE = 242 // { int ffclock_setestimate( struct ffclock_estimate *cest); }
	165	SYS_FFCLOCK_GETESTIMATE = 243 // { int ffclock_getestimate( struct ffclock_estimate *cest); }
	166	SYS_CLOCK_GETCPUCLOCKID2 = 247 // { int clock_getcpuclockid2(id_t id,int which, clockid_t *clock_id); }
167	167	SYS_NTP_GETTIME = 248 // { int ntp_gettime(struct ntptimeval *ntvp); }
168		SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, \
	168	SYS_MINHERIT = 250 // { int minherit(void *addr, size_t len, int inherit); }
169	169	SYS_RFORK = 251 // { int rfork(int flags); }
170		SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, \
	170	SYS_OPENBSD_POLL = 252 // { int openbsd_poll(struct pollfd *fds, u_int nfds, int timeout); }
171	171	SYS_ISSETUGID = 253 // { int issetugid(void); }
172	172	SYS_LCHOWN = 254 // { int lchown(char *path, int uid, int gid); }
173	173	SYS_AIO_READ = 255 // { int aio_read(struct aiocb *aiocbp); }
174	174	SYS_AIO_WRITE = 256 // { int aio_write(struct aiocb *aiocbp); }
175		SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, \
176		SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, \
	175	SYS_LIO_LISTIO = 257 // { int lio_listio(int mode, struct aiocb * const acb_list, int nent, struct sigevent sig); }
	176	SYS_GETDENTS = 272 // { int getdents(int fd, char *buf, size_t count); }
177	177	SYS_LCHMOD = 274 // { int lchmod(char *path, mode_t mode); }
178		SYS_LUTIMES = 276 // { int lutimes(char *path, \
	178	SYS_LUTIMES = 276 // { int lutimes(char path, struct timeval tptr); }
179	179	SYS_NSTAT = 278 // { int nstat(char path, struct nstat ub); }
180	180	SYS_NFSTAT = 279 // { int nfstat(int fd, struct nstat *sb); }
181	181	SYS_NLSTAT = 280 // { int nlstat(char path, struct nstat ub); }
182		SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, \
183		SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, \
184		SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, \
185		SYS_FHSTAT = 299 // { int fhstat(const struct fhandle *u_fhp, \
	182	SYS_PREADV = 289 // { ssize_t preadv(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	183	SYS_PWRITEV = 290 // { ssize_t pwritev(int fd, struct iovec *iovp, u_int iovcnt, off_t offset); }
	184	SYS_FHOPEN = 298 // { int fhopen(const struct fhandle *u_fhp, int flags); }
	185	SYS_FHSTAT = 299 // { int fhstat(const struct fhandle u_fhp, struct stat sb); }
186	186	SYS_MODNEXT = 300 // { int modnext(int modid); }
187		SYS_MODSTAT = 301 // { int modstat(int modid, \
	187	SYS_MODSTAT = 301 // { int modstat(int modid, struct module_stat *stat); }
188	188	SYS_MODFNEXT = 302 // { int modfnext(int modid); }
189	189	SYS_MODFIND = 303 // { int modfind(const char *name); }
190	190	SYS_KLDLOAD = 304 // { int kldload(const char *file); }
191	191	SYS_KLDUNLOAD = 305 // { int kldunload(int fileid); }
192	192	SYS_KLDFIND = 306 // { int kldfind(const char *file); }
193	193	SYS_KLDNEXT = 307 // { int kldnext(int fileid); }
194		SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct \
	194	SYS_KLDSTAT = 308 // { int kldstat(int fileid, struct kld_file_stat* stat); }
195	195	SYS_KLDFIRSTMOD = 309 // { int kldfirstmod(int fileid); }
196	196	SYS_GETSID = 310 // { int getsid(pid_t pid); }
197		SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, \
198		SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, \
	197	SYS_SETRESUID = 311 // { int setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	198	SYS_SETRESGID = 312 // { int setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
199	199	SYS_AIO_RETURN = 314 // { int aio_return(struct aiocb *aiocbp); }
200		SYS_AIO_SUSPEND = 315 // { int aio_suspend( \
201		SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, \
	200	SYS_AIO_SUSPEND = 315 // { int aio_suspend( struct aiocb * const * aiocbp, int nent, const struct timespec *timeout); }
	201	SYS_AIO_CANCEL = 316 // { int aio_cancel(int fd, struct aiocb *aiocbp); }
202	202	SYS_AIO_ERROR = 317 // { int aio_error(struct aiocb *aiocbp); }
203	203	SYS_OAIO_READ = 318 // { int oaio_read(struct oaiocb *aiocbp); }
204	204	SYS_OAIO_WRITE = 319 // { int oaio_write(struct oaiocb *aiocbp); }
205		SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, \
	205	SYS_OLIO_LISTIO = 320 // { int olio_listio(int mode, struct oaiocb * const acb_list, int nent, struct osigevent sig); }
206	206	SYS_YIELD = 321 // { int yield(void); }
207	207	SYS_MLOCKALL = 324 // { int mlockall(int how); }
208	208	SYS_MUNLOCKALL = 325 // { int munlockall(void); }
209	209	SYS___GETCWD = 326 // { int __getcwd(char *buf, u_int buflen); }
210		SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, \
211		SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct \
212		SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int \
	210	SYS_SCHED_SETPARAM = 327 // { int sched_setparam (pid_t pid, const struct sched_param *param); }
	211	SYS_SCHED_GETPARAM = 328 // { int sched_getparam (pid_t pid, struct sched_param *param); }
	212	SYS_SCHED_SETSCHEDULER = 329 // { int sched_setscheduler (pid_t pid, int policy, const struct sched_param *param); }
213	213	SYS_SCHED_GETSCHEDULER = 330 // { int sched_getscheduler (pid_t pid); }
214	214	SYS_SCHED_YIELD = 331 // { int sched_yield (void); }
215	215	SYS_SCHED_GET_PRIORITY_MAX = 332 // { int sched_get_priority_max (int policy); }
216	216	SYS_SCHED_GET_PRIORITY_MIN = 333 // { int sched_get_priority_min (int policy); }
217		SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, \
	217	SYS_SCHED_RR_GET_INTERVAL = 334 // { int sched_rr_get_interval (pid_t pid, struct timespec *interval); }
218	218	SYS_UTRACE = 335 // { int utrace(const void *addr, size_t len); }
219		SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, \
	219	SYS_KLDSYM = 337 // { int kldsym(int fileid, int cmd, void *data); }
220	220	SYS_JAIL = 338 // { int jail(struct jail *jail); }
221		SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, \
	221	SYS_SIGPROCMASK = 340 // { int sigprocmask(int how, const sigset_t set, sigset_t oset); }
222	222	SYS_SIGSUSPEND = 341 // { int sigsuspend(const sigset_t *sigmask); }
223	223	SYS_SIGPENDING = 343 // { int sigpending(sigset_t *set); }
224		SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t *set, \
225		SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t *set, \
226		SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char *path, \
227		SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char *path, \
228		SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, \
229		SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, \
230		SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, \
231		SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, \
232		SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char *path, \
233		SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, \
234		SYS_EXTATTRCTL = 355 // { int extattrctl(const char *path, int cmd, \
235		SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( \
236		SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( \
237		SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char *path, \
238		SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( \
239		SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, \
240		SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, \
	224	SYS_SIGTIMEDWAIT = 345 // { int sigtimedwait(const sigset_t set, siginfo_t info, const struct timespec *timeout); }
	225	SYS_SIGWAITINFO = 346 // { int sigwaitinfo(const sigset_t set, siginfo_t info); }
	226	SYS___ACL_GET_FILE = 347 // { int __acl_get_file(const char path, acl_type_t type, struct acl aclp); }
	227	SYS___ACL_SET_FILE = 348 // { int __acl_set_file(const char path, acl_type_t type, struct acl aclp); }
	228	SYS___ACL_GET_FD = 349 // { int __acl_get_fd(int filedes, acl_type_t type, struct acl *aclp); }
	229	SYS___ACL_SET_FD = 350 // { int __acl_set_fd(int filedes, acl_type_t type, struct acl *aclp); }
	230	SYS___ACL_DELETE_FILE = 351 // { int __acl_delete_file(const char *path, acl_type_t type); }
	231	SYS___ACL_DELETE_FD = 352 // { int __acl_delete_fd(int filedes, acl_type_t type); }
	232	SYS___ACL_ACLCHECK_FILE = 353 // { int __acl_aclcheck_file(const char path, acl_type_t type, struct acl aclp); }
	233	SYS___ACL_ACLCHECK_FD = 354 // { int __acl_aclcheck_fd(int filedes, acl_type_t type, struct acl *aclp); }
	234	SYS_EXTATTRCTL = 355 // { int extattrctl(const char path, int cmd, const char filename, int attrnamespace, const char *attrname); }
	235	SYS_EXTATTR_SET_FILE = 356 // { ssize_t extattr_set_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	236	SYS_EXTATTR_GET_FILE = 357 // { ssize_t extattr_get_file( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	237	SYS_EXTATTR_DELETE_FILE = 358 // { int extattr_delete_file(const char path, int attrnamespace, const char attrname); }
	238	SYS_AIO_WAITCOMPLETE = 359 // { int aio_waitcomplete( struct aiocb *aiocbp, struct timespec timeout); }
	239	SYS_GETRESUID = 360 // { int getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	240	SYS_GETRESGID = 361 // { int getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
241	241	SYS_KQUEUE = 362 // { int kqueue(void); }
242		SYS_KEVENT = 363 // { int kevent(int fd, \
243		SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, \
244		SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, \
245		SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, \
	242	SYS_KEVENT = 363 // { int kevent(int fd, struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
	243	SYS_EXTATTR_SET_FD = 371 // { ssize_t extattr_set_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	244	SYS_EXTATTR_GET_FD = 372 // { ssize_t extattr_get_fd(int fd, int attrnamespace, const char attrname, void data, size_t nbytes); }
	245	SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, int attrnamespace, const char *attrname); }
246	246	SYS___SETUGID = 374 // { int __setugid(int flag); }
247	247	SYS_EACCESS = 376 // { int eaccess(char *path, int amode); }
248		SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, \
	248	SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, unsigned int iovcnt, int flags); }
249	249	SYS___MAC_GET_PROC = 384 // { int __mac_get_proc(struct mac *mac_p); }
250	250	SYS___MAC_SET_PROC = 385 // { int __mac_set_proc(struct mac *mac_p); }
251		SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, \
252		SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char *path_p, \
253		SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, \
254		SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char *path_p, \
255		SYS_KENV = 390 // { int kenv(int what, const char *name, \
256		SYS_LCHFLAGS = 391 // { int lchflags(const char *path, \
257		SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, \
258		SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, \
259		SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char *policy, \
260		SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, \
261		SYS_STATFS = 396 // { int statfs(char *path, \
	251	SYS___MAC_GET_FD = 386 // { int __mac_get_fd(int fd, struct mac *mac_p); }
	252	SYS___MAC_GET_FILE = 387 // { int __mac_get_file(const char path_p, struct mac mac_p); }
	253	SYS___MAC_SET_FD = 388 // { int __mac_set_fd(int fd, struct mac *mac_p); }
	254	SYS___MAC_SET_FILE = 389 // { int __mac_set_file(const char path_p, struct mac mac_p); }
	255	SYS_KENV = 390 // { int kenv(int what, const char name, char value, int len); }
	256	SYS_LCHFLAGS = 391 // { int lchflags(const char *path, u_long flags); }
	257	SYS_UUIDGEN = 392 // { int uuidgen(struct uuid *store, int count); }
	258	SYS_SENDFILE = 393 // { int sendfile(int fd, int s, off_t offset, size_t nbytes, struct sf_hdtr hdtr, off_t sbytes, int flags); }
	259	SYS_MAC_SYSCALL = 394 // { int mac_syscall(const char policy, int call, void arg); }
	260	SYS_GETFSSTAT = 395 // { int getfsstat(struct statfs *buf, long bufsize, int flags); }
	261	SYS_STATFS = 396 // { int statfs(char path, struct statfs buf); }
262	262	SYS_FSTATFS = 397 // { int fstatfs(int fd, struct statfs *buf); }
263		SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle *u_fhp, \
	263	SYS_FHSTATFS = 398 // { int fhstatfs(const struct fhandle u_fhp, struct statfs buf); }
264	264	SYS_KSEM_CLOSE = 400 // { int ksem_close(semid_t id); }
265	265	SYS_KSEM_POST = 401 // { int ksem_post(semid_t id); }
266	266	SYS_KSEM_WAIT = 402 // { int ksem_wait(semid_t id); }
267	267	SYS_KSEM_TRYWAIT = 403 // { int ksem_trywait(semid_t id); }
268		SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, \
269		SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t *idp, \
	268	SYS_KSEM_INIT = 404 // { int ksem_init(semid_t *idp, unsigned int value); }
	269	SYS_KSEM_OPEN = 405 // { int ksem_open(semid_t idp, const char name, int oflag, mode_t mode, unsigned int value); }
270	270	SYS_KSEM_UNLINK = 406 // { int ksem_unlink(const char *name); }
271	271	SYS_KSEM_GETVALUE = 407 // { int ksem_getvalue(semid_t id, int *val); }
272	272	SYS_KSEM_DESTROY = 408 // { int ksem_destroy(semid_t id); }
273		SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, \
274		SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char *path_p, \
275		SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char *path_p, \
276		SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( \
277		SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( \
278		SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( \
279		SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char *argv, \
280		SYS_SIGACTION = 416 // { int sigaction(int sig, \
281		SYS_SIGRETURN = 417 // { int sigreturn( \
	273	SYS___MAC_GET_PID = 409 // { int __mac_get_pid(pid_t pid, struct mac *mac_p); }
	274	SYS___MAC_GET_LINK = 410 // { int __mac_get_link(const char path_p, struct mac mac_p); }
	275	SYS___MAC_SET_LINK = 411 // { int __mac_set_link(const char path_p, struct mac mac_p); }
	276	SYS_EXTATTR_SET_LINK = 412 // { ssize_t extattr_set_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	277	SYS_EXTATTR_GET_LINK = 413 // { ssize_t extattr_get_link( const char path, int attrnamespace, const char attrname, void *data, size_t nbytes); }
	278	SYS_EXTATTR_DELETE_LINK = 414 // { int extattr_delete_link( const char path, int attrnamespace, const char attrname); }
	279	SYS___MAC_EXECVE = 415 // { int __mac_execve(char fname, char argv, char envv, struct mac mac_p); }
	280	SYS_SIGACTION = 416 // { int sigaction(int sig, const struct sigaction act, struct sigaction oact); }
	281	SYS_SIGRETURN = 417 // { int sigreturn( const struct __ucontext *sigcntxp); }
282	282	SYS_GETCONTEXT = 421 // { int getcontext(struct __ucontext *ucp); }
283		SYS_SETCONTEXT = 422 // { int setcontext( \
284		SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext *oucp, \
	283	SYS_SETCONTEXT = 422 // { int setcontext( const struct __ucontext *ucp); }
	284	SYS_SWAPCONTEXT = 423 // { int swapcontext(struct __ucontext oucp, const struct __ucontext ucp); }
285	285	SYS_SWAPOFF = 424 // { int swapoff(const char *name); }
286		SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char *path, \
287		SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char *path, \
288		SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, \
289		SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char *path, \
290		SYS_SIGWAIT = 429 // { int sigwait(const sigset_t *set, \
291		SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, \
	286	SYS___ACL_GET_LINK = 425 // { int __acl_get_link(const char path, acl_type_t type, struct acl aclp); }
	287	SYS___ACL_SET_LINK = 426 // { int __acl_set_link(const char path, acl_type_t type, struct acl aclp); }
	288	SYS___ACL_DELETE_LINK = 427 // { int __acl_delete_link(const char *path, acl_type_t type); }
	289	SYS___ACL_ACLCHECK_LINK = 428 // { int __acl_aclcheck_link(const char path, acl_type_t type, struct acl aclp); }
	290	SYS_SIGWAIT = 429 // { int sigwait(const sigset_t set, int sig); }
	291	SYS_THR_CREATE = 430 // { int thr_create(ucontext_t ctx, long id, int flags); }
292	292	SYS_THR_EXIT = 431 // { void thr_exit(long *state); }
293	293	SYS_THR_SELF = 432 // { int thr_self(long *id); }
294	294	SYS_THR_KILL = 433 // { int thr_kill(long id, int sig); }
295	295	SYS__UMTX_LOCK = 434 // { int _umtx_lock(struct umtx *umtx); }
296	296	SYS__UMTX_UNLOCK = 435 // { int _umtx_unlock(struct umtx *umtx); }
297	297	SYS_JAIL_ATTACH = 436 // { int jail_attach(int jid); }
298		SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, \
299		SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( \
300		SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( \
301		SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, \
302		SYS_THR_SUSPEND = 442 // { int thr_suspend( \
	298	SYS_EXTATTR_LIST_FD = 437 // { ssize_t extattr_list_fd(int fd, int attrnamespace, void *data, size_t nbytes); }
	299	SYS_EXTATTR_LIST_FILE = 438 // { ssize_t extattr_list_file( const char path, int attrnamespace, void data, size_t nbytes); }
	300	SYS_EXTATTR_LIST_LINK = 439 // { ssize_t extattr_list_link( const char path, int attrnamespace, void data, size_t nbytes); }
	301	SYS_KSEM_TIMEDWAIT = 441 // { int ksem_timedwait(semid_t id, const struct timespec *abstime); }
	302	SYS_THR_SUSPEND = 442 // { int thr_suspend( const struct timespec *timeout); }
303	303	SYS_THR_WAKE = 443 // { int thr_wake(long id); }
304	304	SYS_KLDUNLOADF = 444 // { int kldunloadf(int fileid, int flags); }
305		SYS_AUDIT = 445 // { int audit(const void *record, \
306		SYS_AUDITON = 446 // { int auditon(int cmd, void *data, \
	305	SYS_AUDIT = 445 // { int audit(const void *record, u_int length); }
	306	SYS_AUDITON = 446 // { int auditon(int cmd, void *data, u_int length); }
307	307	SYS_GETAUID = 447 // { int getauid(uid_t *auid); }
308	308	SYS_SETAUID = 448 // { int setauid(uid_t *auid); }
309	309	SYS_GETAUDIT = 449 // { int getaudit(struct auditinfo *auditinfo); }
310	310	SYS_SETAUDIT = 450 // { int setaudit(struct auditinfo *auditinfo); }
311		SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( \
312		SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( \
	311	SYS_GETAUDIT_ADDR = 451 // { int getaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
	312	SYS_SETAUDIT_ADDR = 452 // { int setaudit_addr( struct auditinfo_addr *auditinfo_addr, u_int length); }
313	313	SYS_AUDITCTL = 453 // { int auditctl(char *path); }
314		SYS__UMTX_OP = 454 // { int _umtx_op(void *obj, int op, \
315		SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, \
	314	SYS__UMTX_OP = 454 // { int _umtx_op(void obj, int op, u_long val, void uaddr1, void *uaddr2); }
	315	SYS_THR_NEW = 455 // { int thr_new(struct thr_param *param, int param_size); }
316	316	SYS_SIGQUEUE = 456 // { int sigqueue(pid_t pid, int signum, void *value); }
317		SYS_KMQ_OPEN = 457 // { int kmq_open(const char *path, int flags, \
318		SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, \
319		SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, \
320		SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, \
321		SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, \
	317	SYS_KMQ_OPEN = 457 // { int kmq_open(const char path, int flags, mode_t mode, const struct mq_attr attr); }
	318	SYS_KMQ_SETATTR = 458 // { int kmq_setattr(int mqd, const struct mq_attr attr, struct mq_attr oattr); }
	319	SYS_KMQ_TIMEDRECEIVE = 459 // { int kmq_timedreceive(int mqd, char msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout); }
	320	SYS_KMQ_TIMEDSEND = 460 // { int kmq_timedsend(int mqd, const char msg_ptr, size_t msg_len,unsigned msg_prio, const struct timespec abs_timeout);}
	321	SYS_KMQ_NOTIFY = 461 // { int kmq_notify(int mqd, const struct sigevent *sigev); }
322	322	SYS_KMQ_UNLINK = 462 // { int kmq_unlink(const char *path); }
323	323	SYS_ABORT2 = 463 // { int abort2(const char why, int nargs, void *args); }
324	324	SYS_THR_SET_NAME = 464 // { int thr_set_name(long id, const char *name); }
325	325	SYS_AIO_FSYNC = 465 // { int aio_fsync(int op, struct aiocb *aiocbp); }
326		SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, \
	326	SYS_RTPRIO_THREAD = 466 // { int rtprio_thread(int function, lwpid_t lwpid, struct rtprio *rtp); }
327	327	SYS_SCTP_PEELOFF = 471 // { int sctp_peeloff(int sd, uint32_t name); }
328		SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, \
329		SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec *iov, int iovlen, \
330		SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec *iov, int iovlen, \
331		SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, \
332		SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, \
333		SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, \
334		SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, \
	328	SYS_SCTP_GENERIC_SENDMSG = 472 // { int sctp_generic_sendmsg(int sd, caddr_t msg, int mlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo *sinfo, int flags); }
	329	SYS_SCTP_GENERIC_SENDMSG_IOV = 473 // { int sctp_generic_sendmsg_iov(int sd, struct iovec iov, int iovlen, caddr_t to, __socklen_t tolen, struct sctp_sndrcvinfo sinfo, int flags); }
	330	SYS_SCTP_GENERIC_RECVMSG = 474 // { int sctp_generic_recvmsg(int sd, struct iovec iov, int iovlen, struct sockaddr from, __socklen_t fromlenaddr, struct sctp_sndrcvinfo sinfo, int *msg_flags); }
	331	SYS_PREAD = 475 // { ssize_t pread(int fd, void *buf, size_t nbyte, off_t offset); }
	332	SYS_PWRITE = 476 // { ssize_t pwrite(int fd, const void *buf, size_t nbyte, off_t offset); }
	333	SYS_MMAP = 477 // { caddr_t mmap(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos); }
	334	SYS_LSEEK = 478 // { off_t lseek(int fd, off_t offset, int whence); }
335	335	SYS_TRUNCATE = 479 // { int truncate(char *path, off_t length); }
336	336	SYS_FTRUNCATE = 480 // { int ftruncate(int fd, off_t length); }
337	337	SYS_THR_KILL2 = 481 // { int thr_kill2(pid_t pid, long id, int sig); }
338		SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, \
	338	SYS_SHM_OPEN = 482 // { int shm_open(const char *path, int flags, mode_t mode); }
339	339	SYS_SHM_UNLINK = 483 // { int shm_unlink(const char *path); }
340	340	SYS_CPUSET = 484 // { int cpuset(cpusetid_t *setid); }
341		SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, \
342		SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, \
343		SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, \
344		SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, \
345		SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, \
346		SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, \
347		SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, \
348		SYS_FEXECVE = 492 // { int fexecve(int fd, char **argv, \
349		SYS_FSTATAT = 493 // { int fstatat(int fd, char *path, \
350		SYS_FUTIMESAT = 494 // { int futimesat(int fd, char *path, \
351		SYS_LINKAT = 495 // { int linkat(int fd1, char *path1, int fd2, \
	341	SYS_CPUSET_SETID = 485 // { int cpuset_setid(cpuwhich_t which, id_t id, cpusetid_t setid); }
	342	SYS_CPUSET_GETID = 486 // { int cpuset_getid(cpulevel_t level, cpuwhich_t which, id_t id, cpusetid_t *setid); }
	343	SYS_CPUSET_GETAFFINITY = 487 // { int cpuset_getaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, cpuset_t *mask); }
	344	SYS_CPUSET_SETAFFINITY = 488 // { int cpuset_setaffinity(cpulevel_t level, cpuwhich_t which, id_t id, size_t cpusetsize, const cpuset_t *mask); }
	345	SYS_FACCESSAT = 489 // { int faccessat(int fd, char *path, int amode, int flag); }
	346	SYS_FCHMODAT = 490 // { int fchmodat(int fd, char *path, mode_t mode, int flag); }
	347	SYS_FCHOWNAT = 491 // { int fchownat(int fd, char *path, uid_t uid, gid_t gid, int flag); }
	348	SYS_FEXECVE = 492 // { int fexecve(int fd, char argv, char envv); }
	349	SYS_FSTATAT = 493 // { int fstatat(int fd, char path, struct stat buf, int flag); }
	350	SYS_FUTIMESAT = 494 // { int futimesat(int fd, char path, struct timeval times); }
	351	SYS_LINKAT = 495 // { int linkat(int fd1, char path1, int fd2, char path2, int flag); }
352	352	SYS_MKDIRAT = 496 // { int mkdirat(int fd, char *path, mode_t mode); }
353	353	SYS_MKFIFOAT = 497 // { int mkfifoat(int fd, char *path, mode_t mode); }
354		SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, \
355		SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, \
356		SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, \
357		SYS_RENAMEAT = 501 // { int renameat(int oldfd, char *old, int newfd, \
358		SYS_SYMLINKAT = 502 // { int symlinkat(char *path1, int fd, \
	354	SYS_MKNODAT = 498 // { int mknodat(int fd, char *path, mode_t mode, dev_t dev); }
	355	SYS_OPENAT = 499 // { int openat(int fd, char *path, int flag, mode_t mode); }
	356	SYS_READLINKAT = 500 // { int readlinkat(int fd, char path, char buf, size_t bufsize); }
	357	SYS_RENAMEAT = 501 // { int renameat(int oldfd, char old, int newfd, char new); }
	358	SYS_SYMLINKAT = 502 // { int symlinkat(char path1, int fd, char path2); }
359	359	SYS_UNLINKAT = 503 // { int unlinkat(int fd, char *path, int flag); }
360	360	SYS_POSIX_OPENPT = 504 // { int posix_openpt(int flags); }
361	361	SYS_GSSD_SYSCALL = 505 // { int gssd_syscall(char *path); }
362		SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, \
363		SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, \
	362	SYS_JAIL_GET = 506 // { int jail_get(struct iovec *iovp, unsigned int iovcnt, int flags); }
	363	SYS_JAIL_SET = 507 // { int jail_set(struct iovec *iovp, unsigned int iovcnt, int flags); }
364	364	SYS_JAIL_REMOVE = 508 // { int jail_remove(int jid); }
365	365	SYS_CLOSEFROM = 509 // { int closefrom(int lowfd); }
366		SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, \
367		SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, \
368		SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, \
	366	SYS___SEMCTL = 510 // { int __semctl(int semid, int semnum, int cmd, union semun *arg); }
	367	SYS_MSGCTL = 511 // { int msgctl(int msqid, int cmd, struct msqid_ds *buf); }
	368	SYS_SHMCTL = 512 // { int shmctl(int shmid, int cmd, struct shmid_ds *buf); }
369	369	SYS_LPATHCONF = 513 // { int lpathconf(char *path, int name); }
370		SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, \
	370	SYS___CAP_RIGHTS_GET = 515 // { int __cap_rights_get(int version, int fd, cap_rights_t *rightsp); }
371	371	SYS_CAP_ENTER = 516 // { int cap_enter(void); }
372	372	SYS_CAP_GETMODE = 517 // { int cap_getmode(u_int *modep); }
373	373	SYS_PDFORK = 518 // { int pdfork(int *fdp, int flags); }
374	374	SYS_PDKILL = 519 // { int pdkill(int fd, int signum); }
375	375	SYS_PDGETPID = 520 // { int pdgetpid(int fd, pid_t *pidp); }
376		SYS_PSELECT = 522 // { int pselect(int nd, fd_set *in, \
377		SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, \
	376	SYS_PSELECT = 522 // { int pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *sm); }
	377	SYS_GETLOGINCLASS = 523 // { int getloginclass(char *namebuf, size_t namelen); }
378	378	SYS_SETLOGINCLASS = 524 // { int setloginclass(const char *namebuf); }
379		SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void *inbufp, \
380		SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void *inbufp, \
381		SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void *inbufp, \
382		SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void *inbufp, \
383		SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void *inbufp, \
384		SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, \
385		SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, \
386		SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, \
387		SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, \
388		SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, \
389		SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, \
390		SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, \
391		SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, \
392		SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, \
393		SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, \
394		SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, \
395		SYS_ACCEPT4 = 541 // { int accept4(int s, \
	379	SYS_RCTL_GET_RACCT = 525 // { int rctl_get_racct(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	380	SYS_RCTL_GET_RULES = 526 // { int rctl_get_rules(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	381	SYS_RCTL_GET_LIMITS = 527 // { int rctl_get_limits(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	382	SYS_RCTL_ADD_RULE = 528 // { int rctl_add_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	383	SYS_RCTL_REMOVE_RULE = 529 // { int rctl_remove_rule(const void inbufp, size_t inbuflen, void outbufp, size_t outbuflen); }
	384	SYS_POSIX_FALLOCATE = 530 // { int posix_fallocate(int fd, off_t offset, off_t len); }
	385	SYS_POSIX_FADVISE = 531 // { int posix_fadvise(int fd, off_t offset, off_t len, int advice); }
	386	SYS_WAIT6 = 532 // { int wait6(idtype_t idtype, id_t id, int status, int options, struct __wrusage wrusage, siginfo_t *info); }
	387	SYS_CAP_RIGHTS_LIMIT = 533 // { int cap_rights_limit(int fd, cap_rights_t *rightsp); }
	388	SYS_CAP_IOCTLS_LIMIT = 534 // { int cap_ioctls_limit(int fd, const u_long *cmds, size_t ncmds); }
	389	SYS_CAP_IOCTLS_GET = 535 // { ssize_t cap_ioctls_get(int fd, u_long *cmds, size_t maxcmds); }
	390	SYS_CAP_FCNTLS_LIMIT = 536 // { int cap_fcntls_limit(int fd, uint32_t fcntlrights); }
	391	SYS_CAP_FCNTLS_GET = 537 // { int cap_fcntls_get(int fd, uint32_t *fcntlrightsp); }
	392	SYS_BINDAT = 538 // { int bindat(int fd, int s, caddr_t name, int namelen); }
	393	SYS_CONNECTAT = 539 // { int connectat(int fd, int s, caddr_t name, int namelen); }
	394	SYS_CHFLAGSAT = 540 // { int chflagsat(int fd, const char *path, u_long flags, int atflag); }
	395	SYS_ACCEPT4 = 541 // { int accept4(int s, struct sockaddr * __restrict name, __socklen_t * __restrict anamelen, int flags); }
396	396	SYS_PIPE2 = 542 // { int pipe2(int *fildes, int flags); }
397	397	SYS_AIO_MLOCK = 543 // { int aio_mlock(struct aiocb *aiocbp); }
398		SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, \
399		SYS_PPOLL = 545 // { int ppoll(struct pollfd *fds, u_int nfds, \
400		SYS_FUTIMENS = 546 // { int futimens(int fd, \
401		SYS_UTIMENSAT = 547 // { int utimensat(int fd, \
	398	SYS_PROCCTL = 544 // { int procctl(idtype_t idtype, id_t id, int com, void *data); }
	399	SYS_PPOLL = 545 // { int ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *set); }
	400	SYS_FUTIMENS = 546 // { int futimens(int fd, struct timespec *times); }
	401	SYS_UTIMENSAT = 547 // { int utimensat(int fd, char path, struct timespec times, int flag); }
402	402	)

-2

unix/zsysnum_linux_sparc64.go less more

0		// mksysnum_linux.pl -Ilinux/usr/include -m64 -D__arch64__ linux/usr/include/asm/unistd.h
1		// Code generated by the command above; DO NOT EDIT.
	0	// go run linux/mksysnum.go -Wall -Werror -static -I/tmp/include /tmp/include/asm/unistd.h
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build sparc64,linux
4	4

344	344	SYS_COPY_FILE_RANGE = 357
345	345	SYS_PREADV2 = 358
346	346	SYS_PWRITEV2 = 359
	347	SYS_STATX = 360
	348	SYS_IO_PGETEVENTS = 361
347	349	)

-2

unix/zsysnum_netbsd_386.go less more

0		// mksysnum_netbsd.pl
1		// Code generated by the command above; DO NOT EDIT.
	0	// go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build 386,netbsd
4	4

-2

unix/zsysnum_netbsd_amd64.go less more

0		// mksysnum_netbsd.pl
1		// Code generated by the command above; DO NOT EDIT.
	0	// go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build amd64,netbsd
4	4

-2

unix/zsysnum_netbsd_arm.go less more

0		// mksysnum_netbsd.pl
1		// Code generated by the command above; DO NOT EDIT.
	0	// go run mksysnum.go http://cvsweb.netbsd.org/bsdweb.cgi/~checkout~/src/sys/kern/syscalls.master
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build arm,netbsd
4	4

+108

-108

unix/zsysnum_openbsd_386.go less more

0		// mksysnum_openbsd.pl
	0	// go run mksysnum.go http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build 386,openbsd

8	8	SYS_EXIT = 1 // { void sys_exit(int rval); }
9	9	SYS_FORK = 2 // { int sys_fork(void); }
10	10	SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
11		SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \
12		SYS_OPEN = 5 // { int sys_open(const char *path, \
	11	SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, size_t nbyte); }
	12	SYS_OPEN = 5 // { int sys_open(const char *path, int flags, ... mode_t mode); }
13	13	SYS_CLOSE = 6 // { int sys_close(int fd); }
14	14	SYS_GETENTROPY = 7 // { int sys_getentropy(void *buf, size_t nbyte); }
15		SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \
	15	SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, size_t psize); }
16	16	SYS_LINK = 9 // { int sys_link(const char path, const char link); }
17	17	SYS_UNLINK = 10 // { int sys_unlink(const char *path); }
18		SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \
	18	SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int status, int options, struct rusage rusage); }
19	19	SYS_CHDIR = 12 // { int sys_chdir(const char *path); }
20	20	SYS_FCHDIR = 13 // { int sys_fchdir(int fd); }
21		SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \
	21	SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, dev_t dev); }
22	22	SYS_CHMOD = 15 // { int sys_chmod(const char *path, mode_t mode); }
23		SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \
	23	SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, gid_t gid); }
24	24	SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break
25	25	SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); }
26		SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \
	26	SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, struct rusage *rusage); }
27	27	SYS_GETPID = 20 // { pid_t sys_getpid(void); }
28		SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, \
	28	SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, int flags, void *data); }
29	29	SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); }
30	30	SYS_SETUID = 23 // { int sys_setuid(uid_t uid); }
31	31	SYS_GETUID = 24 // { uid_t sys_getuid(void); }
32	32	SYS_GETEUID = 25 // { uid_t sys_geteuid(void); }
33		SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
34		SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
35		SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, \
36		SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
37		SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr *name, \
38		SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr *asa, \
39		SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr *asa, \
	33	SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, int data); }
	34	SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, int flags); }
	35	SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, const struct msghdr *msg, int flags); }
	36	SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void buf, size_t len, int flags, struct sockaddr from, socklen_t *fromlenaddr); }
	37	SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr name, socklen_t anamelen); }
	38	SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr asa, socklen_t alen); }
	39	SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr asa, socklen_t alen); }
40	40	SYS_ACCESS = 33 // { int sys_access(const char *path, int amode); }
41	41	SYS_CHFLAGS = 34 // { int sys_chflags(const char *path, u_int flags); }
42	42	SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); }

45	45	SYS_GETPPID = 39 // { pid_t sys_getppid(void); }
46	46	SYS_LSTAT = 40 // { int sys_lstat(const char path, struct stat ub); }
47	47	SYS_DUP = 41 // { int sys_dup(int fd); }
48		SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \
	48	SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char path, struct stat buf, int flag); }
49	49	SYS_GETEGID = 43 // { gid_t sys_getegid(void); }
50		SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \
51		SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \
52		SYS_SIGACTION = 46 // { int sys_sigaction(int signum, \
	50	SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, u_long offset, u_int scale); }
	51	SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, int facs, pid_t pid); }
	52	SYS_SIGACTION = 46 // { int sys_sigaction(int signum, const struct sigaction nsa, struct sigaction osa); }
53	53	SYS_GETGID = 47 // { gid_t sys_getgid(void); }
54	54	SYS_SIGPROCMASK = 48 // { int sys_sigprocmask(int how, sigset_t mask); }
55	55	SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); }
56	56	SYS_ACCT = 51 // { int sys_acct(const char *path); }
57	57	SYS_SIGPENDING = 52 // { int sys_sigpending(void); }
58	58	SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); }
59		SYS_IOCTL = 54 // { int sys_ioctl(int fd, \
	59	SYS_IOCTL = 54 // { int sys_ioctl(int fd, u_long com, ... void *data); }
60	60	SYS_REBOOT = 55 // { int sys_reboot(int opt); }
61	61	SYS_REVOKE = 56 // { int sys_revoke(const char *path); }
62		SYS_SYMLINK = 57 // { int sys_symlink(const char *path, \
63		SYS_READLINK = 58 // { ssize_t sys_readlink(const char *path, \
64		SYS_EXECVE = 59 // { int sys_execve(const char *path, \
	62	SYS_SYMLINK = 57 // { int sys_symlink(const char path, const char link); }
	63	SYS_READLINK = 58 // { ssize_t sys_readlink(const char path, char buf, size_t count); }
	64	SYS_EXECVE = 59 // { int sys_execve(const char path, char const argp, char const *envp); }
65	65	SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); }
66	66	SYS_CHROOT = 61 // { int sys_chroot(const char *path); }
67		SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \
68		SYS_STATFS = 63 // { int sys_statfs(const char *path, \
	67	SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, int flags); }
	68	SYS_STATFS = 63 // { int sys_statfs(const char path, struct statfs buf); }
69	69	SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); }
70		SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \
	70	SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t fhp, struct statfs buf); }
71	71	SYS_VFORK = 66 // { int sys_vfork(void); }
72		SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \
73		SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \
74		SYS_SETITIMER = 69 // { int sys_setitimer(int which, \
75		SYS_GETITIMER = 70 // { int sys_getitimer(int which, \
76		SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, \
77		SYS_KEVENT = 72 // { int sys_kevent(int fd, \
	72	SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval tp, struct timezone tzp); }
	73	SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval tv, const struct timezone tzp); }
	74	SYS_SETITIMER = 69 // { int sys_setitimer(int which, const struct itimerval itv, struct itimerval oitv); }
	75	SYS_GETITIMER = 70 // { int sys_getitimer(int which, struct itimerval *itv); }
	76	SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
	77	SYS_KEVENT = 72 // { int sys_kevent(int fd, const struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
78	78	SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); }
79		SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \
80		SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \
81		SYS_UTIMES = 76 // { int sys_utimes(const char *path, \
82		SYS_FUTIMES = 77 // { int sys_futimes(int fd, \
83		SYS_MINCORE = 78 // { int sys_mincore(void *addr, size_t len, \
84		SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \
85		SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \
	79	SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, int prot); }
	80	SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, int behav); }
	81	SYS_UTIMES = 76 // { int sys_utimes(const char path, const struct timeval tptr); }
	82	SYS_FUTIMES = 77 // { int sys_futimes(int fd, const struct timeval *tptr); }
	83	SYS_MINCORE = 78 // { int sys_mincore(void addr, size_t len, char vec); }
	84	SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, gid_t *gidset); }
	85	SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, const gid_t *gidset); }
86	86	SYS_GETPGRP = 81 // { int sys_getpgrp(void); }
87	87	SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, pid_t pgid); }
88		SYS_FUTEX = 83 // { int sys_futex(uint32_t *f, int op, int val, \
89		SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \
90		SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \
91		SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, \
92		SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \
93		SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \
94		SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \
	88	SYS_FUTEX = 83 // { int sys_futex(uint32_t f, int op, int val, const struct timespec timeout, uint32_t *g); }
	89	SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char path, const struct timespec times, int flag); }
	90	SYS_FUTIMENS = 85 // { int sys_futimens(int fd, const struct timespec *times); }
	91	SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, size_t psize, int64_t proc_cookie); }
	92	SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, struct timespec *tp); }
	93	SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, const struct timespec *tp); }
	94	SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, struct timespec *tp); }
95	95	SYS_DUP2 = 90 // { int sys_dup2(int from, int to); }
96		SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \
	96	SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec rqtp, struct timespec rmtp); }
97	97	SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); }
98		SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr *name, \
99		SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \
	98	SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr name, socklen_t anamelen, int flags); }
	99	SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void ident, clockid_t clock_id, const struct timespec tp, void lock, const int abort); }
100	100	SYS_FSYNC = 95 // { int sys_fsync(int fd); }
101	101	SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); }
102	102	SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); }
103		SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \
	103	SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, socklen_t namelen); }
104	104	SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); }
105	105	SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); }
106	106	SYS_PIPE2 = 101 // { int sys_pipe2(int *fdp, int flags); }
107	107	SYS_DUP3 = 102 // { int sys_dup3(int from, int to, int flags); }
108	108	SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); }
109		SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \
110		SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \
	109	SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, socklen_t namelen); }
	110	SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, const void *val, socklen_t valsize); }
111	111	SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); }
112		SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, \
113		SYS_PLEDGE = 108 // { int sys_pledge(const char *promises, \
114		SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \
115		SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, \
	112	SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, u_int flags, int atflags); }
	113	SYS_PLEDGE = 108 // { int sys_pledge(const char promises, const char execpromises); }
	114	SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *mask); }
	115	SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *mask); }
116	116	SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); }
117		SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, \
118		SYS_UNVEIL = 114 // { int sys_unveil(const char *path, \
119		SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \
	117	SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, int flags); }
	118	SYS_UNVEIL = 114 // { int sys_unveil(const char path, const char permissions); }
	119	SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, void val, socklen_t avalsize); }
120	120	SYS_THRKILL = 119 // { int sys_thrkill(pid_t tid, int signum, void *tcb); }
121		SYS_READV = 120 // { ssize_t sys_readv(int fd, \
122		SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \
	121	SYS_READV = 120 // { ssize_t sys_readv(int fd, const struct iovec *iovp, int iovcnt); }
	122	SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, const struct iovec *iovp, int iovcnt); }
123	123	SYS_KILL = 122 // { int sys_kill(int pid, int signum); }
124	124	SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); }
125	125	SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); }

128	128	SYS_RENAME = 128 // { int sys_rename(const char from, const char to); }
129	129	SYS_FLOCK = 131 // { int sys_flock(int fd, int how); }
130	130	SYS_MKFIFO = 132 // { int sys_mkfifo(const char *path, mode_t mode); }
131		SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void *buf, \
	131	SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void buf, size_t len, int flags, const struct sockaddr to, socklen_t tolen); }
132	132	SYS_SHUTDOWN = 134 // { int sys_shutdown(int s, int how); }
133		SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \
	133	SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, int protocol, int *rsv); }
134	134	SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); }
135	135	SYS_RMDIR = 137 // { int sys_rmdir(const char *path); }
136		SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \
	136	SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval delta, struct timeval olddelta); }
137	137	SYS_GETLOGIN_R = 141 // { int sys_getlogin_r(char *namebuf, u_int namelen); }
138	138	SYS_SETSID = 147 // { int sys_setsid(void); }
139		SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \
	139	SYS_QUOTACTL = 148 // { int sys_quotactl(const char path, int cmd, int uid, char arg); }
140	140	SYS_NFSSVC = 155 // { int sys_nfssvc(int flag, void *argp); }
141	141	SYS_GETFH = 161 // { int sys_getfh(const char fname, fhandle_t fhp); }
142	142	SYS_SYSARCH = 165 // { int sys_sysarch(int op, void *parms); }
143		SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, \
144		SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, \
	143	SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	144	SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
145	145	SYS_SETGID = 181 // { int sys_setgid(gid_t gid); }
146	146	SYS_SETEGID = 182 // { int sys_setegid(gid_t egid); }
147	147	SYS_SETEUID = 183 // { int sys_seteuid(uid_t euid); }
148	148	SYS_PATHCONF = 191 // { long sys_pathconf(const char *path, int name); }
149	149	SYS_FPATHCONF = 192 // { long sys_fpathconf(int fd, int name); }
150	150	SYS_SWAPCTL = 193 // { int sys_swapctl(int cmd, const void *arg, int misc); }
151		SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, \
152		SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, \
153		SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, \
154		SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, \
155		SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, \
	151	SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, struct rlimit *rlp); }
	152	SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, const struct rlimit *rlp); }
	153	SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
	154	SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, int whence); }
	155	SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, off_t length); }
156	156	SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); }
157		SYS_SYSCTL = 202 // { int sys_sysctl(const int *name, u_int namelen, \
	157	SYS_SYSCTL = 202 // { int sys_sysctl(const int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); }
158	158	SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); }
159	159	SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); }
160	160	SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); }
161		SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, \
	161	SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, size_t len); }
162	162	SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); }
163	163	SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); }
164		SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
165		SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
166		SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, \
	164	SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	165	SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	166	SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, int shmflg); }
167	167	SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); }
168		SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \
169		SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \
	168	SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, int inherit); }
	169	SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, u_int nfds, int timeout); }
170	170	SYS_ISSETUGID = 253 // { int sys_issetugid(void); }
171	171	SYS_LCHOWN = 254 // { int sys_lchown(const char *path, uid_t uid, gid_t gid); }
172	172	SYS_GETSID = 255 // { pid_t sys_getsid(pid_t pid); }
173	173	SYS_MSYNC = 256 // { int sys_msync(void *addr, size_t len, int flags); }
174	174	SYS_PIPE = 263 // { int sys_pipe(int *fdp); }
175	175	SYS_FHOPEN = 264 // { int sys_fhopen(const fhandle_t *fhp, int flags); }
176		SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, \
177		SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, \
	176	SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
	177	SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
178	178	SYS_KQUEUE = 269 // { int sys_kqueue(void); }
179	179	SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); }
180	180	SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); }
181		SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, \
182		SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, \
183		SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, \
184		SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, \
185		SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, \
	181	SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	182	SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	183	SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
	184	SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
	185	SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
186	186	SYS_CLOSEFROM = 287 // { int sys_closefrom(int fd); }
187		SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \
	187	SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack nss, struct sigaltstack oss); }
188	188	SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); }
189		SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \
190		SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \
191		SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \
192		SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \
193		SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \
	189	SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, size_t nsops); }
	190	SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t fhp, struct stat sb); }
	191	SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, union semun *arg); }
	192	SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, struct shmid_ds *buf); }
	193	SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, struct msqid_ds *buf); }
194	194	SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); }
195	195	SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); }
196		SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \
	196	SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, int n); }
197	197	SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); }
198		SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \
	198	SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, siginfo_t info, const struct timespec timeout); }
199	199	SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); }
200		SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \
	200	SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t freq, int64_t oldfreq); }
201	201	SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); }
202	202	SYS_GETRTABLE = 311 // { int sys_getrtable(void); }
203		SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \
204		SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \
205		SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \
206		SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \
207		SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \
208		SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \
209		SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, \
210		SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, \
211		SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char *path, \
212		SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \
213		SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \
214		SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \
	203	SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, int amode, int flag); }
	204	SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, mode_t mode, int flag); }
	205	SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, uid_t uid, gid_t gid, int flag); }
	206	SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char path1, int fd2, const char path2, int flag); }
	207	SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, mode_t mode); }
	208	SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, mode_t mode); }
	209	SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, mode_t mode, dev_t dev); }
	210	SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, ... mode_t mode); }
	211	SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char path, char buf, size_t count); }
	212	SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char from, int tofd, const char to); }
	213	SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char path, int fd, const char link); }
	214	SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, int flag); }
215	215	SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); }
216	216	SYS___GET_TCB = 330 // { void *sys___get_tcb(void); }
217	217	)

+108

-108

unix/zsysnum_openbsd_amd64.go less more

0		// mksysnum_openbsd.pl
	0	// go run mksysnum.go http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build amd64,openbsd

8	8	SYS_EXIT = 1 // { void sys_exit(int rval); }
9	9	SYS_FORK = 2 // { int sys_fork(void); }
10	10	SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
11		SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \
12		SYS_OPEN = 5 // { int sys_open(const char *path, \
	11	SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, size_t nbyte); }
	12	SYS_OPEN = 5 // { int sys_open(const char *path, int flags, ... mode_t mode); }
13	13	SYS_CLOSE = 6 // { int sys_close(int fd); }
14	14	SYS_GETENTROPY = 7 // { int sys_getentropy(void *buf, size_t nbyte); }
15		SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \
	15	SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, size_t psize); }
16	16	SYS_LINK = 9 // { int sys_link(const char path, const char link); }
17	17	SYS_UNLINK = 10 // { int sys_unlink(const char *path); }
18		SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \
	18	SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int status, int options, struct rusage rusage); }
19	19	SYS_CHDIR = 12 // { int sys_chdir(const char *path); }
20	20	SYS_FCHDIR = 13 // { int sys_fchdir(int fd); }
21		SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \
	21	SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, dev_t dev); }
22	22	SYS_CHMOD = 15 // { int sys_chmod(const char *path, mode_t mode); }
23		SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \
	23	SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, gid_t gid); }
24	24	SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break
25	25	SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); }
26		SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \
	26	SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, struct rusage *rusage); }
27	27	SYS_GETPID = 20 // { pid_t sys_getpid(void); }
28		SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, \
	28	SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, int flags, void *data); }
29	29	SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); }
30	30	SYS_SETUID = 23 // { int sys_setuid(uid_t uid); }
31	31	SYS_GETUID = 24 // { uid_t sys_getuid(void); }
32	32	SYS_GETEUID = 25 // { uid_t sys_geteuid(void); }
33		SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
34		SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
35		SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, \
36		SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
37		SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr *name, \
38		SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr *asa, \
39		SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr *asa, \
	33	SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, int data); }
	34	SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, int flags); }
	35	SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, const struct msghdr *msg, int flags); }
	36	SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void buf, size_t len, int flags, struct sockaddr from, socklen_t *fromlenaddr); }
	37	SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr name, socklen_t anamelen); }
	38	SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr asa, socklen_t alen); }
	39	SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr asa, socklen_t alen); }
40	40	SYS_ACCESS = 33 // { int sys_access(const char *path, int amode); }
41	41	SYS_CHFLAGS = 34 // { int sys_chflags(const char *path, u_int flags); }
42	42	SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); }

45	45	SYS_GETPPID = 39 // { pid_t sys_getppid(void); }
46	46	SYS_LSTAT = 40 // { int sys_lstat(const char path, struct stat ub); }
47	47	SYS_DUP = 41 // { int sys_dup(int fd); }
48		SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \
	48	SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char path, struct stat buf, int flag); }
49	49	SYS_GETEGID = 43 // { gid_t sys_getegid(void); }
50		SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \
51		SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \
52		SYS_SIGACTION = 46 // { int sys_sigaction(int signum, \
	50	SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, u_long offset, u_int scale); }
	51	SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, int facs, pid_t pid); }
	52	SYS_SIGACTION = 46 // { int sys_sigaction(int signum, const struct sigaction nsa, struct sigaction osa); }
53	53	SYS_GETGID = 47 // { gid_t sys_getgid(void); }
54	54	SYS_SIGPROCMASK = 48 // { int sys_sigprocmask(int how, sigset_t mask); }
55	55	SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); }
56	56	SYS_ACCT = 51 // { int sys_acct(const char *path); }
57	57	SYS_SIGPENDING = 52 // { int sys_sigpending(void); }
58	58	SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); }
59		SYS_IOCTL = 54 // { int sys_ioctl(int fd, \
	59	SYS_IOCTL = 54 // { int sys_ioctl(int fd, u_long com, ... void *data); }
60	60	SYS_REBOOT = 55 // { int sys_reboot(int opt); }
61	61	SYS_REVOKE = 56 // { int sys_revoke(const char *path); }
62		SYS_SYMLINK = 57 // { int sys_symlink(const char *path, \
63		SYS_READLINK = 58 // { ssize_t sys_readlink(const char *path, \
64		SYS_EXECVE = 59 // { int sys_execve(const char *path, \
	62	SYS_SYMLINK = 57 // { int sys_symlink(const char path, const char link); }
	63	SYS_READLINK = 58 // { ssize_t sys_readlink(const char path, char buf, size_t count); }
	64	SYS_EXECVE = 59 // { int sys_execve(const char path, char const argp, char const *envp); }
65	65	SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); }
66	66	SYS_CHROOT = 61 // { int sys_chroot(const char *path); }
67		SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \
68		SYS_STATFS = 63 // { int sys_statfs(const char *path, \
	67	SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, int flags); }
	68	SYS_STATFS = 63 // { int sys_statfs(const char path, struct statfs buf); }
69	69	SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); }
70		SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \
	70	SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t fhp, struct statfs buf); }
71	71	SYS_VFORK = 66 // { int sys_vfork(void); }
72		SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \
73		SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \
74		SYS_SETITIMER = 69 // { int sys_setitimer(int which, \
75		SYS_GETITIMER = 70 // { int sys_getitimer(int which, \
76		SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, \
77		SYS_KEVENT = 72 // { int sys_kevent(int fd, \
	72	SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval tp, struct timezone tzp); }
	73	SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval tv, const struct timezone tzp); }
	74	SYS_SETITIMER = 69 // { int sys_setitimer(int which, const struct itimerval itv, struct itimerval oitv); }
	75	SYS_GETITIMER = 70 // { int sys_getitimer(int which, struct itimerval *itv); }
	76	SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
	77	SYS_KEVENT = 72 // { int sys_kevent(int fd, const struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
78	78	SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); }
79		SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \
80		SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \
81		SYS_UTIMES = 76 // { int sys_utimes(const char *path, \
82		SYS_FUTIMES = 77 // { int sys_futimes(int fd, \
83		SYS_MINCORE = 78 // { int sys_mincore(void *addr, size_t len, \
84		SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \
85		SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \
	79	SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, int prot); }
	80	SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, int behav); }
	81	SYS_UTIMES = 76 // { int sys_utimes(const char path, const struct timeval tptr); }
	82	SYS_FUTIMES = 77 // { int sys_futimes(int fd, const struct timeval *tptr); }
	83	SYS_MINCORE = 78 // { int sys_mincore(void addr, size_t len, char vec); }
	84	SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, gid_t *gidset); }
	85	SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, const gid_t *gidset); }
86	86	SYS_GETPGRP = 81 // { int sys_getpgrp(void); }
87	87	SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, pid_t pgid); }
88		SYS_FUTEX = 83 // { int sys_futex(uint32_t *f, int op, int val, \
89		SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \
90		SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \
91		SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, \
92		SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \
93		SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \
94		SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \
	88	SYS_FUTEX = 83 // { int sys_futex(uint32_t f, int op, int val, const struct timespec timeout, uint32_t *g); }
	89	SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char path, const struct timespec times, int flag); }
	90	SYS_FUTIMENS = 85 // { int sys_futimens(int fd, const struct timespec *times); }
	91	SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, size_t psize, int64_t proc_cookie); }
	92	SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, struct timespec *tp); }
	93	SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, const struct timespec *tp); }
	94	SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, struct timespec *tp); }
95	95	SYS_DUP2 = 90 // { int sys_dup2(int from, int to); }
96		SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \
	96	SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec rqtp, struct timespec rmtp); }
97	97	SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); }
98		SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr *name, \
99		SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \
	98	SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr name, socklen_t anamelen, int flags); }
	99	SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void ident, clockid_t clock_id, const struct timespec tp, void lock, const int abort); }
100	100	SYS_FSYNC = 95 // { int sys_fsync(int fd); }
101	101	SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); }
102	102	SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); }
103		SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \
	103	SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, socklen_t namelen); }
104	104	SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); }
105	105	SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); }
106	106	SYS_PIPE2 = 101 // { int sys_pipe2(int *fdp, int flags); }
107	107	SYS_DUP3 = 102 // { int sys_dup3(int from, int to, int flags); }
108	108	SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); }
109		SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \
110		SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \
	109	SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, socklen_t namelen); }
	110	SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, const void *val, socklen_t valsize); }
111	111	SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); }
112		SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, \
113		SYS_PLEDGE = 108 // { int sys_pledge(const char *promises, \
114		SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \
115		SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, \
	112	SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, u_int flags, int atflags); }
	113	SYS_PLEDGE = 108 // { int sys_pledge(const char promises, const char execpromises); }
	114	SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *mask); }
	115	SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *mask); }
116	116	SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); }
117		SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, \
118		SYS_UNVEIL = 114 // { int sys_unveil(const char *path, \
119		SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \
	117	SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, int flags); }
	118	SYS_UNVEIL = 114 // { int sys_unveil(const char path, const char permissions); }
	119	SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, void val, socklen_t avalsize); }
120	120	SYS_THRKILL = 119 // { int sys_thrkill(pid_t tid, int signum, void *tcb); }
121		SYS_READV = 120 // { ssize_t sys_readv(int fd, \
122		SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \
	121	SYS_READV = 120 // { ssize_t sys_readv(int fd, const struct iovec *iovp, int iovcnt); }
	122	SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, const struct iovec *iovp, int iovcnt); }
123	123	SYS_KILL = 122 // { int sys_kill(int pid, int signum); }
124	124	SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); }
125	125	SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); }

128	128	SYS_RENAME = 128 // { int sys_rename(const char from, const char to); }
129	129	SYS_FLOCK = 131 // { int sys_flock(int fd, int how); }
130	130	SYS_MKFIFO = 132 // { int sys_mkfifo(const char *path, mode_t mode); }
131		SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void *buf, \
	131	SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void buf, size_t len, int flags, const struct sockaddr to, socklen_t tolen); }
132	132	SYS_SHUTDOWN = 134 // { int sys_shutdown(int s, int how); }
133		SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \
	133	SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, int protocol, int *rsv); }
134	134	SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); }
135	135	SYS_RMDIR = 137 // { int sys_rmdir(const char *path); }
136		SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \
	136	SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval delta, struct timeval olddelta); }
137	137	SYS_GETLOGIN_R = 141 // { int sys_getlogin_r(char *namebuf, u_int namelen); }
138	138	SYS_SETSID = 147 // { int sys_setsid(void); }
139		SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \
	139	SYS_QUOTACTL = 148 // { int sys_quotactl(const char path, int cmd, int uid, char arg); }
140	140	SYS_NFSSVC = 155 // { int sys_nfssvc(int flag, void *argp); }
141	141	SYS_GETFH = 161 // { int sys_getfh(const char fname, fhandle_t fhp); }
142	142	SYS_SYSARCH = 165 // { int sys_sysarch(int op, void *parms); }
143		SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, \
144		SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, \
	143	SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	144	SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
145	145	SYS_SETGID = 181 // { int sys_setgid(gid_t gid); }
146	146	SYS_SETEGID = 182 // { int sys_setegid(gid_t egid); }
147	147	SYS_SETEUID = 183 // { int sys_seteuid(uid_t euid); }
148	148	SYS_PATHCONF = 191 // { long sys_pathconf(const char *path, int name); }
149	149	SYS_FPATHCONF = 192 // { long sys_fpathconf(int fd, int name); }
150	150	SYS_SWAPCTL = 193 // { int sys_swapctl(int cmd, const void *arg, int misc); }
151		SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, \
152		SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, \
153		SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, \
154		SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, \
155		SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, \
	151	SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, struct rlimit *rlp); }
	152	SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, const struct rlimit *rlp); }
	153	SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
	154	SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, int whence); }
	155	SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, off_t length); }
156	156	SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); }
157		SYS_SYSCTL = 202 // { int sys_sysctl(const int *name, u_int namelen, \
	157	SYS_SYSCTL = 202 // { int sys_sysctl(const int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); }
158	158	SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); }
159	159	SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); }
160	160	SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); }
161		SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, \
	161	SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, size_t len); }
162	162	SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); }
163	163	SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); }
164		SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
165		SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
166		SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, \
	164	SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	165	SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	166	SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, int shmflg); }
167	167	SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); }
168		SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \
169		SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \
	168	SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, int inherit); }
	169	SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, u_int nfds, int timeout); }
170	170	SYS_ISSETUGID = 253 // { int sys_issetugid(void); }
171	171	SYS_LCHOWN = 254 // { int sys_lchown(const char *path, uid_t uid, gid_t gid); }
172	172	SYS_GETSID = 255 // { pid_t sys_getsid(pid_t pid); }
173	173	SYS_MSYNC = 256 // { int sys_msync(void *addr, size_t len, int flags); }
174	174	SYS_PIPE = 263 // { int sys_pipe(int *fdp); }
175	175	SYS_FHOPEN = 264 // { int sys_fhopen(const fhandle_t *fhp, int flags); }
176		SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, \
177		SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, \
	176	SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
	177	SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
178	178	SYS_KQUEUE = 269 // { int sys_kqueue(void); }
179	179	SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); }
180	180	SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); }
181		SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, \
182		SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, \
183		SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, \
184		SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, \
185		SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, \
	181	SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	182	SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	183	SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
	184	SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
	185	SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
186	186	SYS_CLOSEFROM = 287 // { int sys_closefrom(int fd); }
187		SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \
	187	SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack nss, struct sigaltstack oss); }
188	188	SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); }
189		SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \
190		SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \
191		SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \
192		SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \
193		SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \
	189	SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, size_t nsops); }
	190	SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t fhp, struct stat sb); }
	191	SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, union semun *arg); }
	192	SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, struct shmid_ds *buf); }
	193	SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, struct msqid_ds *buf); }
194	194	SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); }
195	195	SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); }
196		SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \
	196	SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, int n); }
197	197	SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); }
198		SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \
	198	SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, siginfo_t info, const struct timespec timeout); }
199	199	SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); }
200		SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \
	200	SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t freq, int64_t oldfreq); }
201	201	SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); }
202	202	SYS_GETRTABLE = 311 // { int sys_getrtable(void); }
203		SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \
204		SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \
205		SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \
206		SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \
207		SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \
208		SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \
209		SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, \
210		SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, \
211		SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char *path, \
212		SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \
213		SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \
214		SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \
	203	SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, int amode, int flag); }
	204	SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, mode_t mode, int flag); }
	205	SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, uid_t uid, gid_t gid, int flag); }
	206	SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char path1, int fd2, const char path2, int flag); }
	207	SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, mode_t mode); }
	208	SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, mode_t mode); }
	209	SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, mode_t mode, dev_t dev); }
	210	SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, ... mode_t mode); }
	211	SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char path, char buf, size_t count); }
	212	SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char from, int tofd, const char to); }
	213	SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char path, int fd, const char link); }
	214	SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, int flag); }
215	215	SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); }
216	216	SYS___GET_TCB = 330 // { void *sys___get_tcb(void); }
217	217	)

+108

-108

unix/zsysnum_openbsd_arm.go less more

0		// mksysnum_openbsd.pl
	0	// go run mksysnum.go http://cvsweb.openbsd.org/cgi-bin/cvsweb/~checkout~/src/sys/kern/syscalls.master
1	1	// Code generated by the command above; see README.md. DO NOT EDIT.
2	2
3	3	// +build arm,openbsd

8	8	SYS_EXIT = 1 // { void sys_exit(int rval); }
9	9	SYS_FORK = 2 // { int sys_fork(void); }
10	10	SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); }
11		SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, \
12		SYS_OPEN = 5 // { int sys_open(const char *path, \
	11	SYS_WRITE = 4 // { ssize_t sys_write(int fd, const void *buf, size_t nbyte); }
	12	SYS_OPEN = 5 // { int sys_open(const char *path, int flags, ... mode_t mode); }
13	13	SYS_CLOSE = 6 // { int sys_close(int fd); }
14	14	SYS_GETENTROPY = 7 // { int sys_getentropy(void *buf, size_t nbyte); }
15		SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, \
	15	SYS___TFORK = 8 // { int sys___tfork(const struct __tfork *param, size_t psize); }
16	16	SYS_LINK = 9 // { int sys_link(const char path, const char link); }
17	17	SYS_UNLINK = 10 // { int sys_unlink(const char *path); }
18		SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int *status, \
	18	SYS_WAIT4 = 11 // { pid_t sys_wait4(pid_t pid, int status, int options, struct rusage rusage); }
19	19	SYS_CHDIR = 12 // { int sys_chdir(const char *path); }
20	20	SYS_FCHDIR = 13 // { int sys_fchdir(int fd); }
21		SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, \
	21	SYS_MKNOD = 14 // { int sys_mknod(const char *path, mode_t mode, dev_t dev); }
22	22	SYS_CHMOD = 15 // { int sys_chmod(const char *path, mode_t mode); }
23		SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, \
	23	SYS_CHOWN = 16 // { int sys_chown(const char *path, uid_t uid, gid_t gid); }
24	24	SYS_OBREAK = 17 // { int sys_obreak(char *nsize); } break
25	25	SYS_GETDTABLECOUNT = 18 // { int sys_getdtablecount(void); }
26		SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, \
	26	SYS_GETRUSAGE = 19 // { int sys_getrusage(int who, struct rusage *rusage); }
27	27	SYS_GETPID = 20 // { pid_t sys_getpid(void); }
28		SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, \
	28	SYS_MOUNT = 21 // { int sys_mount(const char type, const char path, int flags, void *data); }
29	29	SYS_UNMOUNT = 22 // { int sys_unmount(const char *path, int flags); }
30	30	SYS_SETUID = 23 // { int sys_setuid(uid_t uid); }
31	31	SYS_GETUID = 24 // { uid_t sys_getuid(void); }
32	32	SYS_GETEUID = 25 // { uid_t sys_geteuid(void); }
33		SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, \
34		SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, \
35		SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, \
36		SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void *buf, size_t len, \
37		SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr *name, \
38		SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr *asa, \
39		SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr *asa, \
	33	SYS_PTRACE = 26 // { int sys_ptrace(int req, pid_t pid, caddr_t addr, int data); }
	34	SYS_RECVMSG = 27 // { ssize_t sys_recvmsg(int s, struct msghdr *msg, int flags); }
	35	SYS_SENDMSG = 28 // { ssize_t sys_sendmsg(int s, const struct msghdr *msg, int flags); }
	36	SYS_RECVFROM = 29 // { ssize_t sys_recvfrom(int s, void buf, size_t len, int flags, struct sockaddr from, socklen_t *fromlenaddr); }
	37	SYS_ACCEPT = 30 // { int sys_accept(int s, struct sockaddr name, socklen_t anamelen); }
	38	SYS_GETPEERNAME = 31 // { int sys_getpeername(int fdes, struct sockaddr asa, socklen_t alen); }
	39	SYS_GETSOCKNAME = 32 // { int sys_getsockname(int fdes, struct sockaddr asa, socklen_t alen); }
40	40	SYS_ACCESS = 33 // { int sys_access(const char *path, int amode); }
41	41	SYS_CHFLAGS = 34 // { int sys_chflags(const char *path, u_int flags); }
42	42	SYS_FCHFLAGS = 35 // { int sys_fchflags(int fd, u_int flags); }

45	45	SYS_GETPPID = 39 // { pid_t sys_getppid(void); }
46	46	SYS_LSTAT = 40 // { int sys_lstat(const char path, struct stat ub); }
47	47	SYS_DUP = 41 // { int sys_dup(int fd); }
48		SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char *path, \
	48	SYS_FSTATAT = 42 // { int sys_fstatat(int fd, const char path, struct stat buf, int flag); }
49	49	SYS_GETEGID = 43 // { gid_t sys_getegid(void); }
50		SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, \
51		SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, \
52		SYS_SIGACTION = 46 // { int sys_sigaction(int signum, \
	50	SYS_PROFIL = 44 // { int sys_profil(caddr_t samples, size_t size, u_long offset, u_int scale); }
	51	SYS_KTRACE = 45 // { int sys_ktrace(const char *fname, int ops, int facs, pid_t pid); }
	52	SYS_SIGACTION = 46 // { int sys_sigaction(int signum, const struct sigaction nsa, struct sigaction osa); }
53	53	SYS_GETGID = 47 // { gid_t sys_getgid(void); }
54	54	SYS_SIGPROCMASK = 48 // { int sys_sigprocmask(int how, sigset_t mask); }
55	55	SYS_SETLOGIN = 50 // { int sys_setlogin(const char *namebuf); }
56	56	SYS_ACCT = 51 // { int sys_acct(const char *path); }
57	57	SYS_SIGPENDING = 52 // { int sys_sigpending(void); }
58	58	SYS_FSTAT = 53 // { int sys_fstat(int fd, struct stat *sb); }
59		SYS_IOCTL = 54 // { int sys_ioctl(int fd, \
	59	SYS_IOCTL = 54 // { int sys_ioctl(int fd, u_long com, ... void *data); }
60	60	SYS_REBOOT = 55 // { int sys_reboot(int opt); }
61	61	SYS_REVOKE = 56 // { int sys_revoke(const char *path); }
62		SYS_SYMLINK = 57 // { int sys_symlink(const char *path, \
63		SYS_READLINK = 58 // { ssize_t sys_readlink(const char *path, \
64		SYS_EXECVE = 59 // { int sys_execve(const char *path, \
	62	SYS_SYMLINK = 57 // { int sys_symlink(const char path, const char link); }
	63	SYS_READLINK = 58 // { ssize_t sys_readlink(const char path, char buf, size_t count); }
	64	SYS_EXECVE = 59 // { int sys_execve(const char path, char const argp, char const *envp); }
65	65	SYS_UMASK = 60 // { mode_t sys_umask(mode_t newmask); }
66	66	SYS_CHROOT = 61 // { int sys_chroot(const char *path); }
67		SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, \
68		SYS_STATFS = 63 // { int sys_statfs(const char *path, \
	67	SYS_GETFSSTAT = 62 // { int sys_getfsstat(struct statfs *buf, size_t bufsize, int flags); }
	68	SYS_STATFS = 63 // { int sys_statfs(const char path, struct statfs buf); }
69	69	SYS_FSTATFS = 64 // { int sys_fstatfs(int fd, struct statfs *buf); }
70		SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t *fhp, \
	70	SYS_FHSTATFS = 65 // { int sys_fhstatfs(const fhandle_t fhp, struct statfs buf); }
71	71	SYS_VFORK = 66 // { int sys_vfork(void); }
72		SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval *tp, \
73		SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval *tv, \
74		SYS_SETITIMER = 69 // { int sys_setitimer(int which, \
75		SYS_GETITIMER = 70 // { int sys_getitimer(int which, \
76		SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, \
77		SYS_KEVENT = 72 // { int sys_kevent(int fd, \
	72	SYS_GETTIMEOFDAY = 67 // { int sys_gettimeofday(struct timeval tp, struct timezone tzp); }
	73	SYS_SETTIMEOFDAY = 68 // { int sys_settimeofday(const struct timeval tv, const struct timezone tzp); }
	74	SYS_SETITIMER = 69 // { int sys_setitimer(int which, const struct itimerval itv, struct itimerval oitv); }
	75	SYS_GETITIMER = 70 // { int sys_getitimer(int which, struct itimerval *itv); }
	76	SYS_SELECT = 71 // { int sys_select(int nd, fd_set in, fd_set ou, fd_set ex, struct timeval tv); }
	77	SYS_KEVENT = 72 // { int sys_kevent(int fd, const struct kevent changelist, int nchanges, struct kevent eventlist, int nevents, const struct timespec *timeout); }
78	78	SYS_MUNMAP = 73 // { int sys_munmap(void *addr, size_t len); }
79		SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, \
80		SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, \
81		SYS_UTIMES = 76 // { int sys_utimes(const char *path, \
82		SYS_FUTIMES = 77 // { int sys_futimes(int fd, \
83		SYS_MINCORE = 78 // { int sys_mincore(void *addr, size_t len, \
84		SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, \
85		SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, \
	79	SYS_MPROTECT = 74 // { int sys_mprotect(void *addr, size_t len, int prot); }
	80	SYS_MADVISE = 75 // { int sys_madvise(void *addr, size_t len, int behav); }
	81	SYS_UTIMES = 76 // { int sys_utimes(const char path, const struct timeval tptr); }
	82	SYS_FUTIMES = 77 // { int sys_futimes(int fd, const struct timeval *tptr); }
	83	SYS_MINCORE = 78 // { int sys_mincore(void addr, size_t len, char vec); }
	84	SYS_GETGROUPS = 79 // { int sys_getgroups(int gidsetsize, gid_t *gidset); }
	85	SYS_SETGROUPS = 80 // { int sys_setgroups(int gidsetsize, const gid_t *gidset); }
86	86	SYS_GETPGRP = 81 // { int sys_getpgrp(void); }
87	87	SYS_SETPGID = 82 // { int sys_setpgid(pid_t pid, pid_t pgid); }
88		SYS_FUTEX = 83 // { int sys_futex(uint32_t *f, int op, int val, \
89		SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char *path, \
90		SYS_FUTIMENS = 85 // { int sys_futimens(int fd, \
91		SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, \
92		SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, \
93		SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, \
94		SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, \
	88	SYS_FUTEX = 83 // { int sys_futex(uint32_t f, int op, int val, const struct timespec timeout, uint32_t *g); }
	89	SYS_UTIMENSAT = 84 // { int sys_utimensat(int fd, const char path, const struct timespec times, int flag); }
	90	SYS_FUTIMENS = 85 // { int sys_futimens(int fd, const struct timespec *times); }
	91	SYS_KBIND = 86 // { int sys_kbind(const struct __kbind *param, size_t psize, int64_t proc_cookie); }
	92	SYS_CLOCK_GETTIME = 87 // { int sys_clock_gettime(clockid_t clock_id, struct timespec *tp); }
	93	SYS_CLOCK_SETTIME = 88 // { int sys_clock_settime(clockid_t clock_id, const struct timespec *tp); }
	94	SYS_CLOCK_GETRES = 89 // { int sys_clock_getres(clockid_t clock_id, struct timespec *tp); }
95	95	SYS_DUP2 = 90 // { int sys_dup2(int from, int to); }
96		SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec *rqtp, \
	96	SYS_NANOSLEEP = 91 // { int sys_nanosleep(const struct timespec rqtp, struct timespec rmtp); }
97	97	SYS_FCNTL = 92 // { int sys_fcntl(int fd, int cmd, ... void *arg); }
98		SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr *name, \
99		SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, \
	98	SYS_ACCEPT4 = 93 // { int sys_accept4(int s, struct sockaddr name, socklen_t anamelen, int flags); }
	99	SYS___THRSLEEP = 94 // { int sys___thrsleep(const volatile void ident, clockid_t clock_id, const struct timespec tp, void lock, const int abort); }
100	100	SYS_FSYNC = 95 // { int sys_fsync(int fd); }
101	101	SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); }
102	102	SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); }
103		SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, \
	103	SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, socklen_t namelen); }
104	104	SYS_GETDENTS = 99 // { int sys_getdents(int fd, void *buf, size_t buflen); }
105	105	SYS_GETPRIORITY = 100 // { int sys_getpriority(int which, id_t who); }
106	106	SYS_PIPE2 = 101 // { int sys_pipe2(int *fdp, int flags); }
107	107	SYS_DUP3 = 102 // { int sys_dup3(int from, int to, int flags); }
108	108	SYS_SIGRETURN = 103 // { int sys_sigreturn(struct sigcontext *sigcntxp); }
109		SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, \
110		SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, \
	109	SYS_BIND = 104 // { int sys_bind(int s, const struct sockaddr *name, socklen_t namelen); }
	110	SYS_SETSOCKOPT = 105 // { int sys_setsockopt(int s, int level, int name, const void *val, socklen_t valsize); }
111	111	SYS_LISTEN = 106 // { int sys_listen(int s, int backlog); }
112		SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, \
113		SYS_PLEDGE = 108 // { int sys_pledge(const char *promises, \
114		SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd *fds, \
115		SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, \
	112	SYS_CHFLAGSAT = 107 // { int sys_chflagsat(int fd, const char *path, u_int flags, int atflags); }
	113	SYS_PLEDGE = 108 // { int sys_pledge(const char promises, const char execpromises); }
	114	SYS_PPOLL = 109 // { int sys_ppoll(struct pollfd fds, u_int nfds, const struct timespec ts, const sigset_t *mask); }
	115	SYS_PSELECT = 110 // { int sys_pselect(int nd, fd_set in, fd_set ou, fd_set ex, const struct timespec ts, const sigset_t *mask); }
116	116	SYS_SIGSUSPEND = 111 // { int sys_sigsuspend(int mask); }
117		SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, \
118		SYS_UNVEIL = 114 // { int sys_unveil(const char *path, \
119		SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, \
	117	SYS_SENDSYSLOG = 112 // { int sys_sendsyslog(const char *buf, size_t nbyte, int flags); }
	118	SYS_UNVEIL = 114 // { int sys_unveil(const char path, const char permissions); }
	119	SYS_GETSOCKOPT = 118 // { int sys_getsockopt(int s, int level, int name, void val, socklen_t avalsize); }
120	120	SYS_THRKILL = 119 // { int sys_thrkill(pid_t tid, int signum, void *tcb); }
121		SYS_READV = 120 // { ssize_t sys_readv(int fd, \
122		SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, \
	121	SYS_READV = 120 // { ssize_t sys_readv(int fd, const struct iovec *iovp, int iovcnt); }
	122	SYS_WRITEV = 121 // { ssize_t sys_writev(int fd, const struct iovec *iovp, int iovcnt); }
123	123	SYS_KILL = 122 // { int sys_kill(int pid, int signum); }
124	124	SYS_FCHOWN = 123 // { int sys_fchown(int fd, uid_t uid, gid_t gid); }
125	125	SYS_FCHMOD = 124 // { int sys_fchmod(int fd, mode_t mode); }

128	128	SYS_RENAME = 128 // { int sys_rename(const char from, const char to); }
129	129	SYS_FLOCK = 131 // { int sys_flock(int fd, int how); }
130	130	SYS_MKFIFO = 132 // { int sys_mkfifo(const char *path, mode_t mode); }
131		SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void *buf, \
	131	SYS_SENDTO = 133 // { ssize_t sys_sendto(int s, const void buf, size_t len, int flags, const struct sockaddr to, socklen_t tolen); }
132	132	SYS_SHUTDOWN = 134 // { int sys_shutdown(int s, int how); }
133		SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, \
	133	SYS_SOCKETPAIR = 135 // { int sys_socketpair(int domain, int type, int protocol, int *rsv); }
134	134	SYS_MKDIR = 136 // { int sys_mkdir(const char *path, mode_t mode); }
135	135	SYS_RMDIR = 137 // { int sys_rmdir(const char *path); }
136		SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval *delta, \
	136	SYS_ADJTIME = 140 // { int sys_adjtime(const struct timeval delta, struct timeval olddelta); }
137	137	SYS_GETLOGIN_R = 141 // { int sys_getlogin_r(char *namebuf, u_int namelen); }
138	138	SYS_SETSID = 147 // { int sys_setsid(void); }
139		SYS_QUOTACTL = 148 // { int sys_quotactl(const char *path, int cmd, \
	139	SYS_QUOTACTL = 148 // { int sys_quotactl(const char path, int cmd, int uid, char arg); }
140	140	SYS_NFSSVC = 155 // { int sys_nfssvc(int flag, void *argp); }
141	141	SYS_GETFH = 161 // { int sys_getfh(const char fname, fhandle_t fhp); }
142	142	SYS_SYSARCH = 165 // { int sys_sysarch(int op, void *parms); }
143		SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, \
144		SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, \
	143	SYS_PREAD = 173 // { ssize_t sys_pread(int fd, void *buf, size_t nbyte, int pad, off_t offset); }
	144	SYS_PWRITE = 174 // { ssize_t sys_pwrite(int fd, const void *buf, size_t nbyte, int pad, off_t offset); }
145	145	SYS_SETGID = 181 // { int sys_setgid(gid_t gid); }
146	146	SYS_SETEGID = 182 // { int sys_setegid(gid_t egid); }
147	147	SYS_SETEUID = 183 // { int sys_seteuid(uid_t euid); }
148	148	SYS_PATHCONF = 191 // { long sys_pathconf(const char *path, int name); }
149	149	SYS_FPATHCONF = 192 // { long sys_fpathconf(int fd, int name); }
150	150	SYS_SWAPCTL = 193 // { int sys_swapctl(int cmd, const void *arg, int misc); }
151		SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, \
152		SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, \
153		SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, \
154		SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, \
155		SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, \
	151	SYS_GETRLIMIT = 194 // { int sys_getrlimit(int which, struct rlimit *rlp); }
	152	SYS_SETRLIMIT = 195 // { int sys_setrlimit(int which, const struct rlimit *rlp); }
	153	SYS_MMAP = 197 // { void sys_mmap(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
	154	SYS_LSEEK = 199 // { off_t sys_lseek(int fd, int pad, off_t offset, int whence); }
	155	SYS_TRUNCATE = 200 // { int sys_truncate(const char *path, int pad, off_t length); }
156	156	SYS_FTRUNCATE = 201 // { int sys_ftruncate(int fd, int pad, off_t length); }
157		SYS_SYSCTL = 202 // { int sys_sysctl(const int *name, u_int namelen, \
	157	SYS_SYSCTL = 202 // { int sys_sysctl(const int name, u_int namelen, void old, size_t oldlenp, void new, size_t newlen); }
158	158	SYS_MLOCK = 203 // { int sys_mlock(const void *addr, size_t len); }
159	159	SYS_MUNLOCK = 204 // { int sys_munlock(const void *addr, size_t len); }
160	160	SYS_GETPGID = 207 // { pid_t sys_getpgid(pid_t pid); }
161		SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, \
	161	SYS_UTRACE = 209 // { int sys_utrace(const char label, const void addr, size_t len); }
162	162	SYS_SEMGET = 221 // { int sys_semget(key_t key, int nsems, int semflg); }
163	163	SYS_MSGGET = 225 // { int sys_msgget(key_t key, int msgflg); }
164		SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
165		SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
166		SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, \
	164	SYS_MSGSND = 226 // { int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); }
	165	SYS_MSGRCV = 227 // { int sys_msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); }
	166	SYS_SHMAT = 228 // { void sys_shmat(int shmid, const void shmaddr, int shmflg); }
167	167	SYS_SHMDT = 230 // { int sys_shmdt(const void *shmaddr); }
168		SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, \
169		SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, \
	168	SYS_MINHERIT = 250 // { int sys_minherit(void *addr, size_t len, int inherit); }
	169	SYS_POLL = 252 // { int sys_poll(struct pollfd *fds, u_int nfds, int timeout); }
170	170	SYS_ISSETUGID = 253 // { int sys_issetugid(void); }
171	171	SYS_LCHOWN = 254 // { int sys_lchown(const char *path, uid_t uid, gid_t gid); }
172	172	SYS_GETSID = 255 // { pid_t sys_getsid(pid_t pid); }
173	173	SYS_MSYNC = 256 // { int sys_msync(void *addr, size_t len, int flags); }
174	174	SYS_PIPE = 263 // { int sys_pipe(int *fdp); }
175	175	SYS_FHOPEN = 264 // { int sys_fhopen(const fhandle_t *fhp, int flags); }
176		SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, \
177		SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, \
	176	SYS_PREADV = 267 // { ssize_t sys_preadv(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
	177	SYS_PWRITEV = 268 // { ssize_t sys_pwritev(int fd, const struct iovec *iovp, int iovcnt, int pad, off_t offset); }
178	178	SYS_KQUEUE = 269 // { int sys_kqueue(void); }
179	179	SYS_MLOCKALL = 271 // { int sys_mlockall(int flags); }
180	180	SYS_MUNLOCKALL = 272 // { int sys_munlockall(void); }
181		SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, \
182		SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, \
183		SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, \
184		SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, \
185		SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, \
	181	SYS_GETRESUID = 281 // { int sys_getresuid(uid_t ruid, uid_t euid, uid_t *suid); }
	182	SYS_SETRESUID = 282 // { int sys_setresuid(uid_t ruid, uid_t euid, uid_t suid); }
	183	SYS_GETRESGID = 283 // { int sys_getresgid(gid_t rgid, gid_t egid, gid_t *sgid); }
	184	SYS_SETRESGID = 284 // { int sys_setresgid(gid_t rgid, gid_t egid, gid_t sgid); }
	185	SYS_MQUERY = 286 // { void sys_mquery(void addr, size_t len, int prot, int flags, int fd, long pad, off_t pos); }
186	186	SYS_CLOSEFROM = 287 // { int sys_closefrom(int fd); }
187		SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack *nss, \
	187	SYS_SIGALTSTACK = 288 // { int sys_sigaltstack(const struct sigaltstack nss, struct sigaltstack oss); }
188	188	SYS_SHMGET = 289 // { int sys_shmget(key_t key, size_t size, int shmflg); }
189		SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, \
190		SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t *fhp, \
191		SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, \
192		SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, \
193		SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, \
	189	SYS_SEMOP = 290 // { int sys_semop(int semid, struct sembuf *sops, size_t nsops); }
	190	SYS_FHSTAT = 294 // { int sys_fhstat(const fhandle_t fhp, struct stat sb); }
	191	SYS___SEMCTL = 295 // { int sys___semctl(int semid, int semnum, int cmd, union semun *arg); }
	192	SYS_SHMCTL = 296 // { int sys_shmctl(int shmid, int cmd, struct shmid_ds *buf); }
	193	SYS_MSGCTL = 297 // { int sys_msgctl(int msqid, int cmd, struct msqid_ds *buf); }
194	194	SYS_SCHED_YIELD = 298 // { int sys_sched_yield(void); }
195	195	SYS_GETTHRID = 299 // { pid_t sys_getthrid(void); }
196		SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, \
	196	SYS___THRWAKEUP = 301 // { int sys___thrwakeup(const volatile void *ident, int n); }
197	197	SYS___THREXIT = 302 // { void sys___threxit(pid_t *notdead); }
198		SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, \
	198	SYS___THRSIGDIVERT = 303 // { int sys___thrsigdivert(sigset_t sigmask, siginfo_t info, const struct timespec timeout); }
199	199	SYS___GETCWD = 304 // { int sys___getcwd(char *buf, size_t len); }
200		SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t *freq, \
	200	SYS_ADJFREQ = 305 // { int sys_adjfreq(const int64_t freq, int64_t oldfreq); }
201	201	SYS_SETRTABLE = 310 // { int sys_setrtable(int rtableid); }
202	202	SYS_GETRTABLE = 311 // { int sys_getrtable(void); }
203		SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, \
204		SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, \
205		SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, \
206		SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char *path1, int fd2, \
207		SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, \
208		SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, \
209		SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, \
210		SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, \
211		SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char *path, \
212		SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char *from, \
213		SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char *path, int fd, \
214		SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, \
	203	SYS_FACCESSAT = 313 // { int sys_faccessat(int fd, const char *path, int amode, int flag); }
	204	SYS_FCHMODAT = 314 // { int sys_fchmodat(int fd, const char *path, mode_t mode, int flag); }
	205	SYS_FCHOWNAT = 315 // { int sys_fchownat(int fd, const char *path, uid_t uid, gid_t gid, int flag); }
	206	SYS_LINKAT = 317 // { int sys_linkat(int fd1, const char path1, int fd2, const char path2, int flag); }
	207	SYS_MKDIRAT = 318 // { int sys_mkdirat(int fd, const char *path, mode_t mode); }
	208	SYS_MKFIFOAT = 319 // { int sys_mkfifoat(int fd, const char *path, mode_t mode); }
	209	SYS_MKNODAT = 320 // { int sys_mknodat(int fd, const char *path, mode_t mode, dev_t dev); }
	210	SYS_OPENAT = 321 // { int sys_openat(int fd, const char *path, int flags, ... mode_t mode); }
	211	SYS_READLINKAT = 322 // { ssize_t sys_readlinkat(int fd, const char path, char buf, size_t count); }
	212	SYS_RENAMEAT = 323 // { int sys_renameat(int fromfd, const char from, int tofd, const char to); }
	213	SYS_SYMLINKAT = 324 // { int sys_symlinkat(const char path, int fd, const char link); }
	214	SYS_UNLINKAT = 325 // { int sys_unlinkat(int fd, const char *path, int flag); }
215	215	SYS___SET_TCB = 329 // { void sys___set_tcb(void *tcb); }
216	216	SYS___GET_TCB = 330 // { void *sys___get_tcb(void); }
217	217	)

+1395

-104

unix/ztypes_linux_sparc64.go less more

	0	// cgo -godefs -- -Wall -Werror -static -I/tmp/include linux/types.go \| go run mkpost.go
	1	// Code generated by the command above; see README.md. DO NOT EDIT.
	2
0	3	// +build sparc64,linux
1		// Created by cgo -godefs - DO NOT EDIT
2		// cgo -godefs types_linux.go \| go run mkpost.go
3	4
4	5	package unix
5	6

25	26	}
26	27
27	28	type Timeval struct {
28		Sec int64
29		Usec int32
30		Pad_cgo_0 [4]byte
	29	Sec int64
	30	Usec int32
	31	_ [4]byte
31	32	}
32	33
33	34	type Timex struct {
34	35	Modes uint32
35		Pad_cgo_0 [4]byte
36	36	Offset int64
37	37	Freq int64
38	38	Maxerror int64
39	39	Esterror int64
40	40	Status int32
41		Pad_cgo_1 [4]byte
42	41	Constant int64
43	42	Precision int64
44	43	Tolerance int64

47	46	Ppsfreq int64
48	47	Jitter int64
49	48	Shift int32
50		Pad_cgo_2 [4]byte
51	49	Stabil int64
52	50	Jitcnt int64
53	51	Calcnt int64
54	52	Errcnt int64
55	53	Stbcnt int64
56	54	Tai int32
57		Pad_cgo_3 [44]byte
	55	_ [44]byte
58	56	}
59	57
60	58	type Time_t int64

98	96	type _Gid_t uint32
99	97
100	98	type Stat_t struct {
101		Dev uint64
102		X__pad1 uint16
103		Pad_cgo_0 [6]byte
104		Ino uint64
105		Mode uint32
106		Nlink uint32
107		Uid uint32
108		Gid uint32
109		Rdev uint64
110		X__pad2 uint16
111		Pad_cgo_1 [6]byte
112		Size int64
113		Blksize int64
114		Blocks int64
115		Atim Timespec
116		Mtim Timespec
117		Ctim Timespec
118		X__glibc_reserved4 uint64
119		X__glibc_reserved5 uint64
120		}
121
122		type Statfs_t struct {
123		Type int64
124		Bsize int64
125		Blocks uint64
126		Bfree uint64
127		Bavail uint64
128		Files uint64
129		Ffree uint64
130		Fsid Fsid
131		Namelen int64
132		Frsize int64
133		Flags int64
134		Spare [4]int64
	99	Dev uint64
	100	_ uint16
	101	Ino uint64
	102	Mode uint32
	103	Nlink uint32
	104	Uid uint32
	105	Gid uint32
	106	Rdev uint64
	107	_ uint16
	108	Size int64
	109	Blksize int64
	110	Blocks int64
	111	Atim Timespec
	112	Mtim Timespec
	113	Ctim Timespec
	114	_ uint64
	115	_ uint64
	116	}
	117
	118	type StatxTimestamp struct {
	119	Sec int64
	120	Nsec uint32
	121	_ int32
	122	}
	123
	124	type Statx_t struct {
	125	Mask uint32
	126	Blksize uint32
	127	Attributes uint64
	128	Nlink uint32
	129	Uid uint32
	130	Gid uint32
	131	Mode uint16
	132	_ [1]uint16
	133	Ino uint64
	134	Size uint64
	135	Blocks uint64
	136	Attributes_mask uint64
	137	Atime StatxTimestamp
	138	Btime StatxTimestamp
	139	Ctime StatxTimestamp
	140	Mtime StatxTimestamp
	141	Rdev_major uint32
	142	Rdev_minor uint32
	143	Dev_major uint32
	144	Dev_minor uint32
	145	_ [14]uint64
135	146	}
136	147
137	148	type Dirent struct {
138		Ino uint64
139		Off int64
140		Reclen uint16
141		Type uint8
142		Name [256]int8
143		Pad_cgo_0 [5]byte
	149	Ino uint64
	150	Off int64
	151	Reclen uint16
	152	Type uint8
	153	Name [256]int8
	154	_ [5]byte
144	155	}
145	156
146	157	type Fsid struct {
147		X__val [2]int32
	158	Val [2]int32
148	159	}
149	160
150	161	type Flock_t struct {
151		Type int16
152		Whence int16
153		Pad_cgo_0 [4]byte
154		Start int64
155		Len int64
156		Pid int32
157		X__glibc_reserved int16
158		Pad_cgo_1 [2]byte
	162	Type int16
	163	Whence int16
	164	Start int64
	165	Len int64
	166	Pid int32
	167	_ int16
	168	_ [2]byte
	169	}
	170
	171	type FscryptPolicy struct {
	172	Version uint8
	173	Contents_encryption_mode uint8
	174	Filenames_encryption_mode uint8
	175	Flags uint8
	176	Master_key_descriptor [8]uint8
	177	}
	178
	179	type FscryptKey struct {
	180	Mode uint32
	181	Raw [64]uint8
	182	Size uint32
	183	}
	184
	185	type KeyctlDHParams struct {
	186	Private int32
	187	Prime int32
	188	Base int32
159	189	}
160	190
161	191	const (

210	240	Channel uint16
211	241	}
212	242
	243	type RawSockaddrL2 struct {
	244	Family uint16
	245	Psm uint16
	246	Bdaddr [6]uint8
	247	Cid uint16
	248	Bdaddr_type uint8
	249	_ [1]byte
	250	}
	251
	252	type RawSockaddrRFCOMM struct {
	253	Family uint16
	254	Bdaddr [6]uint8
	255	Channel uint8
	256	_ [1]byte
	257	}
	258
213	259	type RawSockaddrCAN struct {
214		Family uint16
215		Pad_cgo_0 [2]byte
216		Ifindex int32
217		Addr [8]byte
	260	Family uint16
	261	Ifindex int32
	262	Addr [8]byte
218	263	}
219	264
220	265	type RawSockaddrALG struct {

233	278	Zero [4]uint8
234	279	}
235	280
	281	type RawSockaddrXDP struct {
	282	Family uint16
	283	Flags uint16
	284	Ifindex uint32
	285	Queue_id uint32
	286	Shared_umem_fd uint32
	287	}
	288
	289	type RawSockaddrPPPoX [0x1e]byte
	290
236	291	type RawSockaddr struct {
237	292	Family uint16
238	293	Data [14]int8

271	326	Interface uint32
272	327	}
273	328
	329	type PacketMreq struct {
	330	Ifindex int32
	331	Type uint16
	332	Alen uint16
	333	Address [8]uint8
	334	}
	335
274	336	type Msghdr struct {
275	337	Name *byte
276	338	Namelen uint32
277		Pad_cgo_0 [4]byte
278	339	Iov *Iovec
279	340	Iovlen uint64
280	341	Control *byte
281	342	Controllen uint64
282	343	Flags int32
283		Pad_cgo_1 [4]byte
	344	_ [4]byte
284	345	}
285	346
286	347	type Cmsghdr struct {

322	383	Probes uint8
323	384	Backoff uint8
324	385	Options uint8
325		Pad_cgo_0 [2]byte
326	386	Rto uint32
327	387	Ato uint32
328	388	Snd_mss uint32

357	417	SizeofSockaddrLinklayer = 0x14
358	418	SizeofSockaddrNetlink = 0xc
359	419	SizeofSockaddrHCI = 0x6
	420	SizeofSockaddrL2 = 0xe
	421	SizeofSockaddrRFCOMM = 0xa
360	422	SizeofSockaddrCAN = 0x10
361	423	SizeofSockaddrALG = 0x58
362	424	SizeofSockaddrVM = 0x10
	425	SizeofSockaddrXDP = 0x10
	426	SizeofSockaddrPPPoX = 0x1e
363	427	SizeofLinger = 0x8
	428	SizeofIovec = 0x10
364	429	SizeofIPMreq = 0x8
365	430	SizeofIPMreqn = 0xc
366	431	SizeofIPv6Mreq = 0x14
	432	SizeofPacketMreq = 0x10
367	433	SizeofMsghdr = 0x38
368	434	SizeofCmsghdr = 0x10
369	435	SizeofInet4Pktinfo = 0xc

387	453	IFLA_ADDRESS = 0x1
388	454	IFLA_BROADCAST = 0x2
389	455	IFLA_IFNAME = 0x3
	456	IFLA_INFO_KIND = 0x1
390	457	IFLA_MTU = 0x4
391	458	IFLA_LINK = 0x5
392	459	IFLA_QDISC = 0x6

430	497	IFLA_EVENT = 0x2c
431	498	IFLA_NEW_NETNSID = 0x2d
432	499	IFLA_IF_NETNSID = 0x2e
433		IFLA_MAX = 0x2e
	500	IFLA_MAX = 0x33
434	501	RT_SCOPE_UNIVERSE = 0x0
435	502	RT_SCOPE_SITE = 0xc8
436	503	RT_SCOPE_LINK = 0xfd

455	522	RTA_FLOW = 0xb
456	523	RTA_CACHEINFO = 0xc
457	524	RTA_TABLE = 0xf
	525	RTA_MARK = 0x10
	526	RTA_MFC_STATS = 0x11
	527	RTA_VIA = 0x12
	528	RTA_NEWDST = 0x13
	529	RTA_PREF = 0x14
	530	RTA_ENCAP_TYPE = 0x15
	531	RTA_ENCAP = 0x16
	532	RTA_EXPIRES = 0x17
	533	RTA_PAD = 0x18
	534	RTA_UID = 0x19
	535	RTA_TTL_PROPAGATE = 0x1a
	536	RTA_IP_PROTO = 0x1b
	537	RTA_SPORT = 0x1c
	538	RTA_DPORT = 0x1d
458	539	RTN_UNSPEC = 0x0
459	540	RTN_UNICAST = 0x1
460	541	RTN_LOCAL = 0x2

522	603	}
523	604
524	605	type IfInfomsg struct {
525		Family uint8
526		X__ifi_pad uint8
527		Type uint16
528		Index int32
529		Flags uint32
530		Change uint32
	606	Family uint8
	607	_ uint8
	608	Type uint16
	609	Index int32
	610	Flags uint32
	611	Change uint32
531	612	}
532	613
533	614	type IfAddrmsg struct {

570	651	}
571	652
572	653	type SockFprog struct {
573		Len uint16
574		Pad_cgo_0 [6]byte
575		Filter *SockFilter
	654	Len uint16
	655	Filter *SockFilter
576	656	}
577	657
578	658	type InotifyEvent struct {

591	671	Tnpc uint64
592	672	Y uint32
593	673	Magic uint32
594		}
595
596		type ptracePsw struct {
597		}
598
599		type ptraceFpregs struct {
600		}
601
602		type ptracePer struct {
603	674	}
604	675
605	676	type FdSet struct {

617	688	Freeswap uint64
618	689	Procs uint16
619	690	Pad uint16
620		Pad_cgo_0 [4]byte
621	691	Totalhigh uint64
622	692	Freehigh uint64
623	693	Unit uint32
624		X_f [0]int8
625		Pad_cgo_1 [4]byte
	694	_ [0]int8
	695	_ [4]byte
626	696	}
627	697
628	698	type Utsname struct {

635	705	}
636	706
637	707	type Ustat_t struct {
638		Tfree int32
639		Pad_cgo_0 [4]byte
640		Tinode uint64
641		Fname [6]int8
642		Fpack [6]int8
643		Pad_cgo_1 [4]byte
	708	Tfree int32
	709	Tinode uint64
	710	Fname [6]int8
	711	Fpack [6]int8
	712	_ [4]byte
644	713	}
645	714
646	715	type EpollEvent struct {
647		Events uint32
648		X_padFd int32
649		Fd int32
650		Pad int32
651		}
652
653		const (
654		AT_FDCWD = -0x64
655		AT_REMOVEDIR = 0x200
	716	Events uint32
	717	_ int32
	718	Fd int32
	719	Pad int32
	720	}
	721
	722	const (
	723	AT_EMPTY_PATH = 0x1000
	724	AT_FDCWD = -0x64
	725	AT_NO_AUTOMOUNT = 0x800
	726	AT_REMOVEDIR = 0x200
	727
	728	AT_STATX_SYNC_AS_STAT = 0x0
	729	AT_STATX_FORCE_SYNC = 0x2000
	730	AT_STATX_DONT_SYNC = 0x4000
	731
656	732	AT_SYMLINK_FOLLOW = 0x400
657	733	AT_SYMLINK_NOFOLLOW = 0x100
	734
	735	AT_EACCESS = 0x200
658	736	)
659	737
660	738	type PollFd struct {

674	752	)
675	753
676	754	type Sigset_t struct {
677		X__val [16]uint64
678		}
	755	Val [16]uint64
	756	}
	757
	758	const RNDGETENTCNT = 0x40045200
	759
	760	const PERF_IOC_FLAG_GROUP = 0x1
679	761
680	762	type Termios struct {
681	763	Iflag uint32

687	769	Ispeed uint32
688	770	Ospeed uint32
689	771	}
	772
	773	type Winsize struct {
	774	Row uint16
	775	Col uint16
	776	Xpixel uint16
	777	Ypixel uint16
	778	}
	779
	780	type Taskstats struct {
	781	Version uint16
	782	Ac_exitcode uint32
	783	Ac_flag uint8
	784	Ac_nice uint8
	785	Cpu_count uint64
	786	Cpu_delay_total uint64
	787	Blkio_count uint64
	788	Blkio_delay_total uint64
	789	Swapin_count uint64
	790	Swapin_delay_total uint64
	791	Cpu_run_real_total uint64
	792	Cpu_run_virtual_total uint64
	793	Ac_comm [32]int8
	794	Ac_sched uint8
	795	Ac_pad [3]uint8
	796	_ [4]byte
	797	Ac_uid uint32
	798	Ac_gid uint32
	799	Ac_pid uint32
	800	Ac_ppid uint32
	801	Ac_btime uint32
	802	Ac_etime uint64
	803	Ac_utime uint64
	804	Ac_stime uint64
	805	Ac_minflt uint64
	806	Ac_majflt uint64
	807	Coremem uint64
	808	Virtmem uint64
	809	Hiwater_rss uint64
	810	Hiwater_vm uint64
	811	Read_char uint64
	812	Write_char uint64
	813	Read_syscalls uint64
	814	Write_syscalls uint64
	815	Read_bytes uint64
	816	Write_bytes uint64
	817	Cancelled_write_bytes uint64
	818	Nvcsw uint64
	819	Nivcsw uint64
	820	Ac_utimescaled uint64
	821	Ac_stimescaled uint64
	822	Cpu_scaled_run_real_total uint64
	823	Freepages_count uint64
	824	Freepages_delay_total uint64
	825	}
	826
	827	const (
	828	TASKSTATS_CMD_UNSPEC = 0x0
	829	TASKSTATS_CMD_GET = 0x1
	830	TASKSTATS_CMD_NEW = 0x2
	831	TASKSTATS_TYPE_UNSPEC = 0x0
	832	TASKSTATS_TYPE_PID = 0x1
	833	TASKSTATS_TYPE_TGID = 0x2
	834	TASKSTATS_TYPE_STATS = 0x3
	835	TASKSTATS_TYPE_AGGR_PID = 0x4
	836	TASKSTATS_TYPE_AGGR_TGID = 0x5
	837	TASKSTATS_TYPE_NULL = 0x6
	838	TASKSTATS_CMD_ATTR_UNSPEC = 0x0
	839	TASKSTATS_CMD_ATTR_PID = 0x1
	840	TASKSTATS_CMD_ATTR_TGID = 0x2
	841	TASKSTATS_CMD_ATTR_REGISTER_CPUMASK = 0x3
	842	TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK = 0x4
	843	)
	844
	845	type CGroupStats struct {
	846	Sleeping uint64
	847	Running uint64
	848	Stopped uint64
	849	Uninterruptible uint64
	850	Io_wait uint64
	851	}
	852
	853	const (
	854	CGROUPSTATS_CMD_UNSPEC = 0x3
	855	CGROUPSTATS_CMD_GET = 0x4
	856	CGROUPSTATS_CMD_NEW = 0x5
	857	CGROUPSTATS_TYPE_UNSPEC = 0x0
	858	CGROUPSTATS_TYPE_CGROUP_STATS = 0x1
	859	CGROUPSTATS_CMD_ATTR_UNSPEC = 0x0
	860	CGROUPSTATS_CMD_ATTR_FD = 0x1
	861	)
	862
	863	type Genlmsghdr struct {
	864	Cmd uint8
	865	Version uint8
	866	Reserved uint16
	867	}
	868
	869	const (
	870	CTRL_CMD_UNSPEC = 0x0
	871	CTRL_CMD_NEWFAMILY = 0x1
	872	CTRL_CMD_DELFAMILY = 0x2
	873	CTRL_CMD_GETFAMILY = 0x3
	874	CTRL_CMD_NEWOPS = 0x4
	875	CTRL_CMD_DELOPS = 0x5
	876	CTRL_CMD_GETOPS = 0x6
	877	CTRL_CMD_NEWMCAST_GRP = 0x7
	878	CTRL_CMD_DELMCAST_GRP = 0x8
	879	CTRL_CMD_GETMCAST_GRP = 0x9
	880	CTRL_ATTR_UNSPEC = 0x0
	881	CTRL_ATTR_FAMILY_ID = 0x1
	882	CTRL_ATTR_FAMILY_NAME = 0x2
	883	CTRL_ATTR_VERSION = 0x3
	884	CTRL_ATTR_HDRSIZE = 0x4
	885	CTRL_ATTR_MAXATTR = 0x5
	886	CTRL_ATTR_OPS = 0x6
	887	CTRL_ATTR_MCAST_GROUPS = 0x7
	888	CTRL_ATTR_OP_UNSPEC = 0x0
	889	CTRL_ATTR_OP_ID = 0x1
	890	CTRL_ATTR_OP_FLAGS = 0x2
	891	CTRL_ATTR_MCAST_GRP_UNSPEC = 0x0
	892	CTRL_ATTR_MCAST_GRP_NAME = 0x1
	893	CTRL_ATTR_MCAST_GRP_ID = 0x2
	894	)
	895
	896	type cpuMask uint64
	897
	898	const (
	899	_CPU_SETSIZE = 0x400
	900	_NCPUBITS = 0x40
	901	)
	902
	903	const (
	904	BDADDR_BREDR = 0x0
	905	BDADDR_LE_PUBLIC = 0x1
	906	BDADDR_LE_RANDOM = 0x2
	907	)
	908
	909	type PerfEventAttr struct {
	910	Type uint32
	911	Size uint32
	912	Config uint64
	913	Sample uint64
	914	Sample_type uint64
	915	Read_format uint64
	916	Bits uint64
	917	Wakeup uint32
	918	Bp_type uint32
	919	Ext1 uint64
	920	Ext2 uint64
	921	Branch_sample_type uint64
	922	Sample_regs_user uint64
	923	Sample_stack_user uint32
	924	Clockid int32
	925	Sample_regs_intr uint64
	926	Aux_watermark uint32
	927	_ uint32
	928	}
	929
	930	type PerfEventMmapPage struct {
	931	Version uint32
	932	Compat_version uint32
	933	Lock uint32
	934	Index uint32
	935	Offset int64
	936	Time_enabled uint64
	937	Time_running uint64
	938	Capabilities uint64
	939	Pmc_width uint16
	940	Time_shift uint16
	941	Time_mult uint32
	942	Time_offset uint64
	943	Time_zero uint64
	944	Size uint32
	945	_ [948]uint8
	946	Data_head uint64
	947	Data_tail uint64
	948	Data_offset uint64
	949	Data_size uint64
	950	Aux_head uint64
	951	Aux_tail uint64
	952	Aux_offset uint64
	953	Aux_size uint64
	954	}
	955
	956	const (
	957	PerfBitDisabled uint64 = CBitFieldMaskBit0
	958	PerfBitInherit = CBitFieldMaskBit1
	959	PerfBitPinned = CBitFieldMaskBit2
	960	PerfBitExclusive = CBitFieldMaskBit3
	961	PerfBitExcludeUser = CBitFieldMaskBit4
	962	PerfBitExcludeKernel = CBitFieldMaskBit5
	963	PerfBitExcludeHv = CBitFieldMaskBit6
	964	PerfBitExcludeIdle = CBitFieldMaskBit7
	965	PerfBitMmap = CBitFieldMaskBit8
	966	PerfBitComm = CBitFieldMaskBit9
	967	PerfBitFreq = CBitFieldMaskBit10
	968	PerfBitInheritStat = CBitFieldMaskBit11
	969	PerfBitEnableOnExec = CBitFieldMaskBit12
	970	PerfBitTask = CBitFieldMaskBit13
	971	PerfBitWatermark = CBitFieldMaskBit14
	972	PerfBitPreciseIPBit1 = CBitFieldMaskBit15
	973	PerfBitPreciseIPBit2 = CBitFieldMaskBit16
	974	PerfBitMmapData = CBitFieldMaskBit17
	975	PerfBitSampleIDAll = CBitFieldMaskBit18
	976	PerfBitExcludeHost = CBitFieldMaskBit19
	977	PerfBitExcludeGuest = CBitFieldMaskBit20
	978	PerfBitExcludeCallchainKernel = CBitFieldMaskBit21
	979	PerfBitExcludeCallchainUser = CBitFieldMaskBit22
	980	PerfBitMmap2 = CBitFieldMaskBit23
	981	PerfBitCommExec = CBitFieldMaskBit24
	982	PerfBitUseClockID = CBitFieldMaskBit25
	983	PerfBitContextSwitch = CBitFieldMaskBit26
	984	)
	985
	986	const (
	987	PERF_TYPE_HARDWARE = 0x0
	988	PERF_TYPE_SOFTWARE = 0x1
	989	PERF_TYPE_TRACEPOINT = 0x2
	990	PERF_TYPE_HW_CACHE = 0x3
	991	PERF_TYPE_RAW = 0x4
	992	PERF_TYPE_BREAKPOINT = 0x5
	993
	994	PERF_COUNT_HW_CPU_CYCLES = 0x0
	995	PERF_COUNT_HW_INSTRUCTIONS = 0x1
	996	PERF_COUNT_HW_CACHE_REFERENCES = 0x2
	997	PERF_COUNT_HW_CACHE_MISSES = 0x3
	998	PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 0x4
	999	PERF_COUNT_HW_BRANCH_MISSES = 0x5
	1000	PERF_COUNT_HW_BUS_CYCLES = 0x6
	1001	PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 0x7
	1002	PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 0x8
	1003	PERF_COUNT_HW_REF_CPU_CYCLES = 0x9
	1004
	1005	PERF_COUNT_HW_CACHE_L1D = 0x0
	1006	PERF_COUNT_HW_CACHE_L1I = 0x1
	1007	PERF_COUNT_HW_CACHE_LL = 0x2
	1008	PERF_COUNT_HW_CACHE_DTLB = 0x3
	1009	PERF_COUNT_HW_CACHE_ITLB = 0x4
	1010	PERF_COUNT_HW_CACHE_BPU = 0x5
	1011	PERF_COUNT_HW_CACHE_NODE = 0x6
	1012
	1013	PERF_COUNT_HW_CACHE_OP_READ = 0x0
	1014	PERF_COUNT_HW_CACHE_OP_WRITE = 0x1
	1015	PERF_COUNT_HW_CACHE_OP_PREFETCH = 0x2
	1016
	1017	PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0x0
	1018	PERF_COUNT_HW_CACHE_RESULT_MISS = 0x1
	1019
	1020	PERF_COUNT_SW_CPU_CLOCK = 0x0
	1021	PERF_COUNT_SW_TASK_CLOCK = 0x1
	1022	PERF_COUNT_SW_PAGE_FAULTS = 0x2
	1023	PERF_COUNT_SW_CONTEXT_SWITCHES = 0x3
	1024	PERF_COUNT_SW_CPU_MIGRATIONS = 0x4
	1025	PERF_COUNT_SW_PAGE_FAULTS_MIN = 0x5
	1026	PERF_COUNT_SW_PAGE_FAULTS_MAJ = 0x6
	1027	PERF_COUNT_SW_ALIGNMENT_FAULTS = 0x7
	1028	PERF_COUNT_SW_EMULATION_FAULTS = 0x8
	1029	PERF_COUNT_SW_DUMMY = 0x9
	1030
	1031	PERF_SAMPLE_IP = 0x1
	1032	PERF_SAMPLE_TID = 0x2
	1033	PERF_SAMPLE_TIME = 0x4
	1034	PERF_SAMPLE_ADDR = 0x8
	1035	PERF_SAMPLE_READ = 0x10
	1036	PERF_SAMPLE_CALLCHAIN = 0x20
	1037	PERF_SAMPLE_ID = 0x40
	1038	PERF_SAMPLE_CPU = 0x80
	1039	PERF_SAMPLE_PERIOD = 0x100
	1040	PERF_SAMPLE_STREAM_ID = 0x200
	1041	PERF_SAMPLE_RAW = 0x400
	1042	PERF_SAMPLE_BRANCH_STACK = 0x800
	1043
	1044	PERF_SAMPLE_BRANCH_USER = 0x1
	1045	PERF_SAMPLE_BRANCH_KERNEL = 0x2
	1046	PERF_SAMPLE_BRANCH_HV = 0x4
	1047	PERF_SAMPLE_BRANCH_ANY = 0x8
	1048	PERF_SAMPLE_BRANCH_ANY_CALL = 0x10
	1049	PERF_SAMPLE_BRANCH_ANY_RETURN = 0x20
	1050	PERF_SAMPLE_BRANCH_IND_CALL = 0x40
	1051
	1052	PERF_FORMAT_TOTAL_TIME_ENABLED = 0x1
	1053	PERF_FORMAT_TOTAL_TIME_RUNNING = 0x2
	1054	PERF_FORMAT_ID = 0x4
	1055	PERF_FORMAT_GROUP = 0x8
	1056
	1057	PERF_RECORD_MMAP = 0x1
	1058	PERF_RECORD_LOST = 0x2
	1059	PERF_RECORD_COMM = 0x3
	1060	PERF_RECORD_EXIT = 0x4
	1061	PERF_RECORD_THROTTLE = 0x5
	1062	PERF_RECORD_UNTHROTTLE = 0x6
	1063	PERF_RECORD_FORK = 0x7
	1064	PERF_RECORD_READ = 0x8
	1065	PERF_RECORD_SAMPLE = 0x9
	1066
	1067	PERF_CONTEXT_HV = -0x20
	1068	PERF_CONTEXT_KERNEL = -0x80
	1069	PERF_CONTEXT_USER = -0x200
	1070
	1071	PERF_CONTEXT_GUEST = -0x800
	1072	PERF_CONTEXT_GUEST_KERNEL = -0x880
	1073	PERF_CONTEXT_GUEST_USER = -0xa00
	1074
	1075	PERF_FLAG_FD_NO_GROUP = 0x1
	1076	PERF_FLAG_FD_OUTPUT = 0x2
	1077	PERF_FLAG_PID_CGROUP = 0x4
	1078	)
	1079
	1080	const (
	1081	CBitFieldMaskBit0 = 0x8000000000000000
	1082	CBitFieldMaskBit1 = 0x4000000000000000
	1083	CBitFieldMaskBit2 = 0x2000000000000000
	1084	CBitFieldMaskBit3 = 0x1000000000000000
	1085	CBitFieldMaskBit4 = 0x800000000000000
	1086	CBitFieldMaskBit5 = 0x400000000000000
	1087	CBitFieldMaskBit6 = 0x200000000000000
	1088	CBitFieldMaskBit7 = 0x100000000000000
	1089	CBitFieldMaskBit8 = 0x80000000000000
	1090	CBitFieldMaskBit9 = 0x40000000000000
	1091	CBitFieldMaskBit10 = 0x20000000000000
	1092	CBitFieldMaskBit11 = 0x10000000000000
	1093	CBitFieldMaskBit12 = 0x8000000000000
	1094	CBitFieldMaskBit13 = 0x4000000000000
	1095	CBitFieldMaskBit14 = 0x2000000000000
	1096	CBitFieldMaskBit15 = 0x1000000000000
	1097	CBitFieldMaskBit16 = 0x800000000000
	1098	CBitFieldMaskBit17 = 0x400000000000
	1099	CBitFieldMaskBit18 = 0x200000000000
	1100	CBitFieldMaskBit19 = 0x100000000000
	1101	CBitFieldMaskBit20 = 0x80000000000
	1102	CBitFieldMaskBit21 = 0x40000000000
	1103	CBitFieldMaskBit22 = 0x20000000000
	1104	CBitFieldMaskBit23 = 0x10000000000
	1105	CBitFieldMaskBit24 = 0x8000000000
	1106	CBitFieldMaskBit25 = 0x4000000000
	1107	CBitFieldMaskBit26 = 0x2000000000
	1108	CBitFieldMaskBit27 = 0x1000000000
	1109	CBitFieldMaskBit28 = 0x800000000
	1110	CBitFieldMaskBit29 = 0x400000000
	1111	CBitFieldMaskBit30 = 0x200000000
	1112	CBitFieldMaskBit31 = 0x100000000
	1113	CBitFieldMaskBit32 = 0x80000000
	1114	CBitFieldMaskBit33 = 0x40000000
	1115	CBitFieldMaskBit34 = 0x20000000
	1116	CBitFieldMaskBit35 = 0x10000000
	1117	CBitFieldMaskBit36 = 0x8000000
	1118	CBitFieldMaskBit37 = 0x4000000
	1119	CBitFieldMaskBit38 = 0x2000000
	1120	CBitFieldMaskBit39 = 0x1000000
	1121	CBitFieldMaskBit40 = 0x800000
	1122	CBitFieldMaskBit41 = 0x400000
	1123	CBitFieldMaskBit42 = 0x200000
	1124	CBitFieldMaskBit43 = 0x100000
	1125	CBitFieldMaskBit44 = 0x80000
	1126	CBitFieldMaskBit45 = 0x40000
	1127	CBitFieldMaskBit46 = 0x20000
	1128	CBitFieldMaskBit47 = 0x10000
	1129	CBitFieldMaskBit48 = 0x8000
	1130	CBitFieldMaskBit49 = 0x4000
	1131	CBitFieldMaskBit50 = 0x2000
	1132	CBitFieldMaskBit51 = 0x1000
	1133	CBitFieldMaskBit52 = 0x800
	1134	CBitFieldMaskBit53 = 0x400
	1135	CBitFieldMaskBit54 = 0x200
	1136	CBitFieldMaskBit55 = 0x100
	1137	CBitFieldMaskBit56 = 0x80
	1138	CBitFieldMaskBit57 = 0x40
	1139	CBitFieldMaskBit58 = 0x20
	1140	CBitFieldMaskBit59 = 0x10
	1141	CBitFieldMaskBit60 = 0x8
	1142	CBitFieldMaskBit61 = 0x4
	1143	CBitFieldMaskBit62 = 0x2
	1144	CBitFieldMaskBit63 = 0x1
	1145	)
	1146
	1147	type SockaddrStorage struct {
	1148	Family uint16
	1149	_ [118]int8
	1150	_ uint64
	1151	}
	1152
	1153	type TCPMD5Sig struct {
	1154	Addr SockaddrStorage
	1155	Flags uint8
	1156	Prefixlen uint8
	1157	Keylen uint16
	1158	_ uint32
	1159	Key [80]uint8
	1160	}
	1161
	1162	type HDDriveCmdHdr struct {
	1163	Command uint8
	1164	Number uint8
	1165	Feature uint8
	1166	Count uint8
	1167	}
	1168
	1169	type HDGeometry struct {
	1170	Heads uint8
	1171	Sectors uint8
	1172	Cylinders uint16
	1173	Start uint64
	1174	}
	1175
	1176	type HDDriveID struct {
	1177	Config uint16
	1178	Cyls uint16
	1179	Reserved2 uint16
	1180	Heads uint16
	1181	Track_bytes uint16
	1182	Sector_bytes uint16
	1183	Sectors uint16
	1184	Vendor0 uint16
	1185	Vendor1 uint16
	1186	Vendor2 uint16
	1187	Serial_no [20]uint8
	1188	Buf_type uint16
	1189	Buf_size uint16
	1190	Ecc_bytes uint16
	1191	Fw_rev [8]uint8
	1192	Model [40]uint8
	1193	Max_multsect uint8
	1194	Vendor3 uint8
	1195	Dword_io uint16
	1196	Vendor4 uint8
	1197	Capability uint8
	1198	Reserved50 uint16
	1199	Vendor5 uint8
	1200	TPIO uint8
	1201	Vendor6 uint8
	1202	TDMA uint8
	1203	Field_valid uint16
	1204	Cur_cyls uint16
	1205	Cur_heads uint16
	1206	Cur_sectors uint16
	1207	Cur_capacity0 uint16
	1208	Cur_capacity1 uint16
	1209	Multsect uint8
	1210	Multsect_valid uint8
	1211	Lba_capacity uint32
	1212	Dma_1word uint16
	1213	Dma_mword uint16
	1214	Eide_pio_modes uint16
	1215	Eide_dma_min uint16
	1216	Eide_dma_time uint16
	1217	Eide_pio uint16
	1218	Eide_pio_iordy uint16
	1219	Words69_70 [2]uint16
	1220	Words71_74 [4]uint16
	1221	Queue_depth uint16
	1222	Words76_79 [4]uint16
	1223	Major_rev_num uint16
	1224	Minor_rev_num uint16
	1225	Command_set_1 uint16
	1226	Command_set_2 uint16
	1227	Cfsse uint16
	1228	Cfs_enable_1 uint16
	1229	Cfs_enable_2 uint16
	1230	Csf_default uint16
	1231	Dma_ultra uint16
	1232	Trseuc uint16
	1233	TrsEuc uint16
	1234	CurAPMvalues uint16
	1235	Mprc uint16
	1236	Hw_config uint16
	1237	Acoustic uint16
	1238	Msrqs uint16
	1239	Sxfert uint16
	1240	Sal uint16
	1241	Spg uint32
	1242	Lba_capacity_2 uint64
	1243	Words104_125 [22]uint16
	1244	Last_lun uint16
	1245	Word127 uint16
	1246	Dlf uint16
	1247	Csfo uint16
	1248	Words130_155 [26]uint16
	1249	Word156 uint16
	1250	Words157_159 [3]uint16
	1251	Cfa_power uint16
	1252	Words161_175 [15]uint16
	1253	Words176_205 [30]uint16
	1254	Words206_254 [49]uint16
	1255	Integrity_word uint16
	1256	}
	1257
	1258	type Statfs_t struct {
	1259	Type int64
	1260	Bsize int64
	1261	Blocks uint64
	1262	Bfree uint64
	1263	Bavail uint64
	1264	Files uint64
	1265	Ffree uint64
	1266	Fsid Fsid
	1267	Namelen int64
	1268	Frsize int64
	1269	Flags int64
	1270	Spare [4]int64
	1271	}
	1272
	1273	const (
	1274	ST_MANDLOCK = 0x40
	1275	ST_NOATIME = 0x400
	1276	ST_NODEV = 0x4
	1277	ST_NODIRATIME = 0x800
	1278	ST_NOEXEC = 0x8
	1279	ST_NOSUID = 0x2
	1280	ST_RDONLY = 0x1
	1281	ST_RELATIME = 0x1000
	1282	ST_SYNCHRONOUS = 0x10
	1283	)
	1284
	1285	type TpacketHdr struct {
	1286	Status uint64
	1287	Len uint32
	1288	Snaplen uint32
	1289	Mac uint16
	1290	Net uint16
	1291	Sec uint32
	1292	Usec uint32
	1293	_ [4]byte
	1294	}
	1295
	1296	type Tpacket2Hdr struct {
	1297	Status uint32
	1298	Len uint32
	1299	Snaplen uint32
	1300	Mac uint16
	1301	Net uint16
	1302	Sec uint32
	1303	Nsec uint32
	1304	Vlan_tci uint16
	1305	Vlan_tpid uint16
	1306	_ [4]uint8
	1307	}
	1308
	1309	type Tpacket3Hdr struct {
	1310	Next_offset uint32
	1311	Sec uint32
	1312	Nsec uint32
	1313	Snaplen uint32
	1314	Len uint32
	1315	Status uint32
	1316	Mac uint16
	1317	Net uint16
	1318	Hv1 TpacketHdrVariant1
	1319	_ [8]uint8
	1320	}
	1321
	1322	type TpacketHdrVariant1 struct {
	1323	Rxhash uint32
	1324	Vlan_tci uint32
	1325	Vlan_tpid uint16
	1326	_ uint16
	1327	}
	1328
	1329	type TpacketBlockDesc struct {
	1330	Version uint32
	1331	To_priv uint32
	1332	Hdr [40]byte
	1333	}
	1334
	1335	type TpacketReq struct {
	1336	Block_size uint32
	1337	Block_nr uint32
	1338	Frame_size uint32
	1339	Frame_nr uint32
	1340	}
	1341
	1342	type TpacketReq3 struct {
	1343	Block_size uint32
	1344	Block_nr uint32
	1345	Frame_size uint32
	1346	Frame_nr uint32
	1347	Retire_blk_tov uint32
	1348	Sizeof_priv uint32
	1349	Feature_req_word uint32
	1350	}
	1351
	1352	type TpacketStats struct {
	1353	Packets uint32
	1354	Drops uint32
	1355	}
	1356
	1357	type TpacketStatsV3 struct {
	1358	Packets uint32
	1359	Drops uint32
	1360	Freeze_q_cnt uint32
	1361	}
	1362
	1363	type TpacketAuxdata struct {
	1364	Status uint32
	1365	Len uint32
	1366	Snaplen uint32
	1367	Mac uint16
	1368	Net uint16
	1369	Vlan_tci uint16
	1370	Vlan_tpid uint16
	1371	}
	1372
	1373	const (
	1374	TPACKET_V1 = 0x0
	1375	TPACKET_V2 = 0x1
	1376	TPACKET_V3 = 0x2
	1377	)
	1378
	1379	const (
	1380	SizeofTpacketHdr = 0x20
	1381	SizeofTpacket2Hdr = 0x20
	1382	SizeofTpacket3Hdr = 0x30
	1383	)
	1384
	1385	const (
	1386	NF_INET_PRE_ROUTING = 0x0
	1387	NF_INET_LOCAL_IN = 0x1
	1388	NF_INET_FORWARD = 0x2
	1389	NF_INET_LOCAL_OUT = 0x3
	1390	NF_INET_POST_ROUTING = 0x4
	1391	NF_INET_NUMHOOKS = 0x5
	1392	)
	1393
	1394	const (
	1395	NF_NETDEV_INGRESS = 0x0
	1396	NF_NETDEV_NUMHOOKS = 0x1
	1397	)
	1398
	1399	const (
	1400	NFPROTO_UNSPEC = 0x0
	1401	NFPROTO_INET = 0x1
	1402	NFPROTO_IPV4 = 0x2
	1403	NFPROTO_ARP = 0x3
	1404	NFPROTO_NETDEV = 0x5
	1405	NFPROTO_BRIDGE = 0x7
	1406	NFPROTO_IPV6 = 0xa
	1407	NFPROTO_DECNET = 0xc
	1408	NFPROTO_NUMPROTO = 0xd
	1409	)
	1410
	1411	type Nfgenmsg struct {
	1412	Nfgen_family uint8
	1413	Version uint8
	1414	Res_id uint16
	1415	}
	1416
	1417	const (
	1418	NFNL_BATCH_UNSPEC = 0x0
	1419	NFNL_BATCH_GENID = 0x1
	1420	)
	1421
	1422	const (
	1423	NFT_REG_VERDICT = 0x0
	1424	NFT_REG_1 = 0x1
	1425	NFT_REG_2 = 0x2
	1426	NFT_REG_3 = 0x3
	1427	NFT_REG_4 = 0x4
	1428	NFT_REG32_00 = 0x8
	1429	NFT_REG32_01 = 0x9
	1430	NFT_REG32_02 = 0xa
	1431	NFT_REG32_03 = 0xb
	1432	NFT_REG32_04 = 0xc
	1433	NFT_REG32_05 = 0xd
	1434	NFT_REG32_06 = 0xe
	1435	NFT_REG32_07 = 0xf
	1436	NFT_REG32_08 = 0x10
	1437	NFT_REG32_09 = 0x11
	1438	NFT_REG32_10 = 0x12
	1439	NFT_REG32_11 = 0x13
	1440	NFT_REG32_12 = 0x14
	1441	NFT_REG32_13 = 0x15
	1442	NFT_REG32_14 = 0x16
	1443	NFT_REG32_15 = 0x17
	1444	NFT_CONTINUE = -0x1
	1445	NFT_BREAK = -0x2
	1446	NFT_JUMP = -0x3
	1447	NFT_GOTO = -0x4
	1448	NFT_RETURN = -0x5
	1449	NFT_MSG_NEWTABLE = 0x0
	1450	NFT_MSG_GETTABLE = 0x1
	1451	NFT_MSG_DELTABLE = 0x2
	1452	NFT_MSG_NEWCHAIN = 0x3
	1453	NFT_MSG_GETCHAIN = 0x4
	1454	NFT_MSG_DELCHAIN = 0x5
	1455	NFT_MSG_NEWRULE = 0x6
	1456	NFT_MSG_GETRULE = 0x7
	1457	NFT_MSG_DELRULE = 0x8
	1458	NFT_MSG_NEWSET = 0x9
	1459	NFT_MSG_GETSET = 0xa
	1460	NFT_MSG_DELSET = 0xb
	1461	NFT_MSG_NEWSETELEM = 0xc
	1462	NFT_MSG_GETSETELEM = 0xd
	1463	NFT_MSG_DELSETELEM = 0xe
	1464	NFT_MSG_NEWGEN = 0xf
	1465	NFT_MSG_GETGEN = 0x10
	1466	NFT_MSG_TRACE = 0x11
	1467	NFT_MSG_NEWOBJ = 0x12
	1468	NFT_MSG_GETOBJ = 0x13
	1469	NFT_MSG_DELOBJ = 0x14
	1470	NFT_MSG_GETOBJ_RESET = 0x15
	1471	NFT_MSG_MAX = 0x19
	1472	NFTA_LIST_UNPEC = 0x0
	1473	NFTA_LIST_ELEM = 0x1
	1474	NFTA_HOOK_UNSPEC = 0x0
	1475	NFTA_HOOK_HOOKNUM = 0x1
	1476	NFTA_HOOK_PRIORITY = 0x2
	1477	NFTA_HOOK_DEV = 0x3
	1478	NFT_TABLE_F_DORMANT = 0x1
	1479	NFTA_TABLE_UNSPEC = 0x0
	1480	NFTA_TABLE_NAME = 0x1
	1481	NFTA_TABLE_FLAGS = 0x2
	1482	NFTA_TABLE_USE = 0x3
	1483	NFTA_CHAIN_UNSPEC = 0x0
	1484	NFTA_CHAIN_TABLE = 0x1
	1485	NFTA_CHAIN_HANDLE = 0x2
	1486	NFTA_CHAIN_NAME = 0x3
	1487	NFTA_CHAIN_HOOK = 0x4
	1488	NFTA_CHAIN_POLICY = 0x5
	1489	NFTA_CHAIN_USE = 0x6
	1490	NFTA_CHAIN_TYPE = 0x7
	1491	NFTA_CHAIN_COUNTERS = 0x8
	1492	NFTA_CHAIN_PAD = 0x9
	1493	NFTA_RULE_UNSPEC = 0x0
	1494	NFTA_RULE_TABLE = 0x1
	1495	NFTA_RULE_CHAIN = 0x2
	1496	NFTA_RULE_HANDLE = 0x3
	1497	NFTA_RULE_EXPRESSIONS = 0x4
	1498	NFTA_RULE_COMPAT = 0x5
	1499	NFTA_RULE_POSITION = 0x6
	1500	NFTA_RULE_USERDATA = 0x7
	1501	NFTA_RULE_PAD = 0x8
	1502	NFTA_RULE_ID = 0x9
	1503	NFT_RULE_COMPAT_F_INV = 0x2
	1504	NFT_RULE_COMPAT_F_MASK = 0x2
	1505	NFTA_RULE_COMPAT_UNSPEC = 0x0
	1506	NFTA_RULE_COMPAT_PROTO = 0x1
	1507	NFTA_RULE_COMPAT_FLAGS = 0x2
	1508	NFT_SET_ANONYMOUS = 0x1
	1509	NFT_SET_CONSTANT = 0x2
	1510	NFT_SET_INTERVAL = 0x4
	1511	NFT_SET_MAP = 0x8
	1512	NFT_SET_TIMEOUT = 0x10
	1513	NFT_SET_EVAL = 0x20
	1514	NFT_SET_OBJECT = 0x40
	1515	NFT_SET_POL_PERFORMANCE = 0x0
	1516	NFT_SET_POL_MEMORY = 0x1
	1517	NFTA_SET_DESC_UNSPEC = 0x0
	1518	NFTA_SET_DESC_SIZE = 0x1
	1519	NFTA_SET_UNSPEC = 0x0
	1520	NFTA_SET_TABLE = 0x1
	1521	NFTA_SET_NAME = 0x2
	1522	NFTA_SET_FLAGS = 0x3
	1523	NFTA_SET_KEY_TYPE = 0x4
	1524	NFTA_SET_KEY_LEN = 0x5
	1525	NFTA_SET_DATA_TYPE = 0x6
	1526	NFTA_SET_DATA_LEN = 0x7
	1527	NFTA_SET_POLICY = 0x8
	1528	NFTA_SET_DESC = 0x9
	1529	NFTA_SET_ID = 0xa
	1530	NFTA_SET_TIMEOUT = 0xb
	1531	NFTA_SET_GC_INTERVAL = 0xc
	1532	NFTA_SET_USERDATA = 0xd
	1533	NFTA_SET_PAD = 0xe
	1534	NFTA_SET_OBJ_TYPE = 0xf
	1535	NFT_SET_ELEM_INTERVAL_END = 0x1
	1536	NFTA_SET_ELEM_UNSPEC = 0x0
	1537	NFTA_SET_ELEM_KEY = 0x1
	1538	NFTA_SET_ELEM_DATA = 0x2
	1539	NFTA_SET_ELEM_FLAGS = 0x3
	1540	NFTA_SET_ELEM_TIMEOUT = 0x4
	1541	NFTA_SET_ELEM_EXPIRATION = 0x5
	1542	NFTA_SET_ELEM_USERDATA = 0x6
	1543	NFTA_SET_ELEM_EXPR = 0x7
	1544	NFTA_SET_ELEM_PAD = 0x8
	1545	NFTA_SET_ELEM_OBJREF = 0x9
	1546	NFTA_SET_ELEM_LIST_UNSPEC = 0x0
	1547	NFTA_SET_ELEM_LIST_TABLE = 0x1
	1548	NFTA_SET_ELEM_LIST_SET = 0x2
	1549	NFTA_SET_ELEM_LIST_ELEMENTS = 0x3
	1550	NFTA_SET_ELEM_LIST_SET_ID = 0x4
	1551	NFT_DATA_VALUE = 0x0
	1552	NFT_DATA_VERDICT = 0xffffff00
	1553	NFTA_DATA_UNSPEC = 0x0
	1554	NFTA_DATA_VALUE = 0x1
	1555	NFTA_DATA_VERDICT = 0x2
	1556	NFTA_VERDICT_UNSPEC = 0x0
	1557	NFTA_VERDICT_CODE = 0x1
	1558	NFTA_VERDICT_CHAIN = 0x2
	1559	NFTA_EXPR_UNSPEC = 0x0
	1560	NFTA_EXPR_NAME = 0x1
	1561	NFTA_EXPR_DATA = 0x2
	1562	NFTA_IMMEDIATE_UNSPEC = 0x0
	1563	NFTA_IMMEDIATE_DREG = 0x1
	1564	NFTA_IMMEDIATE_DATA = 0x2
	1565	NFTA_BITWISE_UNSPEC = 0x0
	1566	NFTA_BITWISE_SREG = 0x1
	1567	NFTA_BITWISE_DREG = 0x2
	1568	NFTA_BITWISE_LEN = 0x3
	1569	NFTA_BITWISE_MASK = 0x4
	1570	NFTA_BITWISE_XOR = 0x5
	1571	NFT_BYTEORDER_NTOH = 0x0
	1572	NFT_BYTEORDER_HTON = 0x1
	1573	NFTA_BYTEORDER_UNSPEC = 0x0
	1574	NFTA_BYTEORDER_SREG = 0x1
	1575	NFTA_BYTEORDER_DREG = 0x2
	1576	NFTA_BYTEORDER_OP = 0x3
	1577	NFTA_BYTEORDER_LEN = 0x4
	1578	NFTA_BYTEORDER_SIZE = 0x5
	1579	NFT_CMP_EQ = 0x0
	1580	NFT_CMP_NEQ = 0x1
	1581	NFT_CMP_LT = 0x2
	1582	NFT_CMP_LTE = 0x3
	1583	NFT_CMP_GT = 0x4
	1584	NFT_CMP_GTE = 0x5
	1585	NFTA_CMP_UNSPEC = 0x0
	1586	NFTA_CMP_SREG = 0x1
	1587	NFTA_CMP_OP = 0x2
	1588	NFTA_CMP_DATA = 0x3
	1589	NFT_RANGE_EQ = 0x0
	1590	NFT_RANGE_NEQ = 0x1
	1591	NFTA_RANGE_UNSPEC = 0x0
	1592	NFTA_RANGE_SREG = 0x1
	1593	NFTA_RANGE_OP = 0x2
	1594	NFTA_RANGE_FROM_DATA = 0x3
	1595	NFTA_RANGE_TO_DATA = 0x4
	1596	NFT_LOOKUP_F_INV = 0x1
	1597	NFTA_LOOKUP_UNSPEC = 0x0
	1598	NFTA_LOOKUP_SET = 0x1
	1599	NFTA_LOOKUP_SREG = 0x2
	1600	NFTA_LOOKUP_DREG = 0x3
	1601	NFTA_LOOKUP_SET_ID = 0x4
	1602	NFTA_LOOKUP_FLAGS = 0x5
	1603	NFT_DYNSET_OP_ADD = 0x0
	1604	NFT_DYNSET_OP_UPDATE = 0x1
	1605	NFT_DYNSET_F_INV = 0x1
	1606	NFTA_DYNSET_UNSPEC = 0x0
	1607	NFTA_DYNSET_SET_NAME = 0x1
	1608	NFTA_DYNSET_SET_ID = 0x2
	1609	NFTA_DYNSET_OP = 0x3
	1610	NFTA_DYNSET_SREG_KEY = 0x4
	1611	NFTA_DYNSET_SREG_DATA = 0x5
	1612	NFTA_DYNSET_TIMEOUT = 0x6
	1613	NFTA_DYNSET_EXPR = 0x7
	1614	NFTA_DYNSET_PAD = 0x8
	1615	NFTA_DYNSET_FLAGS = 0x9
	1616	NFT_PAYLOAD_LL_HEADER = 0x0
	1617	NFT_PAYLOAD_NETWORK_HEADER = 0x1
	1618	NFT_PAYLOAD_TRANSPORT_HEADER = 0x2
	1619	NFT_PAYLOAD_CSUM_NONE = 0x0
	1620	NFT_PAYLOAD_CSUM_INET = 0x1
	1621	NFT_PAYLOAD_L4CSUM_PSEUDOHDR = 0x1
	1622	NFTA_PAYLOAD_UNSPEC = 0x0
	1623	NFTA_PAYLOAD_DREG = 0x1
	1624	NFTA_PAYLOAD_BASE = 0x2
	1625	NFTA_PAYLOAD_OFFSET = 0x3
	1626	NFTA_PAYLOAD_LEN = 0x4
	1627	NFTA_PAYLOAD_SREG = 0x5
	1628	NFTA_PAYLOAD_CSUM_TYPE = 0x6
	1629	NFTA_PAYLOAD_CSUM_OFFSET = 0x7
	1630	NFTA_PAYLOAD_CSUM_FLAGS = 0x8
	1631	NFT_EXTHDR_F_PRESENT = 0x1
	1632	NFT_EXTHDR_OP_IPV6 = 0x0
	1633	NFT_EXTHDR_OP_TCPOPT = 0x1
	1634	NFTA_EXTHDR_UNSPEC = 0x0
	1635	NFTA_EXTHDR_DREG = 0x1
	1636	NFTA_EXTHDR_TYPE = 0x2
	1637	NFTA_EXTHDR_OFFSET = 0x3
	1638	NFTA_EXTHDR_LEN = 0x4
	1639	NFTA_EXTHDR_FLAGS = 0x5
	1640	NFTA_EXTHDR_OP = 0x6
	1641	NFTA_EXTHDR_SREG = 0x7
	1642	NFT_META_LEN = 0x0
	1643	NFT_META_PROTOCOL = 0x1
	1644	NFT_META_PRIORITY = 0x2
	1645	NFT_META_MARK = 0x3
	1646	NFT_META_IIF = 0x4
	1647	NFT_META_OIF = 0x5
	1648	NFT_META_IIFNAME = 0x6
	1649	NFT_META_OIFNAME = 0x7
	1650	NFT_META_IIFTYPE = 0x8
	1651	NFT_META_OIFTYPE = 0x9
	1652	NFT_META_SKUID = 0xa
	1653	NFT_META_SKGID = 0xb
	1654	NFT_META_NFTRACE = 0xc
	1655	NFT_META_RTCLASSID = 0xd
	1656	NFT_META_SECMARK = 0xe
	1657	NFT_META_NFPROTO = 0xf
	1658	NFT_META_L4PROTO = 0x10
	1659	NFT_META_BRI_IIFNAME = 0x11
	1660	NFT_META_BRI_OIFNAME = 0x12
	1661	NFT_META_PKTTYPE = 0x13
	1662	NFT_META_CPU = 0x14
	1663	NFT_META_IIFGROUP = 0x15
	1664	NFT_META_OIFGROUP = 0x16
	1665	NFT_META_CGROUP = 0x17
	1666	NFT_META_PRANDOM = 0x18
	1667	NFT_RT_CLASSID = 0x0
	1668	NFT_RT_NEXTHOP4 = 0x1
	1669	NFT_RT_NEXTHOP6 = 0x2
	1670	NFT_RT_TCPMSS = 0x3
	1671	NFT_HASH_JENKINS = 0x0
	1672	NFT_HASH_SYM = 0x1
	1673	NFTA_HASH_UNSPEC = 0x0
	1674	NFTA_HASH_SREG = 0x1
	1675	NFTA_HASH_DREG = 0x2
	1676	NFTA_HASH_LEN = 0x3
	1677	NFTA_HASH_MODULUS = 0x4
	1678	NFTA_HASH_SEED = 0x5
	1679	NFTA_HASH_OFFSET = 0x6
	1680	NFTA_HASH_TYPE = 0x7
	1681	NFTA_META_UNSPEC = 0x0
	1682	NFTA_META_DREG = 0x1
	1683	NFTA_META_KEY = 0x2
	1684	NFTA_META_SREG = 0x3
	1685	NFTA_RT_UNSPEC = 0x0
	1686	NFTA_RT_DREG = 0x1
	1687	NFTA_RT_KEY = 0x2
	1688	NFT_CT_STATE = 0x0
	1689	NFT_CT_DIRECTION = 0x1
	1690	NFT_CT_STATUS = 0x2
	1691	NFT_CT_MARK = 0x3
	1692	NFT_CT_SECMARK = 0x4
	1693	NFT_CT_EXPIRATION = 0x5
	1694	NFT_CT_HELPER = 0x6
	1695	NFT_CT_L3PROTOCOL = 0x7
	1696	NFT_CT_SRC = 0x8
	1697	NFT_CT_DST = 0x9
	1698	NFT_CT_PROTOCOL = 0xa
	1699	NFT_CT_PROTO_SRC = 0xb
	1700	NFT_CT_PROTO_DST = 0xc
	1701	NFT_CT_LABELS = 0xd
	1702	NFT_CT_PKTS = 0xe
	1703	NFT_CT_BYTES = 0xf
	1704	NFT_CT_AVGPKT = 0x10
	1705	NFT_CT_ZONE = 0x11
	1706	NFT_CT_EVENTMASK = 0x12
	1707	NFTA_CT_UNSPEC = 0x0
	1708	NFTA_CT_DREG = 0x1
	1709	NFTA_CT_KEY = 0x2
	1710	NFTA_CT_DIRECTION = 0x3
	1711	NFTA_CT_SREG = 0x4
	1712	NFT_LIMIT_PKTS = 0x0
	1713	NFT_LIMIT_PKT_BYTES = 0x1
	1714	NFT_LIMIT_F_INV = 0x1
	1715	NFTA_LIMIT_UNSPEC = 0x0
	1716	NFTA_LIMIT_RATE = 0x1
	1717	NFTA_LIMIT_UNIT = 0x2
	1718	NFTA_LIMIT_BURST = 0x3
	1719	NFTA_LIMIT_TYPE = 0x4
	1720	NFTA_LIMIT_FLAGS = 0x5
	1721	NFTA_LIMIT_PAD = 0x6
	1722	NFTA_COUNTER_UNSPEC = 0x0
	1723	NFTA_COUNTER_BYTES = 0x1
	1724	NFTA_COUNTER_PACKETS = 0x2
	1725	NFTA_COUNTER_PAD = 0x3
	1726	NFTA_LOG_UNSPEC = 0x0
	1727	NFTA_LOG_GROUP = 0x1
	1728	NFTA_LOG_PREFIX = 0x2
	1729	NFTA_LOG_SNAPLEN = 0x3
	1730	NFTA_LOG_QTHRESHOLD = 0x4
	1731	NFTA_LOG_LEVEL = 0x5
	1732	NFTA_LOG_FLAGS = 0x6
	1733	NFTA_QUEUE_UNSPEC = 0x0
	1734	NFTA_QUEUE_NUM = 0x1
	1735	NFTA_QUEUE_TOTAL = 0x2
	1736	NFTA_QUEUE_FLAGS = 0x3
	1737	NFTA_QUEUE_SREG_QNUM = 0x4
	1738	NFT_QUOTA_F_INV = 0x1
	1739	NFT_QUOTA_F_DEPLETED = 0x2
	1740	NFTA_QUOTA_UNSPEC = 0x0
	1741	NFTA_QUOTA_BYTES = 0x1
	1742	NFTA_QUOTA_FLAGS = 0x2
	1743	NFTA_QUOTA_PAD = 0x3
	1744	NFTA_QUOTA_CONSUMED = 0x4
	1745	NFT_REJECT_ICMP_UNREACH = 0x0
	1746	NFT_REJECT_TCP_RST = 0x1
	1747	NFT_REJECT_ICMPX_UNREACH = 0x2
	1748	NFT_REJECT_ICMPX_NO_ROUTE = 0x0
	1749	NFT_REJECT_ICMPX_PORT_UNREACH = 0x1
	1750	NFT_REJECT_ICMPX_HOST_UNREACH = 0x2
	1751	NFT_REJECT_ICMPX_ADMIN_PROHIBITED = 0x3
	1752	NFTA_REJECT_UNSPEC = 0x0
	1753	NFTA_REJECT_TYPE = 0x1
	1754	NFTA_REJECT_ICMP_CODE = 0x2
	1755	NFT_NAT_SNAT = 0x0
	1756	NFT_NAT_DNAT = 0x1
	1757	NFTA_NAT_UNSPEC = 0x0
	1758	NFTA_NAT_TYPE = 0x1
	1759	NFTA_NAT_FAMILY = 0x2
	1760	NFTA_NAT_REG_ADDR_MIN = 0x3
	1761	NFTA_NAT_REG_ADDR_MAX = 0x4
	1762	NFTA_NAT_REG_PROTO_MIN = 0x5
	1763	NFTA_NAT_REG_PROTO_MAX = 0x6
	1764	NFTA_NAT_FLAGS = 0x7
	1765	NFTA_MASQ_UNSPEC = 0x0
	1766	NFTA_MASQ_FLAGS = 0x1
	1767	NFTA_MASQ_REG_PROTO_MIN = 0x2
	1768	NFTA_MASQ_REG_PROTO_MAX = 0x3
	1769	NFTA_REDIR_UNSPEC = 0x0
	1770	NFTA_REDIR_REG_PROTO_MIN = 0x1
	1771	NFTA_REDIR_REG_PROTO_MAX = 0x2
	1772	NFTA_REDIR_FLAGS = 0x3
	1773	NFTA_DUP_UNSPEC = 0x0
	1774	NFTA_DUP_SREG_ADDR = 0x1
	1775	NFTA_DUP_SREG_DEV = 0x2
	1776	NFTA_FWD_UNSPEC = 0x0
	1777	NFTA_FWD_SREG_DEV = 0x1
	1778	NFTA_OBJREF_UNSPEC = 0x0
	1779	NFTA_OBJREF_IMM_TYPE = 0x1
	1780	NFTA_OBJREF_IMM_NAME = 0x2
	1781	NFTA_OBJREF_SET_SREG = 0x3
	1782	NFTA_OBJREF_SET_NAME = 0x4
	1783	NFTA_OBJREF_SET_ID = 0x5
	1784	NFTA_GEN_UNSPEC = 0x0
	1785	NFTA_GEN_ID = 0x1
	1786	NFTA_GEN_PROC_PID = 0x2
	1787	NFTA_GEN_PROC_NAME = 0x3
	1788	NFTA_FIB_UNSPEC = 0x0
	1789	NFTA_FIB_DREG = 0x1
	1790	NFTA_FIB_RESULT = 0x2
	1791	NFTA_FIB_FLAGS = 0x3
	1792	NFT_FIB_RESULT_UNSPEC = 0x0
	1793	NFT_FIB_RESULT_OIF = 0x1
	1794	NFT_FIB_RESULT_OIFNAME = 0x2
	1795	NFT_FIB_RESULT_ADDRTYPE = 0x3
	1796	NFTA_FIB_F_SADDR = 0x1
	1797	NFTA_FIB_F_DADDR = 0x2
	1798	NFTA_FIB_F_MARK = 0x4
	1799	NFTA_FIB_F_IIF = 0x8
	1800	NFTA_FIB_F_OIF = 0x10
	1801	NFTA_FIB_F_PRESENT = 0x20
	1802	NFTA_CT_HELPER_UNSPEC = 0x0
	1803	NFTA_CT_HELPER_NAME = 0x1
	1804	NFTA_CT_HELPER_L3PROTO = 0x2
	1805	NFTA_CT_HELPER_L4PROTO = 0x3
	1806	NFTA_OBJ_UNSPEC = 0x0
	1807	NFTA_OBJ_TABLE = 0x1
	1808	NFTA_OBJ_NAME = 0x2
	1809	NFTA_OBJ_TYPE = 0x3
	1810	NFTA_OBJ_DATA = 0x4
	1811	NFTA_OBJ_USE = 0x5
	1812	NFTA_TRACE_UNSPEC = 0x0
	1813	NFTA_TRACE_TABLE = 0x1
	1814	NFTA_TRACE_CHAIN = 0x2
	1815	NFTA_TRACE_RULE_HANDLE = 0x3
	1816	NFTA_TRACE_TYPE = 0x4
	1817	NFTA_TRACE_VERDICT = 0x5
	1818	NFTA_TRACE_ID = 0x6
	1819	NFTA_TRACE_LL_HEADER = 0x7
	1820	NFTA_TRACE_NETWORK_HEADER = 0x8
	1821	NFTA_TRACE_TRANSPORT_HEADER = 0x9
	1822	NFTA_TRACE_IIF = 0xa
	1823	NFTA_TRACE_IIFTYPE = 0xb
	1824	NFTA_TRACE_OIF = 0xc
	1825	NFTA_TRACE_OIFTYPE = 0xd
	1826	NFTA_TRACE_MARK = 0xe
	1827	NFTA_TRACE_NFPROTO = 0xf
	1828	NFTA_TRACE_POLICY = 0x10
	1829	NFTA_TRACE_PAD = 0x11
	1830	NFT_TRACETYPE_UNSPEC = 0x0
	1831	NFT_TRACETYPE_POLICY = 0x1
	1832	NFT_TRACETYPE_RETURN = 0x2
	1833	NFT_TRACETYPE_RULE = 0x3
	1834	NFTA_NG_UNSPEC = 0x0
	1835	NFTA_NG_DREG = 0x1
	1836	NFTA_NG_MODULUS = 0x2
	1837	NFTA_NG_TYPE = 0x3
	1838	NFTA_NG_OFFSET = 0x4
	1839	NFT_NG_INCREMENTAL = 0x0
	1840	NFT_NG_RANDOM = 0x1
	1841	)
	1842
	1843	type RTCTime struct {
	1844	Sec int32
	1845	Min int32
	1846	Hour int32
	1847	Mday int32
	1848	Mon int32
	1849	Year int32
	1850	Wday int32
	1851	Yday int32
	1852	Isdst int32
	1853	}
	1854
	1855	type RTCWkAlrm struct {
	1856	Enabled uint8
	1857	Pending uint8
	1858	Time RTCTime
	1859	}
	1860
	1861	type RTCPLLInfo struct {
	1862	Ctrl int32
	1863	Value int32
	1864	Max int32
	1865	Min int32
	1866	Posmult int32
	1867	Negmult int32
	1868	Clock int64
	1869	}
	1870
	1871	type BlkpgIoctlArg struct {
	1872	Op int32
	1873	Flags int32
	1874	Datalen int32
	1875	Data *byte
	1876	}
	1877
	1878	type BlkpgPartition struct {
	1879	Start int64
	1880	Length int64
	1881	Pno int32
	1882	Devname [64]uint8
	1883	Volname [64]uint8
	1884	_ [4]byte
	1885	}
	1886
	1887	const (
	1888	BLKPG = 0x20001269
	1889	BLKPG_ADD_PARTITION = 0x1
	1890	BLKPG_DEL_PARTITION = 0x2
	1891	BLKPG_RESIZE_PARTITION = 0x3
	1892	)
	1893
	1894	const (
	1895	NETNSA_NONE = 0x0
	1896	NETNSA_NSID = 0x1
	1897	NETNSA_PID = 0x2
	1898	NETNSA_FD = 0x3
	1899	)
	1900
	1901	type XDPRingOffset struct {
	1902	Producer uint64
	1903	Consumer uint64
	1904	Desc uint64
	1905	}
	1906
	1907	type XDPMmapOffsets struct {
	1908	Rx XDPRingOffset
	1909	Tx XDPRingOffset
	1910	Fr XDPRingOffset
	1911	Cr XDPRingOffset
	1912	}
	1913
	1914	type XDPUmemReg struct {
	1915	Addr uint64
	1916	Len uint64
	1917	Size uint32
	1918	Headroom uint32
	1919	}
	1920
	1921	type XDPStatistics struct {
	1922	Rx_dropped uint64
	1923	Rx_invalid_descs uint64
	1924	Tx_invalid_descs uint64
	1925	}
	1926
	1927	type XDPDesc struct {
	1928	Addr uint64
	1929	Len uint32
	1930	Options uint32
	1931	}
	1932
	1933	const (
	1934	NCSI_CMD_UNSPEC = 0x0
	1935	NCSI_CMD_PKG_INFO = 0x1
	1936	NCSI_CMD_SET_INTERFACE = 0x2
	1937	NCSI_CMD_CLEAR_INTERFACE = 0x3
	1938	NCSI_ATTR_UNSPEC = 0x0
	1939	NCSI_ATTR_IFINDEX = 0x1
	1940	NCSI_ATTR_PACKAGE_LIST = 0x2
	1941	NCSI_ATTR_PACKAGE_ID = 0x3
	1942	NCSI_ATTR_CHANNEL_ID = 0x4
	1943	NCSI_PKG_ATTR_UNSPEC = 0x0
	1944	NCSI_PKG_ATTR = 0x1
	1945	NCSI_PKG_ATTR_ID = 0x2
	1946	NCSI_PKG_ATTR_FORCED = 0x3
	1947	NCSI_PKG_ATTR_CHANNEL_LIST = 0x4
	1948	NCSI_CHANNEL_ATTR_UNSPEC = 0x0
	1949	NCSI_CHANNEL_ATTR = 0x1
	1950	NCSI_CHANNEL_ATTR_ID = 0x2
	1951	NCSI_CHANNEL_ATTR_VERSION_MAJOR = 0x3
	1952	NCSI_CHANNEL_ATTR_VERSION_MINOR = 0x4
	1953	NCSI_CHANNEL_ATTR_VERSION_STR = 0x5
	1954	NCSI_CHANNEL_ATTR_LINK_STATE = 0x6
	1955	NCSI_CHANNEL_ATTR_ACTIVE = 0x7
	1956	NCSI_CHANNEL_ATTR_FORCED = 0x8
	1957	NCSI_CHANNEL_ATTR_VLAN_LIST = 0x9
	1958	NCSI_CHANNEL_ATTR_VLAN_ID = 0xa
	1959	)
	1960
	1961	const (
	1962	SOF_TIMESTAMPING_TX_HARDWARE = 0x1
	1963	SOF_TIMESTAMPING_TX_SOFTWARE = 0x2
	1964	SOF_TIMESTAMPING_RX_HARDWARE = 0x4
	1965	SOF_TIMESTAMPING_RX_SOFTWARE = 0x8
	1966	SOF_TIMESTAMPING_SOFTWARE = 0x10
	1967	SOF_TIMESTAMPING_SYS_HARDWARE = 0x20
	1968	SOF_TIMESTAMPING_RAW_HARDWARE = 0x40
	1969	SOF_TIMESTAMPING_OPT_ID = 0x80
	1970	SOF_TIMESTAMPING_TX_SCHED = 0x100
	1971	SOF_TIMESTAMPING_TX_ACK = 0x200
	1972	SOF_TIMESTAMPING_OPT_CMSG = 0x400
	1973	SOF_TIMESTAMPING_OPT_TSONLY = 0x800
	1974	SOF_TIMESTAMPING_OPT_STATS = 0x1000
	1975	SOF_TIMESTAMPING_OPT_PKTINFO = 0x2000
	1976	SOF_TIMESTAMPING_OPT_TX_SWHW = 0x4000
	1977
	1978	SOF_TIMESTAMPING_LAST = 0x4000
	1979	SOF_TIMESTAMPING_MASK = 0x7fff
	1980	)