shithub: mc

Download patch

ref: a5cc4f8eb810cd58f38333d2c5a64b5cd96bba89
parent: 97df0d05c25daa84262b45385694eaebcf1eb59e
author: Ori Bernstein <ori@obwan.hsd1.ca.comcast.net>
date: Tue Sep 12 15:58:06 EDT 2017

Add syscalls for OpenBSD 6.2

--- /dev/null
+++ b/lib/sys/sys+openbsd:6.2-x64.myr
@@ -1,0 +1,1758 @@
+/*
+  generated-ish source
+  stitched for openbsd:6.2 arch:x64
+  edit with caution.
+ */
+pkg sys =
+	type size	= int64	/* spans entire address space */
+	type usize	= uint64	/* unsigned size */
+	type off	= int64	/* file offsets */
+	type intptr	= uint64/* can hold any pointer losslessly */
+	type time	= int64	/* milliseconds since epoch */
+	type pid	= int32	/* process id */
+	type scno	= int64	/*syscall*/
+	type fdopt	= int64	/* fd options */
+	type fd		= int32	/* fd */
+	type whence	= uint64	/* seek from whence */
+	type mprot	= int64	/* memory protection */
+	type mopt	= int64	/* memory mapping options */
+	type socktype	= int64	/* socket type */
+	type sockproto	= int64	/* socket protocol */
+	type sockopt	= int32	/* socket option */
+	type sockfam	= uint8	/* socket family */
+	type filemode	= uint32
+	type filetype	= uint8
+	type fcntlcmd	= int64
+	type signo	= int32
+	type sigflags	= int32
+	type sigset	= uint32
+	type msg	= void
+	
+	type clock = union
+		`Clockrealtime
+		`Clockmonotonic
+		`Clockproccputime
+		`Clockthreadcputime
+		`Clockuptime
+	;;
+	
+	type waitstatus = union
+		`Waitfail int32
+		`Waitexit int32
+		`Waitsig  int32
+		`Waitstop int32
+	;;
+	
+	type rlimit = struct
+		cur	: uint64	/* current (soft) limit */
+		max	: uint64	/* maximum value for rlim_cur */
+	;;
+	
+	type timespec = struct
+		sec	: uint64
+		nsec	: uint64 
+	;;
+	
+	type timeval = struct
+		sec	: uint64
+		usec	: uint64
+	;;
+	
+	type timezone = struct
+		minwest	: int32	/* minutes west of Greenwich */
+		dsttime	: int32	/* type of dst correction */
+	;;
+	
+	type pollfd = struct
+		fd      : fd
+		events  : uint16
+		revents : uint16
+	;;
+	
+	type itimerval = struct
+		interval	: timeval	/* timer interval */
+		value		: timeval	/* current value */
+	;;
+	
+	type sigaction = struct
+		handler	: byte#	/* code pointer */
+		mask	: sigset
+		flags	: sigflags
+	;;
+	/*
+	 * Information pushed on stack when a signal is delivered.
+	 * This is used by the kernel to restore state following
+	 * execution of the signal handler.  It is also made available
+	 * to the handler to allow it to restore state properly if
+	 * a non-standard exit is performed.
+	 */
+	type sigcontext = struct
+		/* plain match trapframe */
+		rdi	: int64
+		rsi	: int64
+		rdx	: int64
+		rcx	: int64
+		r8	: int64
+		r9	: int64
+		r10	: int64
+		r11	: int64
+		r12	: int64
+		r13	: int64
+		r14	: int64
+		r15	: int64
+		rbp	: int64
+		rbx	: int64
+		rax	: int64
+		gs	: int64
+		fs	: int64
+		es	: int64
+		ds	: int64
+		trapno	: int64
+		err	: int64
+		rip	: int64
+		cs	: int64
+		rflags	: int64
+		rsp	: int64
+		ss	: int64
+	
+		fpstate	: fxsave64#
+		__pad	: int32
+		mask	: int32
+		cookie	: int64
+	;;
+	
+	type sigaltstack = struct
+		sp	: void#
+		size	: size
+		flags	: int32
+	;;
+	
+	type fxsave64 = struct
+		fcw	: int16
+		fsw	: int16
+		ftw	: int8
+		unused1	: int8
+		fop	: int16
+		rip	: int64
+		rdp	: int64
+		mxcsr	: int32
+		mxcsrmask	: int32
+		st	: int64[8][2]   /* 8 normal FP regs */
+		xmm	: int64[16][2] /* 16 SSE2 registers */
+		unused3	: int8[96]
+	;;
+	
+	const Simaxsz	= 128
+	const Sipad	= (Simaxsz / 4) - 3
+	type siginfo = struct
+		signo	: int
+		code	: int
+		errno	: int
+		pad	: int[Sipad]
+	;;
+	
+	type rusage = struct
+		utime	: timeval /* user time */
+		stime	: timeval /* system time */
+		maxrss	: uint64 /* max resident set size*/
+		ixrss	: uint64 /* shared text size */
+		idrss	: uint64 /* unshared data size */
+		isrss	: uint64 /* unshared stack size */
+		minflt	: uint64 /* page reclaims */
+		majflt	: uint64 /* page faults */
+		nswap	: uint64 /* swaps */
+		inblock	: uint64 /* block input ops */
+		oublock	: uint64 /* block output ops */
+		msgsnd	: uint64 /* messages sent */	
+		msgrcv	: uint64 /* messages received */
+		nsignals : uint64 /* signals received */
+		nvcsw	: uint64 /* voluntary context switches */
+		nivcsw	: uint64 /* involuntary context switches */
+	;;
+	
+	type tforkparams = struct
+		tcb	: void#
+		tid	: pid#
+		stk	: byte#
+	;;
+	
+	type statbuf = struct
+		mode	: filemode
+		dev	: uint32 
+		ino	: uint64
+		nlink	: uint32
+		uid	: uint32
+		gid	: uint32
+		rdev	: uint32
+		atime	: timespec
+		mtime	: timespec
+		ctime	: timespec
+		size	: off
+		blocks	: int64
+		blksize	: uint32
+		flags	: uint32
+		gen	: uint32
+		birthtim	: timespec 
+	;;
+	
+	type semun = struct
+		semarr	: void#
+	;;
+	
+	const Mfsnamelen 	= 16	/* length of fs type name, including nul */
+	const Mnamelen		= 90	/* length of buffer for returned name */
+	
+	type statfs = struct
+		flags	: uint32	/* copy of mount flags */
+		bsize	: uint32	/* file system block size */
+		iosize	: uint32	/* optimal transfer block size */
+	
+			        	/* unit is f_bsize */
+		blocks	: uint64	/* total data blocks in file system */
+		bfree	: uint64	/* free blocks in fs */
+		bavail	: int64		/* free blocks avail to non-superuser */
+	
+		files	: int64		/* total file nodes in file system */
+		ffree	: int64		/* free file nodes in fs */
+		favail	: int64		/* free file nodes avail to non-root */
+	
+		syncwr	: int64		/* count of sync writes since mount */
+		syncrd	: int64		/* count of sync reads since mount */
+		asyncwr	: int64		/* count of async writes since mount */
+		asyncrd	: int64		/* count of async reads since mount */
+	
+		fsid	: fsid		/* file system id */
+		namemax	: uint32	/* maximum filename length */
+		owner	: uid		/* user that mounted the file system */
+		ctime	: uint64	/* last mount [-u] time */
+	
+		fstypename	: byte[Mfsnamelen];	/* fs type name */
+		mntonname	: byte[Mnamelen];	/* directory on which mounted */
+		mntfromname	: byte[Mnamelen];	/* mounted file system */
+		mntfromspec	: byte[Mnamelen];	/* special for mount request */
+		///union mount_info mount_info;	/* per-filesystem mount options */
+		__mountinfo	: byte[160];	/* storage for 'union mount_info' */
+	;;
+	
+	type utsname = struct
+		system	: byte[32]
+		node : byte[32] 
+		release : byte[32]
+		version : byte[32]
+		machine : byte[32]
+	;;
+	
+	type sockaddr = struct
+		len	: byte
+		fam	: sockfam
+		data	: byte[14] /* what is the *actual* length? */
+	;;
+	
+	type sockaddr_in = struct
+		len	: byte
+		fam	: sockfam
+		port	: uint16
+		addr	: byte[4]
+		zero	: byte[8]
+	;;
+	
+	type sockaddr_in6 = struct
+		len	: byte
+		fam	: sockfam
+		port	: uint16
+		flow	: uint32
+		addr	: byte[16]
+		scope	: uint32
+	;;
+	
+	type sockaddr_un = struct
+		len	: uint8
+		fam	: sockfam
+		path	: byte[104]
+	;;
+	
+	type sockaddr_storage = struct
+		len	: byte
+		fam	: sockfam
+		__pad1  : byte[6]
+		__align : int64
+		__pad2  : byte[240]
+	;;	
+	
+	type dirent = struct
+		fileno	: uint64
+		off	: uint64
+		reclen	: uint16
+		ftype	: uint8
+		namlen	: uint8
+		__pad	: byte[4]
+		name	: byte[256]	
+	;;
+	
+	type iovec = struct
+		base	: byte#
+		len	: uint64
+	;;
+	
+	/* open options */
+	const Ordonly  	: fdopt = 0x0
+	const Owronly  	: fdopt = 0x1
+	const Ordwr    	: fdopt = 0x2
+	const Oappend  	: fdopt = 0x8
+	const Ondelay  	: fdopt = 0x4
+	const Oshlock	: fdopt = 0x10		/* open with shared file lock */
+	const Oexlock	: fdopt = 0x20		/* open with exclusive file lock */
+	const Oasync	: fdopt = 0x40		/* signal pgrp when data ready */
+	const Osync	: fdopt = 0x80		/* backwards compatibility */
+	const Onofollow	: fdopt = 0x100
+	const Ocreat   	: fdopt = 0x200
+	const Otrunc   	: fdopt = 0x400
+	const Oexcl   	: fdopt = 0x800
+	const Ocloexec	: fdopt = 0x10000
+	const Odsync	: fdopt = Osync		/* synchronous data writes */
+	const Orsync	: fdopt = Osync		/* synchronous reads */
+	const Odir	: fdopt = 0x20000
+	
+	/* poll options */
+	const Pollin	: uint16 = 0x0001
+	const Pollpri	: uint16 = 0x0002
+	const Pollout	: uint16 = 0x0004
+	const Pollerr	: uint16 = 0x0008
+	const Pollhup	: uint16 = 0x0010
+	const Pollnval	: uint16 = 0x0020
+	const Pollnorm	: uint16 = 0x0040
+	const Pollrdband: uint16 = 0x0080
+	const Pollwrband: uint16 = 0x0100
+	
+	/* stat modes */	
+	const Sifmt	: filemode = 0xf000
+	const Sififo	: filemode = 0x1000
+	const Sifchr	: filemode = 0x2000
+	const Sifdir	: filemode = 0x4000
+	const Sifblk	: filemode = 0x6000
+	const Sifreg	: filemode = 0x8000
+	const Siflnk	: filemode = 0xa000
+	const Sifsock 	: filemode = 0xc000
+	const Sisvtx 	: filemode = 0x0200
+	
+	/* mmap protection */
+	const Mprotnone	: mprot = 0x0
+	const Mprotrd	: mprot = 0x1
+	const Mprotwr	: mprot = 0x2
+	const Mprotexec	: mprot = 0x4
+	const Mprotrw	: mprot = 0x3
+	
+	/* mmap options */
+	const Mshared	: mopt = 0x1
+	const Mpriv	: mopt = 0x2
+	const Mfixed	: mopt = 0x10
+	const Mfile	: mopt = 0x0
+	const Manon	: mopt = 0x1000
+	const Mnoreplace	: mopt = 0x0800
+	
+	/* file types */
+	const Dtunknown	: filetype = 0
+	const Dtfifo	: filetype = 1
+	const Dtchr	: filetype = 2
+	const Dtdir	: filetype = 4
+	const Dtblk	: filetype = 6
+	const Dtreg	: filetype = 8
+	const Dtlnk	: filetype = 10
+	const Dtsock	: filetype = 12
+	
+	/* socket families. INCOMPLETE. */
+	const Afunspec	: sockfam = 0
+	const Afunix	: sockfam = 1
+	const Afinet	: sockfam = 2
+	const Afinet6	: sockfam = 24
+	
+	/* socket types. */
+	const Sockstream	: socktype = 1
+	const Sockdgram		: socktype = 2
+	const Sockraw		: socktype = 3
+	const Sockrdm		: socktype = 4
+	const Sockseqpacket	: socktype = 5
+	
+	/* socket options */
+	const Sodebug		: sockopt = 0x0001	/* turn on debugging info recording */
+	const Soacceptconn	: sockopt = 0x0002	/* socket has had listen() */
+	const Soreuseaddr	: sockopt = 0x0004	/* allow local address reuse */
+	const Sokeepalive	: sockopt = 0x0008	/* keep connections alive */
+	const Sodontroute	: sockopt = 0x0010	/* just use interface addresses */
+	const Sobroadcast	: sockopt = 0x0020	/* permit sending of broadcast msgs */
+	const Souseloopback	: sockopt = 0x0040	/* bypass hardware when possible */
+	const Solinger		: sockopt = 0x0080	/* linger on close if data present */
+	const Sooobinline	: sockopt = 0x0100	/* leave received OOB data in line */
+	const Soreuseport	: sockopt = 0x0200	/* allow local address & port reuse */
+	const Sotimestamp	: sockopt = 0x0800	/* timestamp received dgram traffic */
+	const Sobindany		: sockopt = 0x1000	/* allow bind to any address */
+	const Sosndbuf		: sockopt = 0x1001	/* send buffer size */
+	const Sorcvbuf		: sockopt = 0x1002	/* receive buffer size */
+	const Sosndlowat	: sockopt = 0x1003	/* send low-water mark */
+	const Sorcvlowat	: sockopt = 0x1004	/* receive low-water mark */
+	const Sosndtimeo	: sockopt = 0x1005	/* send timeout */
+	const Sorcvtimeo	: sockopt = 0x1006	/* receive timeout */
+	const Soerror		: sockopt = 0x1007	/* get error status and clear */
+	const Sotype		: sockopt = 0x1008	/* get socket type */
+	const Sonetproc		: sockopt = 0x1020	/* multiplex; network processing */
+	const Sortable		: sockopt = 0x1021	/* routing table to be used */
+	const Sopeercred	: sockopt = 0x1022	/* get connect-time credentials */
+	const Sosplice		: sockopt = 0x1023	/* splice data to other socket */
+	
+	/* socket option levels */
+	const Solsocket		: sockproto = 0xffff
+	
+	/* network protocols */
+	const Ipproto_ip	: sockproto = 0
+	const Ipproto_icmp	: sockproto = 1
+	const Ipproto_tcp	: sockproto = 6
+	const Ipproto_udp	: sockproto = 17
+	const Ipproto_raw	: sockproto = 255
+	
+	const Seekset	: whence = 0
+	const Seekcur	: whence = 1
+	const Seekend	: whence = 2
+	
+	/* system specific constants */
+	const Maxpathlen	: size = 1024
+	
+	/* fcntl constants */
+	const Fdupfd	 : fcntlcmd = 0		/* duplicate file descriptor */
+	const Fgetfd	 : fcntlcmd = 1		/* get file descriptor flags */
+	const Fsetfd	 : fcntlcmd = 2		/* set file descriptor flags */
+	const Fgetfl	 : fcntlcmd = 3		/* get file status flags */
+	const Fsetfl	 : fcntlcmd = 4		/* set file status flags */
+	const Fgetown	 : fcntlcmd = 5		/* get SIGIO/SIGURG proc/pgrp */
+	const Fsetown	 : fcntlcmd = 6		/* set SIGIO/SIGURG proc/pgrp */
+	const Fogetlk	 : fcntlcmd = 7		/* get record locking information */
+	const Fosetlk	 : fcntlcmd = 8		/* set record locking information */
+	
+	/* return value for a failed mapping */
+	const Mapbad	: byte# = (-1 : byte#)
+	
+	/* signal flags */
+	const Saonstack		: sigflags = 0x0001	/* take signal on signal stack */
+	const Sarestart		: sigflags = 0x0002	/* restart system on signal return */
+	const Saresethand	: sigflags = 0x0004	/* reset to SIG_DFL when taking signal */
+	const Sanodefer		: sigflags = 0x0010	/* don't mask the signal we're delivering */
+	const Sanocldwait	: sigflags = 0x0020	/* don't create zombies (assign to pid 1) */
+	const Sanocldstop	: sigflags = 0x0008	/* do not generate SIGCHLD on child stop */
+	const Sasiginfo		: sigflags = 0x0040	/* generate siginfo_t */
+	
+	/* signals */
+	const Sighup	: signo = 1	/* hangup */
+	const Sigint	: signo = 2	/* interrupt */
+	const Sigquit	: signo = 3	/* quit */
+	const Sigill	: signo = 4	/* illegal instruction (not reset when caught) */
+	const Sigtrap	: signo = 5	/* trace trap (not reset when caught) */
+	const Sigabrt	: signo = 6	/* abort() */
+	const Sigiot	: signo = Sigabrt	/* compatibility */
+	const Sigemt	: signo = 7	/* EMT instruction */
+	const Sigfpe	: signo = 8	/* floating point exception */
+	const Sigkill	: signo = 9	/* kill (cannot be caught or ignored) */
+	const Sigbus	: signo = 10	/* bus error */
+	const Sigsegv	: signo = 11	/* segmentation violation */
+	const Sigsys	: signo = 12	/* bad argument to system call */
+	const Sigpipe	: signo = 13	/* write on a pipe with no one to read it */
+	const Sigalrm	: signo = 14	/* alarm clock */
+	const Sigterm	: signo = 15	/* software termination signal from kill */
+	const Sigurg	: signo = 16	/* urgent condition on IO channel */
+	const Sigstop	: signo = 17	/* sendable stop signal not from tty */
+	const Sigtstp	: signo = 18	/* stop signal from tty */
+	const Sigcont	: signo = 19	/* continue a stopped process */
+	const Sigchld	: signo = 20	/* to parent on child stop or exit */
+	const Sigttin	: signo = 21	/* to readers pgrp upon background tty read */
+	const Sigttou	: signo = 22	/* like TTIN for output if (tp->t_local&LTOSTOP) */
+	const Sigio	: signo = 23	/* input/output possible signal */
+	const Sigxcpu	: signo = 24	/* exceeded CPU time limit */
+	const Sigxfsz	: signo = 25	/* exceeded file size limit */
+	const Sigvtalrm : signo = 26	/* virtual time alarm */
+	const Sigprof	: signo = 27	/* profiling time alarm */
+	const Sigwinch	: signo = 28	/* window size changes */
+	const Siginfo	: signo = 29	/* information request */
+	const Sigusr1	: signo = 30	/* user defined signal 1 */
+	const Sigusr2	: signo = 31	/* user defined signal 2 */
+	const Sigthr	: signo = 32	/* thread library AST */
+	
+	extern const syscall : (sc:scno, args:... -> int64)
+	extern var __cenvp : byte##
+	type dev = int32
+	type uid = uint32
+	type gid = uint32
+	type fd_mask = uint32
+	type uintptr = uint64
+	type clockid = int32
+	type id = uint32
+	type key = int64
+	type shmatt = int16
+	
+	type tfork = struct
+		tcb	: void#
+		tid	: pid#
+		stack	: void#
+	
+	;;
+	
+	type msghdr = struct
+		name	: void#
+		namelen	: int32
+		iov	: iovec#
+		iovlen	: uint
+		control	: void#
+		controllen	: int32
+		flags	: int
+	
+	;;
+	
+	type fsid = struct
+		val	: int32[2]
+	
+	;;
+	
+	type fid = struct
+		len	: uint16
+		reserved	: uint16
+		data	: byte[16]
+	
+	;;
+	
+	type fhandle = struct
+		fsid	: fsid
+		fid	: fid
+	
+	;;
+	
+	type fdset = struct
+		bits	: fd_mask[32]
+	
+	;;
+	
+	type kevent = struct
+		ident	: uintptr
+		filter	: int16
+		flags	: uint16
+		fflags	: uint
+		data	: int64
+		udata	: void#
+	
+	;;
+	
+	type kbind = struct
+		addr	: void#
+		size	: size
+	
+	;;
+	
+	type sembuf = struct
+		num	: uint16
+		op	: int16
+		flg	: int16
+	
+	;;
+	
+	type ipc_perm = struct
+		cuid	: uid
+		cgid	: gid
+		uid	: uid
+		gid	: gid
+		mode	: filemode
+		seq	: uint16
+		key	: key
+	
+	;;
+	
+	type shmid_ds = struct
+		perm	: ipc_perm
+		segsz	: int
+		lpid	: pid
+		cpid	: pid
+		nattch	: shmatt
+		atime	: time
+		atimensec	: int64
+		dtime	: time
+		dtimensec	: int64
+		ctime	: time
+		ctimensec	: int64
+		internal	: void#
+	
+	;;
+	
+	type msqid_ds = struct
+		perm	: ipc_perm
+		first	: msg#
+		last	: msg#
+		cbytes	: uint64
+		qnum	: uint64
+		qbytes	: uint64
+		lspid	: pid
+		lrpid	: pid
+		stime	: time
+		pad1	: int64
+		rtime	: time
+		pad2	: int64
+		ctime	: time
+		pad3	: int64
+		pad4	: int64[4]
+	
+	;;
+	
+
+	const Sysexit			: scno = 1
+	const Sysfork			: scno = 2
+	const Sysread			: scno = 3
+	const Syswrite			: scno = 4
+	const Sysopen			: scno = 5
+	const Sysclose			: scno = 6
+	const Sysgetentropy		: scno = 7
+	const Sys__tfork		: scno = 8
+	const Syslink			: scno = 9
+	const Sysunlink			: scno = 10
+	const Syswait4			: scno = 11
+	const Syschdir			: scno = 12
+	const Sysfchdir			: scno = 13
+	const Sysmknod			: scno = 14
+	const Syschmod			: scno = 15
+	const Syschown			: scno = 16
+	const Sysobreak			: scno = 17
+	const Sysgetdtablecount		: scno = 18
+	const Sysgetrusage		: scno = 19
+	const Sysgetpid			: scno = 20
+	const Sysmount			: scno = 21
+	const Sysunmount		: scno = 22
+	const Syssetuid			: scno = 23
+	const Sysgetuid			: scno = 24
+	const Sysgeteuid		: scno = 25
+	const Sysptrace			: scno = 26
+	const Sysrecvmsg		: scno = 27
+	const Syssendmsg		: scno = 28
+	const Sysrecvfrom		: scno = 29
+	const Sysaccept			: scno = 30
+	const Sysgetpeername		: scno = 31
+	const Sysgetsockname		: scno = 32
+	const Sysaccess			: scno = 33
+	const Syschflags		: scno = 34
+	const Sysfchflags		: scno = 35
+	const Syssync			: scno = 36
+	const Sysstat			: scno = 38
+	const Sysgetppid		: scno = 39
+	const Syslstat			: scno = 40
+	const Sysdup			: scno = 41
+	const Sysfstatat		: scno = 42
+	const Sysgetegid		: scno = 43
+	const Sysprofil			: scno = 44
+	const Sysktrace			: scno = 45
+	const Syssigaction		: scno = 46
+	const Sysgetgid			: scno = 47
+	const Syssigprocmask		: scno = 48
+	const Syssetlogin		: scno = 50
+	const Sysacct			: scno = 51
+	const Syssigpending		: scno = 52
+	const Sysfstat			: scno = 53
+	const Sysioctl			: scno = 54
+	const Sysreboot			: scno = 55
+	const Sysrevoke			: scno = 56
+	const Syssymlink		: scno = 57
+	const Sysreadlink		: scno = 58
+	const Sysexecve			: scno = 59
+	const Sysumask			: scno = 60
+	const Syschroot			: scno = 61
+	const Sysgetfsstat		: scno = 62
+	const Sysstatfs			: scno = 63
+	const Sysfstatfs		: scno = 64
+	const Sysfhstatfs		: scno = 65
+	const Sysvfork			: scno = 66
+	const Sysgettimeofday		: scno = 67
+	const Syssettimeofday		: scno = 68
+	const Syssetitimer		: scno = 69
+	const Sysgetitimer		: scno = 70
+	const Sysselect			: scno = 71
+	const Syskevent			: scno = 72
+	const Sysmunmap			: scno = 73
+	const Sysmprotect		: scno = 74
+	const Sysmadvise		: scno = 75
+	const Sysutimes			: scno = 76
+	const Sysfutimes		: scno = 77
+	const Sysmincore		: scno = 78
+	const Sysgetgroups		: scno = 79
+	const Syssetgroups		: scno = 80
+	const Sysgetpgrp		: scno = 81
+	const Syssetpgid		: scno = 82
+	const Sysfutex			: scno = 83
+	const Sysutimensat		: scno = 84
+	const Sysfutimens		: scno = 85
+	const Syskbind			: scno = 86
+	const Sysclock_gettime		: scno = 87
+	const Sysclock_settime		: scno = 88
+	const Sysclock_getres		: scno = 89
+	const Sysdup2			: scno = 90
+	const Sysnanosleep		: scno = 91
+	const Sysfcntl			: scno = 92
+	const Sysaccept4		: scno = 93
+	const Sys__thrsleep		: scno = 94
+	const Sysfsync			: scno = 95
+	const Syssetpriority		: scno = 96
+	const Syssocket			: scno = 97
+	const Sysconnect		: scno = 98
+	const Sysgetdents		: scno = 99
+	const Sysgetpriority		: scno = 100
+	const Syspipe2			: scno = 101
+	const Sysdup3			: scno = 102
+	const Syssigreturn		: scno = 103
+	const Sysbind			: scno = 104
+	const Syssetsockopt		: scno = 105
+	const Syslisten			: scno = 106
+	const Syschflagsat		: scno = 107
+	const Syspledge			: scno = 108
+	const Sysppoll			: scno = 109
+	const Syspselect		: scno = 110
+	const Syssigsuspend		: scno = 111
+	const Syssendsyslog		: scno = 112
+	const Sysfktrace		: scno = 113
+	const Sysgetsockopt		: scno = 118
+	const Systhrkill		: scno = 119
+	const Sysreadv			: scno = 120
+	const Syswritev			: scno = 121
+	const Syskill			: scno = 122
+	const Sysfchown			: scno = 123
+	const Sysfchmod			: scno = 124
+	const Syssetreuid		: scno = 126
+	const Syssetregid		: scno = 127
+	const Sysrename			: scno = 128
+	const Sysflock			: scno = 131
+	const Sysmkfifo			: scno = 132
+	const Syssendto			: scno = 133
+	const Sysshutdown		: scno = 134
+	const Syssocketpair		: scno = 135
+	const Sysmkdir			: scno = 136
+	const Sysrmdir			: scno = 137
+	const Sysadjtime		: scno = 140
+	const Sysgetlogin_r		: scno = 141
+	const Syssetsid			: scno = 147
+	const Sysquotactl		: scno = 148
+	const Sysnfssvc			: scno = 155
+	const Sysgetfh			: scno = 161
+	const Syssysarch		: scno = 165
+	const Syspread			: scno = 173
+	const Syspwrite			: scno = 174
+	const Syssetgid			: scno = 181
+	const Syssetegid		: scno = 182
+	const Sysseteuid		: scno = 183
+	const Syspathconf		: scno = 191
+	const Sysfpathconf		: scno = 192
+	const Sysswapctl		: scno = 193
+	const Sysgetrlimit		: scno = 194
+	const Syssetrlimit		: scno = 195
+	const Sysmmap			: scno = 197
+	const Syslseek			: scno = 199
+	const Systruncate		: scno = 200
+	const Sysftruncate		: scno = 201
+	const Syssysctl			: scno = 202
+	const Sysmlock			: scno = 203
+	const Sysmunlock		: scno = 204
+	const Sysgetpgid		: scno = 207
+	const Sysutrace			: scno = 209
+	const Syssemget			: scno = 221
+	const Sysmsgget			: scno = 225
+	const Sysmsgsnd			: scno = 226
+	const Sysmsgrcv			: scno = 227
+	const Sysshmat			: scno = 228
+	const Sysshmdt			: scno = 230
+	const Sysminherit		: scno = 250
+	const Syspoll			: scno = 252
+	const Sysissetugid		: scno = 253
+	const Syslchown			: scno = 254
+	const Sysgetsid			: scno = 255
+	const Sysmsync			: scno = 256
+	const Syspipe			: scno = 263
+	const Sysfhopen			: scno = 264
+	const Syspreadv			: scno = 267
+	const Syspwritev		: scno = 268
+	const Syskqueue			: scno = 269
+	const Sysmlockall		: scno = 271
+	const Sysmunlockall		: scno = 272
+	const Sysgetresuid		: scno = 281
+	const Syssetresuid		: scno = 282
+	const Sysgetresgid		: scno = 283
+	const Syssetresgid		: scno = 284
+	const Sysmquery			: scno = 286
+	const Sysclosefrom		: scno = 287
+	const Syssigaltstack		: scno = 288
+	const Sysshmget			: scno = 289
+	const Syssemop			: scno = 290
+	const Sysfhstat			: scno = 294
+	const Sys__semctl		: scno = 295
+	const Sysshmctl			: scno = 296
+	const Sysmsgctl			: scno = 297
+	const Syssched_yield		: scno = 298
+	const Sysgetthrid		: scno = 299
+	const Sys__thrwakeup		: scno = 301
+	const Sys__threxit		: scno = 302
+	const Sys__thrsigdivert		: scno = 303
+	const Sys__getcwd		: scno = 304
+	const Sysadjfreq		: scno = 305
+	const Syssetrtable		: scno = 310
+	const Sysgetrtable		: scno = 311
+	const Sysfaccessat		: scno = 313
+	const Sysfchmodat		: scno = 314
+	const Sysfchownat		: scno = 315
+	const Syslinkat			: scno = 317
+	const Sysmkdirat		: scno = 318
+	const Sysmkfifoat		: scno = 319
+	const Sysmknodat		: scno = 320
+	const Sysopenat			: scno = 321
+	const Sysreadlinkat		: scno = 322
+	const Sysrenameat		: scno = 323
+	const Syssymlinkat		: scno = 324
+	const Sysunlinkat		: scno = 325
+	const Sys__set_tcb		: scno = 329
+	const Sys__get_tcb		: scno = 330
+
+	/* start manual overrides { */
+	const exit	: (status:int -> void)
+	const getpid	: ( -> pid)
+	const kill	: (pid:pid, sig:int64 -> int64)
+	const fork	: (-> pid)
+	const wait4	: (pid:pid, loc:int32#, opt : int64, usage:rusage#	-> int64)
+	const waitpid	: (pid:pid, loc:int32#, opt : int64	-> int64)
+	const execv	: (cmd : byte[:], args : byte[:][:] -> int64)
+	const execve	: (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64)
+	const waitstatus	: (st : int32 -> waitstatus)
+	extern const __tfork_thread	: (tfp : tforkparams#, sz : size, fn : void#, arg : void# -> pid)
+	const open	: (path:byte[:], opts:fdopt -> fd)
+	const openmode	: (path:byte[:], opts:fdopt, mode:int64 -> fd)
+	const close	: (fd:fd -> int64)
+	const creat	: (path:byte[:], mode:int64 -> fd)
+	const unlink	: (path:byte[:] -> int)
+	const read	: (fd:fd, buf:byte[:] -> size)
+	const pread	: (fd:fd, buf:byte[:], off : off -> size)
+	const readv	: (fd:fd, iov:iovec[:] -> size)
+	const write	: (fd:fd, buf:byte[:] -> size)
+	const pwrite	: (fd:fd, buf:byte[:], off : off -> size)
+	const writev	: (fd:fd, iov:iovec[:] -> size)
+	const lseek	: (fd:fd, off : off, whence : whence -> int64)
+	const stat	: (path:byte[:], sb:statbuf# -> int64)
+	const lstat	: (path:byte[:], sb:statbuf# -> int64)
+	const fstat	: (fd:fd, sb:statbuf# -> int64)
+	const mkdir	: (path : byte[:], mode : int64	-> int64)
+	generic ioctl	: (fd:fd, req : int64, arg:@a# -> int64)
+	const getdents	: (fd : fd, buf : byte[:] -> int64)
+	const chdir	: (p : byte[:] -> int64)
+	const __getcwd	: (buf : byte[:] -> int64)
+	const poll	: (pfd : pollfd[:], tm : int -> int)
+	const sigaction	: (sig : signo, act : sigaction#, oact : sigaction# -> int)
+	const sigprocmask	: (how : int32, set : sigset#, oset : sigset# -> int)
+	const pipe	: (fds : fd[2]# -> int64)
+	const dup	: (fd : fd -> fd)
+	const dup2	: (src : fd, dst : fd -> fd)
+	const fcntl	: (fd : fd, cmd : fcntlcmd, args : byte# -> int64)
+	const socket	: (dom : sockfam, stype : socktype, proto : sockproto	-> fd)
+	const connect	: (sock	: fd, addr : sockaddr#, len : size -> int)
+	const accept	: (sock : fd, addr : sockaddr#, len : size# -> fd)
+	const listen	: (sock : fd, backlog : int	-> int)
+	const bind	: (sock : fd, addr : sockaddr#, len : size -> int)
+	const setsockopt	: (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size -> int)
+	const getsockopt	: (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size# -> int)
+	const munmap	: (addr:byte#, len:size -> int64)
+	const mmap	: (addr:byte#, len:size, prot:mprot, flags:mopt, fd:fd, off:off -> byte#)
+	const clock_getres	: (clk : clock, ts : timespec# -> int32)
+	const clock_gettime	: (clk : clock, ts : timespec# -> int32)
+	const clock_settime	: (clk : clock, ts : timespec# -> int32)
+	const sleep	: (time : uint64 -> int32)
+	const nanosleep	: (req : timespec#, rem : timespec# -> int32)
+	const uname 	: (buf : utsname# -> int)
+	const sysctl	: (mib : int[:], \
+		old : void#, oldsz : size#, \
+		new : void#, newsz : size# \
+		-> int)
+	extern const cstring	: (str : byte[:] -> byte#)
+	extern const alloca	: (sz : size	-> byte#)
+	extern const __freebsd_pipe	: (fds : fd[2]# -> int64)
+	/* } end manual overrides */
+
+	const getentropy		:  (buf : void#, nbyte : size -> int)
+	const __tfork			:  (param : tfork#, psize : size -> int)
+	const link			:  (path : byte#, link : byte# -> int)
+	const fchdir			:  (fd : int -> int)
+	const mknod			:  (path : byte#, mode : filemode, dev : dev -> int)
+	const chmod			:  (path : byte#, mode : filemode -> int)
+	const chown			:  (path : byte#, uid : uid, gid : gid -> int)
+	const obreak			:  (nsize : byte# -> int)
+	const getdtablecount		:  ( -> int)
+	const getrusage			:  (who : int, rusage : rusage# -> int)
+	const mount			:  (kind : byte#, path : byte#, flags : int, data : void# -> int)
+	const unmount			:  (path : byte#, flags : int -> int)
+	const setuid			:  (uid : uid -> int)
+	const getuid			:  ( -> uid)
+	const geteuid			:  ( -> uid)
+	const ptrace			:  (req : int, pid : pid, addr : void#, data : int -> int)
+	const recvmsg			:  (s : int, msg : msghdr#, flags : int -> size)
+	const sendmsg			:  (s : int, msg : msghdr#, flags : int -> size)
+	const recvfrom			:  (s : int, buf : void#, len : size, flags : int, from : sockaddr#, fromlenaddr : int32# -> size)
+	const getpeername		:  (fdes : int, asa : sockaddr#, alen : int32# -> int)
+	const getsockname		:  (fdes : int, asa : sockaddr#, alen : int32# -> int)
+	const access			:  (path : byte#, amode : int -> int)
+	const chflags			:  (path : byte#, flags : uint -> int)
+	const fchflags			:  (fd : int, flags : uint -> int)
+	const sync			:  ( -> void)
+	const getppid			:  ( -> pid)
+	const fstatat			:  (fd : int, path : byte#, buf : statbuf#, flag : int -> int)
+	const getegid			:  ( -> gid)
+	const profil			:  (samples : void#, size : size, offset : uint64, scale : uint -> int)
+	const ktrace			:  (fname : byte#, ops : int, facs : int, pid : pid -> int)
+	const getgid			:  ( -> gid)
+	const setlogin			:  (namebuf : byte# -> int)
+	const acct			:  (path : byte# -> int)
+	const sigpending		:  ( -> int)
+	const reboot			:  (opt : int -> int)
+	const revoke			:  (path : byte# -> int)
+	const symlink			:  (path : byte#, link : byte# -> int)
+	const readlink			:  (path : byte#, buf : byte#, count : size -> size)
+	const umask			:  (newmask : filemode -> filemode)
+	const chroot			:  (path : byte# -> int)
+	const getfsstat			:  (buf : statfs#, bufsize : size, flags : int -> int)
+	const statfs			:  (path : byte#, buf : statfs# -> int)
+	const fstatfs			:  (fd : int, buf : statfs# -> int)
+	const fhstatfs			:  (fhp : fhandle#, buf : statfs# -> int)
+	const vfork			:  ( -> int)
+	const gettimeofday		:  (tp : timeval#, tzp : timezone# -> int)
+	const settimeofday		:  (tv : timeval#, tzp : timezone# -> int)
+	const setitimer			:  (which : int, itv : itimerval#, oitv : itimerval# -> int)
+	const getitimer			:  (which : int, itv : itimerval# -> int)
+	const select			:  (nd : int, _in : fdset#, ou : fdset#, ex : fdset#, tv : timeval# -> int)
+	const kevent			:  (fd : int, changelist : kevent#, nchanges : int, eventlist : kevent#, nevents : int, timeout : timespec# -> int)
+	const mprotect			:  (addr : void#, len : size, prot : int -> int)
+	const madvise			:  (addr : void#, len : size, behav : int -> int)
+	const utimes			:  (path : byte#, tptr : timeval# -> int)
+	const futimes			:  (fd : int, tptr : timeval# -> int)
+	const mincore			:  (addr : void#, len : size, vec : byte# -> int)
+	const getgroups			:  (gidsetsize : int, gidset : gid# -> int)
+	const setgroups			:  (gidsetsize : int, gidset : gid# -> int)
+	const getpgrp			:  ( -> int)
+	const setpgid			:  (pid : pid, pgid : pid -> int)
+	const futex			:  (f : uint32#, op : int, val : int, timeout : timespec#, g : uint32# -> int)
+	const utimensat			:  (fd : int, path : byte#, times : timespec#, flag : int -> int)
+	const futimens			:  (fd : int, times : timespec# -> int)
+	const kbind			:  (param : kbind#, psize : size, proc_cookie : int64 -> int)
+	const accept4			:  (s : int, name : sockaddr#, anamelen : int32#, flags : int -> int)
+	const __thrsleep		:  (ident : void#, clock_id : clockid, tp : timespec#, lock : void#, abort : int# -> int)
+	const fsync			:  (fd : int -> int)
+	const setpriority		:  (which : int, who : id, prio : int -> int)
+	const getpriority		:  (which : int, who : id -> int)
+	const pipe2			:  (fdp : int#, flags : int -> int)
+	const dup3			:  (from : int, to : int, flags : int -> int)
+	const sigreturn			:  (sigcntxp : sigcontext# -> int)
+	const chflagsat			:  (fd : int, path : byte#, flags : uint, atflags : int -> int)
+	const pledge			:  (request : byte#, paths : byte## -> int)
+	const ppoll			:  (fds : pollfd#, nfds : uint, ts : timespec#, mask : sigset# -> int)
+	const pselect			:  (nd : int, _in : fdset#, ou : fdset#, ex : fdset#, ts : timespec#, mask : sigset# -> int)
+	const sigsuspend		:  (mask : int -> int)
+	const sendsyslog		:  (buf : void#, nbyte : size, flags : int -> int)
+	const fktrace			:  (fd : int, ops : int, facs : int, pid : pid -> int)
+	const thrkill			:  (tid : pid, signum : int, tcb : void# -> int)
+	const fchown			:  (fd : int, uid : uid, gid : gid -> int)
+	const fchmod			:  (fd : int, mode : filemode -> int)
+	const setreuid			:  (ruid : uid, euid : uid -> int)
+	const setregid			:  (rgid : gid, egid : gid -> int)
+	const rename			:  (from : byte#, to : byte# -> int)
+	const flock			:  (fd : int, how : int -> int)
+	const mkfifo			:  (path : byte#, mode : filemode -> int)
+	const sendto			:  (s : int, buf : void#, len : size, flags : int, to : sockaddr#, tolen : int32 -> size)
+	const shutdown			:  (s : int, how : int -> int)
+	const socketpair		:  (domain : int, kind : int, protocol : int, rsv : int# -> int)
+	const rmdir			:  (path : byte# -> int)
+	const adjtime			:  (delta : timeval#, olddelta : timeval# -> int)
+	const getlogin_r		:  (namebuf : byte#, namelen : uint -> int)
+	const setsid			:  ( -> int)
+	const quotactl			:  (path : byte#, cmd : int, uid : int, arg : byte# -> int)
+	const nfssvc			:  (flag : int, argp : void# -> int)
+	const getfh			:  (fname : byte#, fhp : fhandle# -> int)
+	const sysarch			:  (op : int, parms : void# -> int)
+	const setgid			:  (gid : gid -> int)
+	const setegid			:  (egid : gid -> int)
+	const seteuid			:  (euid : uid -> int)
+	const pathconf			:  (path : byte#, name : int -> int64)
+	const fpathconf			:  (fd : int, name : int -> int64)
+	const swapctl			:  (cmd : int, arg : void#, misc : int -> int)
+	const getrlimit			:  (which : int, rlp : rlimit# -> int)
+	const setrlimit			:  (which : int, rlp : rlimit# -> int)
+	const truncate			:  (path : byte#, pad : int, length : off -> int)
+	const ftruncate			:  (fd : int, pad : int, length : off -> int)
+	const mlock			:  (addr : void#, len : size -> int)
+	const munlock			:  (addr : void#, len : size -> int)
+	const getpgid			:  (pid : pid -> pid)
+	const utrace			:  (label : byte#, addr : void#, len : size -> int)
+	const semget			:  (key : key, nsems : int, semflg : int -> int)
+	const msgget			:  (key : key, msgflg : int -> int)
+	const msgsnd			:  (msqid : int, msgp : void#, msgsz : size, msgflg : int -> int)
+	const msgrcv			:  (msqid : int, msgp : void#, msgsz : size, msgtyp : int64, msgflg : int -> int)
+	const shmat			:  (shmid : int, shmaddr : void#, shmflg : int -> void)
+	const shmdt			:  (shmaddr : void# -> int)
+	const minherit			:  (addr : void#, len : size, inherit : int -> int)
+	const issetugid			:  ( -> int)
+	const lchown			:  (path : byte#, uid : uid, gid : gid -> int)
+	const getsid			:  (pid : pid -> pid)
+	const msync			:  (addr : void#, len : size, flags : int -> int)
+	const fhopen			:  (fhp : fhandle#, flags : int -> int)
+	const preadv			:  (fd : int, iovp : iovec#, iovcnt : int, pad : int, offset : off -> size)
+	const pwritev			:  (fd : int, iovp : iovec#, iovcnt : int, pad : int, offset : off -> size)
+	const kqueue			:  ( -> int)
+	const mlockall			:  (flags : int -> int)
+	const munlockall		:  ( -> int)
+	const getresuid			:  (ruid : uid#, euid : uid#, suid : uid# -> int)
+	const setresuid			:  (ruid : uid, euid : uid, suid : uid -> int)
+	const getresgid			:  (rgid : gid#, egid : gid#, sgid : gid# -> int)
+	const setresgid			:  (rgid : gid, egid : gid, sgid : gid -> int)
+	const mquery			:  (addr : void#, len : size, prot : int, flags : int, fd : int, pad : int64, pos : off -> void)
+	const closefrom			:  (fd : int -> int)
+	const sigaltstack		:  (nss : sigaltstack#, oss : sigaltstack# -> int)
+	const shmget			:  (key : key, size : size, shmflg : int -> int)
+	const semop			:  (semid : int, sops : sembuf#, nsops : size -> int)
+	const fhstat			:  (fhp : fhandle#, sb : statbuf# -> int)
+	const __semctl			:  (semid : int, semnum : int, cmd : int, arg : semun# -> int)
+	const shmctl			:  (shmid : int, cmd : int, buf : shmid_ds# -> int)
+	const msgctl			:  (msqid : int, cmd : int, buf : msqid_ds# -> int)
+	const sched_yield		:  ( -> int)
+	const getthrid			:  ( -> pid)
+	const __thrwakeup		:  (ident : void#, n : int -> int)
+	const __threxit			:  (notdead : pid# -> void)
+	const __thrsigdivert		:  (sigmask : sigset, info : siginfo#, timeout : timespec# -> int)
+	const adjfreq			:  (freq : int64#, oldfreq : int64# -> int)
+	const setrtable			:  (rtableid : int -> int)
+	const getrtable			:  ( -> int)
+	const faccessat			:  (fd : int, path : byte#, amode : int, flag : int -> int)
+	const fchmodat			:  (fd : int, path : byte#, mode : filemode, flag : int -> int)
+	const fchownat			:  (fd : int, path : byte#, uid : uid, gid : gid, flag : int -> int)
+	const linkat			:  (fd1 : int, path1 : byte#, fd2 : int, path2 : byte#, flag : int -> int)
+	const mkdirat			:  (fd : int, path : byte#, mode : filemode -> int)
+	const mkfifoat			:  (fd : int, path : byte#, mode : filemode -> int)
+	const mknodat			:  (fd : int, path : byte#, mode : filemode, dev : dev -> int)
+	const openat			:  (fd : int, path : byte#, flags : int, mode : filemode -> int)
+	const readlinkat		:  (fd : int, path : byte#, buf : byte#, count : size -> size)
+	const renameat			:  (fromfd : int, from : byte#, tofd : int, to : byte# -> int)
+	const symlinkat			:  (path : byte#, fd : int, link : byte# -> int)
+	const unlinkat			:  (fd : int, path : byte#, flag : int -> int)
+	const __set_tcb			:  (tcb : void# -> void)
+	const __get_tcb			:  ( -> void)
+;;
+
+	/* start manual overrides { */
+	/* process control */
+	/* wrappers to extract wait status */
+	
+	/* fd manipulation */
+	
+	/* signals */
+	
+	/* fd stuff */
+	/* NB: the C ABI uses '...' for the args. */
+	
+	/* networking */
+	
+	/* memory mapping */
+	
+	/* time - doublecheck if this is right */
+	
+	/* system information */
+	
+	/* 
+	wraps a syscall argument, converting it to 64 bits for the syscall function. This is
+	the same as casting, but more concise than writing a cast to uint64
+	*/
+	generic a = {x : @t; -> (x : uint64)}
+	
+	
+	
+	/* process management */
+	const exit	= {status;		syscall(Sysexit, a(status))}
+	const getpid	= {;			-> (syscall(Sysgetpid, 1) : pid)}
+	const kill	= {pid, sig;		-> syscall(Syskill, pid, sig)}
+	const fork	= {;			-> (syscall(Sysfork) : pid)}
+	const wait4	= {pid, loc, opt, usage;	-> syscall(Syswait4, pid, loc, opt, usage)}
+	const waitpid	= {pid, loc, opt;
+		-> wait4(pid, loc, opt, (0 : rusage#)) 
+	}
+	
+	const execv	= {cmd, args
+		var p, cargs, i
+	
+		/* of course we fucking have to duplicate this code everywhere,
+		* since we want to stack allocate... */
+		p = alloca((args.len + 1)*sizeof(byte#))
+		cargs = (p : byte##)[:args.len + 1]
+		for i = 0; i < args.len; i++
+			cargs[i] = cstring(args[i])
+		;;
+		cargs[args.len] = (0 : byte#)
+		-> syscall(Sysexecve, cstring(cmd), a(p), a(__cenvp))
+	}
+	
+	const execve	= {cmd, args, env
+		var cargs, cenv, i
+		var p
+	
+		/* copy the args */
+		p = alloca((args.len + 1)*sizeof(byte#))
+		cargs = (p : byte##)[:args.len]
+		for i = 0; i < args.len; i++
+			cargs[i] = cstring(args[i])
+		;;
+		cargs[args.len] = (0 : byte#)
+	
+		/*
+		 copy the env.
+		 of course we fucking have to duplicate this code everywhere,
+		 since we want to stack allocate... 
+		*/
+		p = alloca((env.len + 1)*sizeof(byte#))
+		cenv = (p : byte##)[:env.len]
+		for i = 0; i < env.len; i++
+			cenv[i] = cstring(env[i])
+		;;
+		cenv[env.len] = (0 : byte#)
+	
+		-> syscall(Sysexecve, cstring(cmd), a(p), a(cenv))
+	}
+	
+	/* fd manipulation */
+	const open	= {path, opts;		-> (syscall(Sysopen, cstring(path), a(opts), a(0o777)) : fd)}
+	const openmode	= {path, opts, mode;	-> (syscall(Sysopen, cstring(path), a(opts), a(mode)) : fd)}
+	const close	= {fd;			-> syscall(Sysclose, a(fd))}
+	const creat	= {path, mode;		-> (openmode(path, Ocreat | Otrunc | Owronly, mode) : fd)}
+	const unlink	= {path;		-> (syscall(Sysunlink, cstring(path)) : int)}
+	const read	= {fd, buf;		-> (syscall(Sysread, a(fd), (buf : byte#), a(buf.len)) : size)}
+	const pread	= {fd, buf, off;	-> (syscall(Syspread, a(fd), (buf : byte#), a(buf.len), a(off)) : size)}
+	const readv	= {fd, vec;		-> (syscall(Sysreadv, a(fd), (vec : iovec#), a(vec.len)) : size)}
+	const write	= {fd, buf;		-> (syscall(Syswrite, a(fd), (buf : byte#), a(buf.len)) : size)}
+	const pwrite	= {fd, buf, off;	-> (syscall(Syspwrite, a(fd), (buf : byte#), a(buf.len), a(off)) : size)}
+	const writev	= {fd, vec;		-> (syscall(Syswritev, a(fd), (vec : iovec#), a(vec.len)) : size)}
+	const lseek	= {fd, off, whence;	-> syscall(Syslseek, a(fd), a(off), a(whence))}
+	const stat	= {path, sb;		-> syscall(Sysstat, cstring(path), a(sb))}
+	const lstat	= {path, sb;		-> syscall(Syslstat, cstring(path), a(sb))}
+	const fstat	= {fd, sb;		-> syscall(Sysfstat, a(fd), a(sb))}
+	const mkdir	= {path, mode;		-> (syscall(Sysmkdir, cstring(path), a(mode)) : int64)}
+	generic ioctl	= {fd, req, arg;	-> (syscall(Sysioctl, a(fd), a(req), a(arg)) : int64)}
+	const chdir	= {dir;	-> syscall(Syschdir, cstring(dir))}
+	const __getcwd	= {buf;	-> syscall(Sys__getcwd, a(buf), a(buf.len))}
+	const getdents	= {fd, buf;		-> (syscall(Sysgetdents, a(buf), a(buf.len)) : int64)}
+	
+	/* signals */
+	const sigaction	= {sig, act, oact;	-> (syscall(Syssigaction, a(sig), a(act), a(oact)) : int)}
+	const sigprocmask	= {sig, act, oact;	-> (syscall(Syssigprocmask, a(sig), a(act), a(oact)) : int)}
+	
+	/* file stuff */
+	const pipe	= {fds;	-> syscall(Syspipe, fds)}
+	const dup 	= {fd;	-> (syscall(Sysdup, a(fd)) : fd)}
+	const dup2 	= {src, dst;	-> (syscall(Sysdup2, a(src), a(dst)) : fd)}
+	const fcntl	= {fd, cmd, args; 	-> syscall(Sysfcntl, a(fd), a(cmd), a(args))}
+	const poll      = {pfd, tm;     -> (syscall(Syspoll, (pfd : byte#), a(pfd.len), a(tm)) : int)}
+	
+	/* networking */
+	const socket	= {dom, stype, proto;	-> (syscall(Syssocket, a(dom), a(stype), a(proto)) : fd)}
+	const connect	= {sock, addr, len;	-> (syscall(Sysconnect, a(sock), a(addr), a(len)) : int)}
+	const accept	= {sock, addr, len;	-> (syscall(Sysaccept, a(sock), a(addr), a(len)) : fd)}
+	const listen	= {sock, backlog;	-> (syscall(Syslisten, a(sock), a(backlog)) : int)}
+	const bind	= {sock, addr, len;	-> (syscall(Sysbind, a(sock), a(addr), a(len)) : int)}
+	const setsockopt	= {sock, lev, opt, val, len;	-> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)}
+	const getsockopt	= {sock, lev, opt, val, len;	-> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)}
+	
+	/* memory management */
+	const munmap	= {addr, len;		-> syscall(Sysmunmap, a(addr), a(len))}
+	const mmap	= {addr, len, prot, flags, fd, off;
+		/* the actual syscall has padding on the offset arg */
+		-> (syscall(Sysmmap, a(addr), a(len), a(prot), a(flags), a(fd), a(0), a(off)) : byte#)
+	}
+	
+	/* time */
+	const clock_getres = {clk, ts;	-> (syscall(Sysclock_getres, clockid(clk), a(ts)) : int32)}
+	const clock_gettime = {clk, ts;	-> (syscall(Sysclock_gettime, clockid(clk), a(ts)) : int32)}
+	const clock_settime = {clk, ts;	-> (syscall(Sysclock_settime, clockid(clk), a(ts)) : int32)}
+	
+	const sleep = {time
+		var req, rem
+		req = [.sec = time, .nsec = 0]
+		-> nanosleep(&req, &rem)
+	}
+	
+	const nanosleep	= {req, rem;	-> (syscall(Sysnanosleep, a(req), a(rem)) : int32)}
+	
+	
+	/* system information */
+	const uname	= {buf
+		var mib : int[2]
+		var ret
+		var sys, syssz
+		var nod, nodsz
+		var rel, relsz
+		var ver, versz
+		var mach, machsz
+	
+		ret = 0
+		mib[0] = 1 /* CTL_KERN */
+		mib[1] = 1 /* KERN_OSTYPE */
+		sys = (buf.system[:] : void#)
+		syssz = buf.system.len
+		ret = sysctl(mib[:], sys, &syssz, (0 : void#), (0 : size#))
+		if ret < 0
+			-> ret
+		;;
+	
+		mib[0] = 1 /* CTL_KERN */
+		mib[1] = 10 /* KERN_HOSTNAME */
+		nod = (buf.node[:] : void#)
+		nodsz = buf.node.len
+		ret = sysctl(mib[:], nod, &nodsz, (0 : void#), (0 : size#))
+		if ret < 0
+			-> ret
+		;;
+	
+		mib[0] = 1 /* CTL_KERN */
+		mib[1] = 2 /* KERN_OSRELEASE */
+		rel = (buf.release[:] : void#)
+		relsz = buf.release.len
+		ret = sysctl(mib[:], rel, &relsz, (0 : void#), (0 : size#))
+		if ret < 0
+			-> ret
+		;;
+	
+		mib[0] = 1 /* CTL_KERN */
+		mib[1] = 27 /* KERN_OSVERSION */
+		ver = (buf.version[:] : void#)
+		versz = buf.version.len
+		ret = sysctl(mib[:], ver, &versz, (0 : void#), (0 : size#))
+		if ret < 0
+			-> ret
+		;;
+	
+		mib[0] = 6 /* CTL_HW */
+		mib[1] = 1 /* HW_MACHINE */
+		mach = (buf.machine[:] : void#)
+		machsz = buf.machine.len
+		ret = sysctl(mib[:], mach, &machsz, (0 : void#), (0 : size#))
+		if ret < 0
+			-> ret
+		;;
+	
+		-> 0
+	}
+	
+	const sysctl = {mib, old, oldsz, new, newsz
+		/* all args already passed through a() or ar  ptrs */
+		-> (syscall(Syssysctl, \
+		(mib : int#), a(mib.len), old, oldsz, new, newsz) : int)
+	}
+	
+	const clockid = {clk
+		match clk
+		| `Clockrealtime:	-> 0
+		| `Clockproccputime:	-> 2
+		| `Clockmonotonic:	-> 3
+		| `Clockthreadcputime:	-> 4
+		| `Clockuptime:	-> 5
+		;;
+		-> -1
+	}
+	
+	const waitstatus = {st
+		if st < 0
+			-> `Waitfail st
+		;;
+		match st & 0o177
+		| 0:    -> `Waitexit (st >> 8)
+		| 0x7f:-> `Waitstop (st >> 8)
+		| sig:  -> `Waitsig sig
+		;;
+	}
+	
+	/* } end manual overrides */
+const getentropy	= {buf, nbyte
+	 -> (syscall(Sysgetentropy, a(buf), a(nbyte)) : int)
+}
+const __tfork	= {param, psize
+	 -> (syscall(Sys__tfork, a(param), a(psize)) : int)
+}
+const link	= {path, link
+	 -> (syscall(Syslink, a(path), a(link)) : int)
+}
+const fchdir	= {fd
+	 -> (syscall(Sysfchdir, a(fd)) : int)
+}
+const mknod	= {path, mode, dev
+	 -> (syscall(Sysmknod, a(path), a(mode), a(dev)) : int)
+}
+const chmod	= {path, mode
+	 -> (syscall(Syschmod, a(path), a(mode)) : int)
+}
+const chown	= {path, uid, gid
+	 -> (syscall(Syschown, a(path), a(uid), a(gid)) : int)
+}
+const obreak	= {nsize
+	 -> (syscall(Sysobreak, a(nsize)) : int)
+}
+const getdtablecount	= {
+	 -> (syscall(Sysgetdtablecount) : int)
+}
+const getrusage	= {who, rusage
+	 -> (syscall(Sysgetrusage, a(who), a(rusage)) : int)
+}
+const mount	= {kind, path, flags, data
+	 -> (syscall(Sysmount, a(kind), a(path), a(flags), a(data)) : int)
+}
+const unmount	= {path, flags
+	 -> (syscall(Sysunmount, a(path), a(flags)) : int)
+}
+const setuid	= {uid
+	 -> (syscall(Syssetuid, a(uid)) : int)
+}
+const getuid	= {
+	 -> (syscall(Sysgetuid) : uid)
+}
+const geteuid	= {
+	 -> (syscall(Sysgeteuid) : uid)
+}
+const ptrace	= {req, pid, addr, data
+	 -> (syscall(Sysptrace, a(req), a(pid), a(addr), a(data)) : int)
+}
+const recvmsg	= {s, msg, flags
+	 -> (syscall(Sysrecvmsg, a(s), a(msg), a(flags)) : size)
+}
+const sendmsg	= {s, msg, flags
+	 -> (syscall(Syssendmsg, a(s), a(msg), a(flags)) : size)
+}
+const recvfrom	= {s, buf, len, flags, from, fromlenaddr
+	 -> (syscall(Sysrecvfrom, a(s), a(buf), a(len), a(flags), a(from), a(fromlenaddr)) : size)
+}
+const getpeername	= {fdes, asa, alen
+	 -> (syscall(Sysgetpeername, a(fdes), a(asa), a(alen)) : int)
+}
+const getsockname	= {fdes, asa, alen
+	 -> (syscall(Sysgetsockname, a(fdes), a(asa), a(alen)) : int)
+}
+const access	= {path, amode
+	 -> (syscall(Sysaccess, a(path), a(amode)) : int)
+}
+const chflags	= {path, flags
+	 -> (syscall(Syschflags, a(path), a(flags)) : int)
+}
+const fchflags	= {fd, flags
+	 -> (syscall(Sysfchflags, a(fd), a(flags)) : int)
+}
+const sync	= {
+	 -> (syscall(Syssync) : void)
+}
+const getppid	= {
+	 -> (syscall(Sysgetppid) : pid)
+}
+const fstatat	= {fd, path, buf, flag
+	 -> (syscall(Sysfstatat, a(fd), a(path), a(buf), a(flag)) : int)
+}
+const getegid	= {
+	 -> (syscall(Sysgetegid) : gid)
+}
+const profil	= {samples, size, offset, scale
+	 -> (syscall(Sysprofil, a(samples), a(size), a(offset), a(scale)) : int)
+}
+const ktrace	= {fname, ops, facs, pid
+	 -> (syscall(Sysktrace, a(fname), a(ops), a(facs), a(pid)) : int)
+}
+const getgid	= {
+	 -> (syscall(Sysgetgid) : gid)
+}
+const setlogin	= {namebuf
+	 -> (syscall(Syssetlogin, a(namebuf)) : int)
+}
+const acct	= {path
+	 -> (syscall(Sysacct, a(path)) : int)
+}
+const sigpending	= {
+	 -> (syscall(Syssigpending) : int)
+}
+const reboot	= {opt
+	 -> (syscall(Sysreboot, a(opt)) : int)
+}
+const revoke	= {path
+	 -> (syscall(Sysrevoke, a(path)) : int)
+}
+const symlink	= {path, link
+	 -> (syscall(Syssymlink, a(path), a(link)) : int)
+}
+const readlink	= {path, buf, count
+	 -> (syscall(Sysreadlink, a(path), a(buf), a(count)) : size)
+}
+const umask	= {newmask
+	 -> (syscall(Sysumask, a(newmask)) : filemode)
+}
+const chroot	= {path
+	 -> (syscall(Syschroot, a(path)) : int)
+}
+const getfsstat	= {buf, bufsize, flags
+	 -> (syscall(Sysgetfsstat, a(buf), a(bufsize), a(flags)) : int)
+}
+const statfs	= {path, buf
+	 -> (syscall(Sysstatfs, a(path), a(buf)) : int)
+}
+const fstatfs	= {fd, buf
+	 -> (syscall(Sysfstatfs, a(fd), a(buf)) : int)
+}
+const fhstatfs	= {fhp, buf
+	 -> (syscall(Sysfhstatfs, a(fhp), a(buf)) : int)
+}
+const vfork	= {
+	 -> (syscall(Sysvfork) : int)
+}
+const gettimeofday	= {tp, tzp
+	 -> (syscall(Sysgettimeofday, a(tp), a(tzp)) : int)
+}
+const settimeofday	= {tv, tzp
+	 -> (syscall(Syssettimeofday, a(tv), a(tzp)) : int)
+}
+const setitimer	= {which, itv, oitv
+	 -> (syscall(Syssetitimer, a(which), a(itv), a(oitv)) : int)
+}
+const getitimer	= {which, itv
+	 -> (syscall(Sysgetitimer, a(which), a(itv)) : int)
+}
+const select	= {nd, _in, ou, ex, tv
+	 -> (syscall(Sysselect, a(nd), a(_in), a(ou), a(ex), a(tv)) : int)
+}
+const kevent	= {fd, changelist, nchanges, eventlist, nevents, timeout
+	 -> (syscall(Syskevent, a(fd), a(changelist), a(nchanges), a(eventlist), a(nevents), a(timeout)) : int)
+}
+const mprotect	= {addr, len, prot
+	 -> (syscall(Sysmprotect, a(addr), a(len), a(prot)) : int)
+}
+const madvise	= {addr, len, behav
+	 -> (syscall(Sysmadvise, a(addr), a(len), a(behav)) : int)
+}
+const utimes	= {path, tptr
+	 -> (syscall(Sysutimes, a(path), a(tptr)) : int)
+}
+const futimes	= {fd, tptr
+	 -> (syscall(Sysfutimes, a(fd), a(tptr)) : int)
+}
+const mincore	= {addr, len, vec
+	 -> (syscall(Sysmincore, a(addr), a(len), a(vec)) : int)
+}
+const getgroups	= {gidsetsize, gidset
+	 -> (syscall(Sysgetgroups, a(gidsetsize), a(gidset)) : int)
+}
+const setgroups	= {gidsetsize, gidset
+	 -> (syscall(Syssetgroups, a(gidsetsize), a(gidset)) : int)
+}
+const getpgrp	= {
+	 -> (syscall(Sysgetpgrp) : int)
+}
+const setpgid	= {pid, pgid
+	 -> (syscall(Syssetpgid, a(pid), a(pgid)) : int)
+}
+const futex	= {f, op, val, timeout, g
+	 -> (syscall(Sysfutex, a(f), a(op), a(val), a(timeout), a(g)) : int)
+}
+const utimensat	= {fd, path, times, flag
+	 -> (syscall(Sysutimensat, a(fd), a(path), a(times), a(flag)) : int)
+}
+const futimens	= {fd, times
+	 -> (syscall(Sysfutimens, a(fd), a(times)) : int)
+}
+const kbind	= {param, psize, proc_cookie
+	 -> (syscall(Syskbind, a(param), a(psize), a(proc_cookie)) : int)
+}
+const accept4	= {s, name, anamelen, flags
+	 -> (syscall(Sysaccept4, a(s), a(name), a(anamelen), a(flags)) : int)
+}
+const __thrsleep	= {ident, clock_id, tp, lock, abort
+	 -> (syscall(Sys__thrsleep, a(ident), a(clock_id), a(tp), a(lock), a(abort)) : int)
+}
+const fsync	= {fd
+	 -> (syscall(Sysfsync, a(fd)) : int)
+}
+const setpriority	= {which, who, prio
+	 -> (syscall(Syssetpriority, a(which), a(who), a(prio)) : int)
+}
+const getpriority	= {which, who
+	 -> (syscall(Sysgetpriority, a(which), a(who)) : int)
+}
+const pipe2	= {fdp, flags
+	 -> (syscall(Syspipe2, a(fdp), a(flags)) : int)
+}
+const dup3	= {from, to, flags
+	 -> (syscall(Sysdup3, a(from), a(to), a(flags)) : int)
+}
+const sigreturn	= {sigcntxp
+	 -> (syscall(Syssigreturn, a(sigcntxp)) : int)
+}
+const chflagsat	= {fd, path, flags, atflags
+	 -> (syscall(Syschflagsat, a(fd), a(path), a(flags), a(atflags)) : int)
+}
+const pledge	= {request, paths
+	 -> (syscall(Syspledge, a(request), a(paths)) : int)
+}
+const ppoll	= {fds, nfds, ts, mask
+	 -> (syscall(Sysppoll, a(fds), a(nfds), a(ts), a(mask)) : int)
+}
+const pselect	= {nd, _in, ou, ex, ts, mask
+	 -> (syscall(Syspselect, a(nd), a(_in), a(ou), a(ex), a(ts), a(mask)) : int)
+}
+const sigsuspend	= {mask
+	 -> (syscall(Syssigsuspend, a(mask)) : int)
+}
+const sendsyslog	= {buf, nbyte, flags
+	 -> (syscall(Syssendsyslog, a(buf), a(nbyte), a(flags)) : int)
+}
+const fktrace	= {fd, ops, facs, pid
+	 -> (syscall(Sysfktrace, a(fd), a(ops), a(facs), a(pid)) : int)
+}
+const thrkill	= {tid, signum, tcb
+	 -> (syscall(Systhrkill, a(tid), a(signum), a(tcb)) : int)
+}
+const fchown	= {fd, uid, gid
+	 -> (syscall(Sysfchown, a(fd), a(uid), a(gid)) : int)
+}
+const fchmod	= {fd, mode
+	 -> (syscall(Sysfchmod, a(fd), a(mode)) : int)
+}
+const setreuid	= {ruid, euid
+	 -> (syscall(Syssetreuid, a(ruid), a(euid)) : int)
+}
+const setregid	= {rgid, egid
+	 -> (syscall(Syssetregid, a(rgid), a(egid)) : int)
+}
+const rename	= {from, to
+	 -> (syscall(Sysrename, a(from), a(to)) : int)
+}
+const flock	= {fd, how
+	 -> (syscall(Sysflock, a(fd), a(how)) : int)
+}
+const mkfifo	= {path, mode
+	 -> (syscall(Sysmkfifo, a(path), a(mode)) : int)
+}
+const sendto	= {s, buf, len, flags, to, tolen
+	 -> (syscall(Syssendto, a(s), a(buf), a(len), a(flags), a(to), a(tolen)) : size)
+}
+const shutdown	= {s, how
+	 -> (syscall(Sysshutdown, a(s), a(how)) : int)
+}
+const socketpair	= {domain, kind, protocol, rsv
+	 -> (syscall(Syssocketpair, a(domain), a(kind), a(protocol), a(rsv)) : int)
+}
+const rmdir	= {path
+	 -> (syscall(Sysrmdir, a(path)) : int)
+}
+const adjtime	= {delta, olddelta
+	 -> (syscall(Sysadjtime, a(delta), a(olddelta)) : int)
+}
+const getlogin_r	= {namebuf, namelen
+	 -> (syscall(Sysgetlogin_r, a(namebuf), a(namelen)) : int)
+}
+const setsid	= {
+	 -> (syscall(Syssetsid) : int)
+}
+const quotactl	= {path, cmd, uid, arg
+	 -> (syscall(Sysquotactl, a(path), a(cmd), a(uid), a(arg)) : int)
+}
+const nfssvc	= {flag, argp
+	 -> (syscall(Sysnfssvc, a(flag), a(argp)) : int)
+}
+const getfh	= {fname, fhp
+	 -> (syscall(Sysgetfh, a(fname), a(fhp)) : int)
+}
+const sysarch	= {op, parms
+	 -> (syscall(Syssysarch, a(op), a(parms)) : int)
+}
+const setgid	= {gid
+	 -> (syscall(Syssetgid, a(gid)) : int)
+}
+const setegid	= {egid
+	 -> (syscall(Syssetegid, a(egid)) : int)
+}
+const seteuid	= {euid
+	 -> (syscall(Sysseteuid, a(euid)) : int)
+}
+const pathconf	= {path, name
+	 -> (syscall(Syspathconf, a(path), a(name)) : int64)
+}
+const fpathconf	= {fd, name
+	 -> (syscall(Sysfpathconf, a(fd), a(name)) : int64)
+}
+const swapctl	= {cmd, arg, misc
+	 -> (syscall(Sysswapctl, a(cmd), a(arg), a(misc)) : int)
+}
+const getrlimit	= {which, rlp
+	 -> (syscall(Sysgetrlimit, a(which), a(rlp)) : int)
+}
+const setrlimit	= {which, rlp
+	 -> (syscall(Syssetrlimit, a(which), a(rlp)) : int)
+}
+const truncate	= {path, pad, length
+	 -> (syscall(Systruncate, a(path), a(pad), a(length)) : int)
+}
+const ftruncate	= {fd, pad, length
+	 -> (syscall(Sysftruncate, a(fd), a(pad), a(length)) : int)
+}
+const mlock	= {addr, len
+	 -> (syscall(Sysmlock, a(addr), a(len)) : int)
+}
+const munlock	= {addr, len
+	 -> (syscall(Sysmunlock, a(addr), a(len)) : int)
+}
+const getpgid	= {pid
+	 -> (syscall(Sysgetpgid, a(pid)) : pid)
+}
+const utrace	= {label, addr, len
+	 -> (syscall(Sysutrace, a(label), a(addr), a(len)) : int)
+}
+const semget	= {key, nsems, semflg
+	 -> (syscall(Syssemget, a(key), a(nsems), a(semflg)) : int)
+}
+const msgget	= {key, msgflg
+	 -> (syscall(Sysmsgget, a(key), a(msgflg)) : int)
+}
+const msgsnd	= {msqid, msgp, msgsz, msgflg
+	 -> (syscall(Sysmsgsnd, a(msqid), a(msgp), a(msgsz), a(msgflg)) : int)
+}
+const msgrcv	= {msqid, msgp, msgsz, msgtyp, msgflg
+	 -> (syscall(Sysmsgrcv, a(msqid), a(msgp), a(msgsz), a(msgtyp), a(msgflg)) : int)
+}
+const shmat	= {shmid, shmaddr, shmflg
+	 -> (syscall(Sysshmat, a(shmid), a(shmaddr), a(shmflg)) : void)
+}
+const shmdt	= {shmaddr
+	 -> (syscall(Sysshmdt, a(shmaddr)) : int)
+}
+const minherit	= {addr, len, inherit
+	 -> (syscall(Sysminherit, a(addr), a(len), a(inherit)) : int)
+}
+const issetugid	= {
+	 -> (syscall(Sysissetugid) : int)
+}
+const lchown	= {path, uid, gid
+	 -> (syscall(Syslchown, a(path), a(uid), a(gid)) : int)
+}
+const getsid	= {pid
+	 -> (syscall(Sysgetsid, a(pid)) : pid)
+}
+const msync	= {addr, len, flags
+	 -> (syscall(Sysmsync, a(addr), a(len), a(flags)) : int)
+}
+const fhopen	= {fhp, flags
+	 -> (syscall(Sysfhopen, a(fhp), a(flags)) : int)
+}
+const preadv	= {fd, iovp, iovcnt, pad, offset
+	 -> (syscall(Syspreadv, a(fd), a(iovp), a(iovcnt), a(pad), a(offset)) : size)
+}
+const pwritev	= {fd, iovp, iovcnt, pad, offset
+	 -> (syscall(Syspwritev, a(fd), a(iovp), a(iovcnt), a(pad), a(offset)) : size)
+}
+const kqueue	= {
+	 -> (syscall(Syskqueue) : int)
+}
+const mlockall	= {flags
+	 -> (syscall(Sysmlockall, a(flags)) : int)
+}
+const munlockall	= {
+	 -> (syscall(Sysmunlockall) : int)
+}
+const getresuid	= {ruid, euid, suid
+	 -> (syscall(Sysgetresuid, a(ruid), a(euid), a(suid)) : int)
+}
+const setresuid	= {ruid, euid, suid
+	 -> (syscall(Syssetresuid, a(ruid), a(euid), a(suid)) : int)
+}
+const getresgid	= {rgid, egid, sgid
+	 -> (syscall(Sysgetresgid, a(rgid), a(egid), a(sgid)) : int)
+}
+const setresgid	= {rgid, egid, sgid
+	 -> (syscall(Syssetresgid, a(rgid), a(egid), a(sgid)) : int)
+}
+const mquery	= {addr, len, prot, flags, fd, pad, pos
+	 -> (syscall(Sysmquery, a(addr), a(len), a(prot), a(flags), a(fd), a(pad), a(pos)) : void)
+}
+const closefrom	= {fd
+	 -> (syscall(Sysclosefrom, a(fd)) : int)
+}
+const sigaltstack	= {nss, oss
+	 -> (syscall(Syssigaltstack, a(nss), a(oss)) : int)
+}
+const shmget	= {key, size, shmflg
+	 -> (syscall(Sysshmget, a(key), a(size), a(shmflg)) : int)
+}
+const semop	= {semid, sops, nsops
+	 -> (syscall(Syssemop, a(semid), a(sops), a(nsops)) : int)
+}
+const fhstat	= {fhp, sb
+	 -> (syscall(Sysfhstat, a(fhp), a(sb)) : int)
+}
+const __semctl	= {semid, semnum, cmd, arg
+	 -> (syscall(Sys__semctl, a(semid), a(semnum), a(cmd), a(arg)) : int)
+}
+const shmctl	= {shmid, cmd, buf
+	 -> (syscall(Sysshmctl, a(shmid), a(cmd), a(buf)) : int)
+}
+const msgctl	= {msqid, cmd, buf
+	 -> (syscall(Sysmsgctl, a(msqid), a(cmd), a(buf)) : int)
+}
+const sched_yield	= {
+	 -> (syscall(Syssched_yield) : int)
+}
+const getthrid	= {
+	 -> (syscall(Sysgetthrid) : pid)
+}
+const __thrwakeup	= {ident, n
+	 -> (syscall(Sys__thrwakeup, a(ident), a(n)) : int)
+}
+const __threxit	= {notdead
+	 -> (syscall(Sys__threxit, a(notdead)) : void)
+}
+const __thrsigdivert	= {sigmask, info, timeout
+	 -> (syscall(Sys__thrsigdivert, a(sigmask), a(info), a(timeout)) : int)
+}
+const adjfreq	= {freq, oldfreq
+	 -> (syscall(Sysadjfreq, a(freq), a(oldfreq)) : int)
+}
+const setrtable	= {rtableid
+	 -> (syscall(Syssetrtable, a(rtableid)) : int)
+}
+const getrtable	= {
+	 -> (syscall(Sysgetrtable) : int)
+}
+const faccessat	= {fd, path, amode, flag
+	 -> (syscall(Sysfaccessat, a(fd), a(path), a(amode), a(flag)) : int)
+}
+const fchmodat	= {fd, path, mode, flag
+	 -> (syscall(Sysfchmodat, a(fd), a(path), a(mode), a(flag)) : int)
+}
+const fchownat	= {fd, path, uid, gid, flag
+	 -> (syscall(Sysfchownat, a(fd), a(path), a(uid), a(gid), a(flag)) : int)
+}
+const linkat	= {fd1, path1, fd2, path2, flag
+	 -> (syscall(Syslinkat, a(fd1), a(path1), a(fd2), a(path2), a(flag)) : int)
+}
+const mkdirat	= {fd, path, mode
+	 -> (syscall(Sysmkdirat, a(fd), a(path), a(mode)) : int)
+}
+const mkfifoat	= {fd, path, mode
+	 -> (syscall(Sysmkfifoat, a(fd), a(path), a(mode)) : int)
+}
+const mknodat	= {fd, path, mode, dev
+	 -> (syscall(Sysmknodat, a(fd), a(path), a(mode), a(dev)) : int)
+}
+const openat	= {fd, path, flags, mode
+	 -> (syscall(Sysopenat, a(fd), a(path), a(flags), a(mode)) : int)
+}
+const readlinkat	= {fd, path, buf, count
+	 -> (syscall(Sysreadlinkat, a(fd), a(path), a(buf), a(count)) : size)
+}
+const renameat	= {fromfd, from, tofd, to
+	 -> (syscall(Sysrenameat, a(fromfd), a(from), a(tofd), a(to)) : int)
+}
+const symlinkat	= {path, fd, link
+	 -> (syscall(Syssymlinkat, a(path), a(fd), a(link)) : int)
+}
+const unlinkat	= {fd, path, flag
+	 -> (syscall(Sysunlinkat, a(fd), a(path), a(flag)) : int)
+}
+const __set_tcb	= {tcb
+	 -> (syscall(Sys__set_tcb, a(tcb)) : void)
+}
+const __get_tcb	= {
+	 -> (syscall(Sys__get_tcb) : void)
+}
--- /dev/null
+++ b/support/syscall-gen/gentypes+openbsd:6.2-x64.frag
@@ -1,0 +1,120 @@
+type dev = int32
+type uid = uint32
+type gid = uint32
+type fd_mask = uint32
+type uintptr = uint64
+type clockid = int32
+type id = uint32
+type key = int64
+type shmatt = int16
+
+type tfork = struct
+	tcb	: void#
+	tid	: pid#
+	stack	: void#
+
+;;
+
+type msghdr = struct
+	name	: void#
+	namelen	: int32
+	iov	: iovec#
+	iovlen	: uint
+	control	: void#
+	controllen	: int32
+	flags	: int
+
+;;
+
+type fsid = struct
+	val	: int32[2]
+
+;;
+
+type fid = struct
+	len	: uint16
+	reserved	: uint16
+	data	: byte[16]
+
+;;
+
+type fhandle = struct
+	fsid	: fsid
+	fid	: fid
+
+;;
+
+type fdset = struct
+	bits	: fd_mask[32]
+
+;;
+
+type kevent = struct
+	ident	: uintptr
+	filter	: int16
+	flags	: uint16
+	fflags	: uint
+	data	: int64
+	udata	: void#
+
+;;
+
+type kbind = struct
+	addr	: void#
+	size	: size
+
+;;
+
+type sembuf = struct
+	num	: uint16
+	op	: int16
+	flg	: int16
+
+;;
+
+type ipc_perm = struct
+	cuid	: uid
+	cgid	: gid
+	uid	: uid
+	gid	: gid
+	mode	: filemode
+	seq	: uint16
+	key	: key
+
+;;
+
+type shmid_ds = struct
+	perm	: ipc_perm
+	segsz	: int
+	lpid	: pid
+	cpid	: pid
+	nattch	: shmatt
+	atime	: time
+	atimensec	: int64
+	dtime	: time
+	dtimensec	: int64
+	ctime	: time
+	ctimensec	: int64
+	internal	: void#
+
+;;
+
+type msqid_ds = struct
+	perm	: ipc_perm
+	first	: msg#
+	last	: msg#
+	cbytes	: uint64
+	qnum	: uint64
+	qbytes	: uint64
+	lspid	: pid
+	lrpid	: pid
+	stime	: time
+	pad1	: int64
+	rtime	: time
+	pad2	: int64
+	ctime	: time
+	pad3	: int64
+	pad4	: int64[4]
+
+;;
+
--- /dev/null
+++ b/support/syscall-gen/specials+openbsd:6.2-x64.frag
@@ -1,0 +1,286 @@
+/* process control */
+const exit	: (status:int -> void)
+const getpid	: ( -> pid)
+const kill	: (pid:pid, sig:int64 -> int64)
+const fork	: (-> pid)
+const wait4	: (pid:pid, loc:int32#, opt : int64, usage:rusage#	-> int64)
+const waitpid	: (pid:pid, loc:int32#, opt : int64	-> int64)
+const execv	: (cmd : byte[:], args : byte[:][:] -> int64)
+const execve	: (cmd : byte[:], args : byte[:][:], env : byte[:][:] -> int64)
+/* wrappers to extract wait status */
+const waitstatus	: (st : int32 -> waitstatus)
+extern const __tfork_thread	: (tfp : tforkparams#, sz : size, fn : void#, arg : void# -> pid)
+
+/* fd manipulation */
+const open	: (path:byte[:], opts:fdopt -> fd)
+const openmode	: (path:byte[:], opts:fdopt, mode:int64 -> fd)
+const close	: (fd:fd -> int64)
+const creat	: (path:byte[:], mode:int64 -> fd)
+const unlink	: (path:byte[:] -> int)
+const read	: (fd:fd, buf:byte[:] -> size)
+const pread	: (fd:fd, buf:byte[:], off : off -> size)
+const readv	: (fd:fd, iov:iovec[:] -> size)
+const write	: (fd:fd, buf:byte[:] -> size)
+const pwrite	: (fd:fd, buf:byte[:], off : off -> size)
+const writev	: (fd:fd, iov:iovec[:] -> size)
+const lseek	: (fd:fd, off : off, whence : whence -> int64)
+const stat	: (path:byte[:], sb:statbuf# -> int64)
+const lstat	: (path:byte[:], sb:statbuf# -> int64)
+const fstat	: (fd:fd, sb:statbuf# -> int64)
+const mkdir	: (path : byte[:], mode : int64	-> int64)
+generic ioctl	: (fd:fd, req : int64, arg:@a# -> int64)
+const getdents	: (fd : fd, buf : byte[:] -> int64)
+const chdir	: (p : byte[:] -> int64)
+const __getcwd	: (buf : byte[:] -> int64)
+const poll	: (pfd : pollfd[:], tm : int -> int)
+
+/* signals */
+const sigaction	: (sig : signo, act : sigaction#, oact : sigaction# -> int)
+const sigprocmask	: (how : int32, set : sigset#, oset : sigset# -> int)
+
+/* fd stuff */
+const pipe	: (fds : fd[2]# -> int64)
+const dup	: (fd : fd -> fd)
+const dup2	: (src : fd, dst : fd -> fd)
+/* NB: the C ABI uses '...' for the args. */
+const fcntl	: (fd : fd, cmd : fcntlcmd, args : byte# -> int64)
+
+/* networking */
+const socket	: (dom : sockfam, stype : socktype, proto : sockproto	-> fd)
+const connect	: (sock	: fd, addr : sockaddr#, len : size -> int)
+const accept	: (sock : fd, addr : sockaddr#, len : size# -> fd)
+const listen	: (sock : fd, backlog : int	-> int)
+const bind	: (sock : fd, addr : sockaddr#, len : size -> int)
+const setsockopt	: (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size -> int)
+const getsockopt	: (sock : fd, lev : sockproto, opt : sockopt, val : void#, len : size# -> int)
+
+/* memory mapping */
+const munmap	: (addr:byte#, len:size -> int64)
+const mmap	: (addr:byte#, len:size, prot:mprot, flags:mopt, fd:fd, off:off -> byte#)
+
+/* time - doublecheck if this is right */
+const clock_getres	: (clk : clock, ts : timespec# -> int32)
+const clock_gettime	: (clk : clock, ts : timespec# -> int32)
+const clock_settime	: (clk : clock, ts : timespec# -> int32)
+const sleep	: (time : uint64 -> int32)
+const nanosleep	: (req : timespec#, rem : timespec# -> int32)
+
+/* system information */
+const uname 	: (buf : utsname# -> int)
+const sysctl	: (mib : int[:], \
+		old : void#, oldsz : size#, \
+		new : void#, newsz : size# \
+		-> int)
+
+/* 
+wraps a syscall argument, converting it to 64 bits for the syscall function. This is
+the same as casting, but more concise than writing a cast to uint64
+*/
+generic a = {x : @t; -> (x : uint64)}
+
+extern const cstring	: (str : byte[:] -> byte#)
+extern const alloca	: (sz : size	-> byte#)
+
+extern const __freebsd_pipe	: (fds : fd[2]# -> int64)
+
+/* process management */
+const exit	= {status;		syscall(Sysexit, a(status))}
+const getpid	= {;			-> (syscall(Sysgetpid, 1) : pid)}
+const kill	= {pid, sig;		-> syscall(Syskill, pid, sig)}
+const fork	= {;			-> (syscall(Sysfork) : pid)}
+const wait4	= {pid, loc, opt, usage;	-> syscall(Syswait4, pid, loc, opt, usage)}
+const waitpid	= {pid, loc, opt;
+	-> wait4(pid, loc, opt, (0 : rusage#)) 
+}
+
+const execv	= {cmd, args
+	var p, cargs, i
+
+	/* of course we fucking have to duplicate this code everywhere,
+	* since we want to stack allocate... */
+	p = alloca((args.len + 1)*sizeof(byte#))
+	cargs = (p : byte##)[:args.len + 1]
+	for i = 0; i < args.len; i++
+		cargs[i] = cstring(args[i])
+	;;
+	cargs[args.len] = (0 : byte#)
+	-> syscall(Sysexecve, cstring(cmd), a(p), a(__cenvp))
+}
+
+const execve	= {cmd, args, env
+	var cargs, cenv, i
+	var p
+
+	/* copy the args */
+	p = alloca((args.len + 1)*sizeof(byte#))
+	cargs = (p : byte##)[:args.len]
+	for i = 0; i < args.len; i++
+		cargs[i] = cstring(args[i])
+	;;
+	cargs[args.len] = (0 : byte#)
+
+	/*
+	 copy the env.
+	 of course we fucking have to duplicate this code everywhere,
+	 since we want to stack allocate... 
+	*/
+	p = alloca((env.len + 1)*sizeof(byte#))
+	cenv = (p : byte##)[:env.len]
+	for i = 0; i < env.len; i++
+		cenv[i] = cstring(env[i])
+	;;
+	cenv[env.len] = (0 : byte#)
+
+	-> syscall(Sysexecve, cstring(cmd), a(p), a(cenv))
+}
+
+/* fd manipulation */
+const open	= {path, opts;		-> (syscall(Sysopen, cstring(path), a(opts), a(0o777)) : fd)}
+const openmode	= {path, opts, mode;	-> (syscall(Sysopen, cstring(path), a(opts), a(mode)) : fd)}
+const close	= {fd;			-> syscall(Sysclose, a(fd))}
+const creat	= {path, mode;		-> (openmode(path, Ocreat | Otrunc | Owronly, mode) : fd)}
+const unlink	= {path;		-> (syscall(Sysunlink, cstring(path)) : int)}
+const read	= {fd, buf;		-> (syscall(Sysread, a(fd), (buf : byte#), a(buf.len)) : size)}
+const pread	= {fd, buf, off;	-> (syscall(Syspread, a(fd), (buf : byte#), a(buf.len), a(off)) : size)}
+const readv	= {fd, vec;		-> (syscall(Sysreadv, a(fd), (vec : iovec#), a(vec.len)) : size)}
+const write	= {fd, buf;		-> (syscall(Syswrite, a(fd), (buf : byte#), a(buf.len)) : size)}
+const pwrite	= {fd, buf, off;	-> (syscall(Syspwrite, a(fd), (buf : byte#), a(buf.len), a(off)) : size)}
+const writev	= {fd, vec;		-> (syscall(Syswritev, a(fd), (vec : iovec#), a(vec.len)) : size)}
+const lseek	= {fd, off, whence;	-> syscall(Syslseek, a(fd), a(off), a(whence))}
+const stat	= {path, sb;		-> syscall(Sysstat, cstring(path), a(sb))}
+const lstat	= {path, sb;		-> syscall(Syslstat, cstring(path), a(sb))}
+const fstat	= {fd, sb;		-> syscall(Sysfstat, a(fd), a(sb))}
+const mkdir	= {path, mode;		-> (syscall(Sysmkdir, cstring(path), a(mode)) : int64)}
+generic ioctl	= {fd, req, arg;	-> (syscall(Sysioctl, a(fd), a(req), a(arg)) : int64)}
+const chdir	= {dir;	-> syscall(Syschdir, cstring(dir))}
+const __getcwd	= {buf;	-> syscall(Sys__getcwd, a(buf), a(buf.len))}
+const getdents	= {fd, buf;		-> (syscall(Sysgetdents, a(buf), a(buf.len)) : int64)}
+
+/* signals */
+const sigaction	= {sig, act, oact;	-> (syscall(Syssigaction, a(sig), a(act), a(oact)) : int)}
+const sigprocmask	= {sig, act, oact;	-> (syscall(Syssigprocmask, a(sig), a(act), a(oact)) : int)}
+
+/* file stuff */
+const pipe	= {fds;	-> syscall(Syspipe, fds)}
+const dup 	= {fd;	-> (syscall(Sysdup, a(fd)) : fd)}
+const dup2 	= {src, dst;	-> (syscall(Sysdup2, a(src), a(dst)) : fd)}
+const fcntl	= {fd, cmd, args; 	-> syscall(Sysfcntl, a(fd), a(cmd), a(args))}
+const poll      = {pfd, tm;     -> (syscall(Syspoll, (pfd : byte#), a(pfd.len), a(tm)) : int)}
+
+/* networking */
+const socket	= {dom, stype, proto;	-> (syscall(Syssocket, a(dom), a(stype), a(proto)) : fd)}
+const connect	= {sock, addr, len;	-> (syscall(Sysconnect, a(sock), a(addr), a(len)) : int)}
+const accept	= {sock, addr, len;	-> (syscall(Sysaccept, a(sock), a(addr), a(len)) : fd)}
+const listen	= {sock, backlog;	-> (syscall(Syslisten, a(sock), a(backlog)) : int)}
+const bind	= {sock, addr, len;	-> (syscall(Sysbind, a(sock), a(addr), a(len)) : int)}
+const setsockopt	= {sock, lev, opt, val, len;	-> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)}
+const getsockopt	= {sock, lev, opt, val, len;	-> (syscall(Syssetsockopt, a(sock), a(lev), a(opt), a(val), a(len)) : int)}
+
+/* memory management */
+const munmap	= {addr, len;		-> syscall(Sysmunmap, a(addr), a(len))}
+const mmap	= {addr, len, prot, flags, fd, off;
+	/* the actual syscall has padding on the offset arg */
+	-> (syscall(Sysmmap, a(addr), a(len), a(prot), a(flags), a(fd), a(0), a(off)) : byte#)
+}
+
+/* time */
+const clock_getres = {clk, ts;	-> (syscall(Sysclock_getres, clockid(clk), a(ts)) : int32)}
+const clock_gettime = {clk, ts;	-> (syscall(Sysclock_gettime, clockid(clk), a(ts)) : int32)}
+const clock_settime = {clk, ts;	-> (syscall(Sysclock_settime, clockid(clk), a(ts)) : int32)}
+
+const sleep = {time
+	var req, rem
+	req = [.sec = time, .nsec = 0]
+	-> nanosleep(&req, &rem)
+}
+
+const nanosleep	= {req, rem;	-> (syscall(Sysnanosleep, a(req), a(rem)) : int32)}
+
+
+/* system information */
+const uname	= {buf
+	var mib : int[2]
+	var ret
+	var sys, syssz
+	var nod, nodsz
+	var rel, relsz
+	var ver, versz
+	var mach, machsz
+
+	ret = 0
+	mib[0] = 1 /* CTL_KERN */
+	mib[1] = 1 /* KERN_OSTYPE */
+	sys = (buf.system[:] : void#)
+	syssz = buf.system.len
+	ret = sysctl(mib[:], sys, &syssz, (0 : void#), (0 : size#))
+	if ret < 0
+		-> ret
+	;;
+
+	mib[0] = 1 /* CTL_KERN */
+	mib[1] = 10 /* KERN_HOSTNAME */
+	nod = (buf.node[:] : void#)
+	nodsz = buf.node.len
+	ret = sysctl(mib[:], nod, &nodsz, (0 : void#), (0 : size#))
+	if ret < 0
+		-> ret
+	;;
+
+	mib[0] = 1 /* CTL_KERN */
+	mib[1] = 2 /* KERN_OSRELEASE */
+	rel = (buf.release[:] : void#)
+	relsz = buf.release.len
+	ret = sysctl(mib[:], rel, &relsz, (0 : void#), (0 : size#))
+	if ret < 0
+		-> ret
+	;;
+
+	mib[0] = 1 /* CTL_KERN */
+	mib[1] = 27 /* KERN_OSVERSION */
+	ver = (buf.version[:] : void#)
+	versz = buf.version.len
+	ret = sysctl(mib[:], ver, &versz, (0 : void#), (0 : size#))
+	if ret < 0
+		-> ret
+	;;
+
+	mib[0] = 6 /* CTL_HW */
+	mib[1] = 1 /* HW_MACHINE */
+	mach = (buf.machine[:] : void#)
+	machsz = buf.machine.len
+	ret = sysctl(mib[:], mach, &machsz, (0 : void#), (0 : size#))
+	if ret < 0
+		-> ret
+	;;
+
+	-> 0
+}
+
+const sysctl = {mib, old, oldsz, new, newsz
+	/* all args already passed through a() or ar  ptrs */
+	-> (syscall(Syssysctl, \
+		(mib : int#), a(mib.len), old, oldsz, new, newsz) : int)
+}
+
+const clockid = {clk
+	match clk
+	| `Clockrealtime:	-> 0
+	| `Clockproccputime:	-> 2
+	| `Clockmonotonic:	-> 3
+	| `Clockthreadcputime:	-> 4
+	| `Clockuptime:	-> 5
+	;;
+	-> -1
+}
+
+const waitstatus = {st
+	if st < 0
+		-> `Waitfail st
+	;;
+	match st & 0o177
+	| 0:    -> `Waitexit (st >> 8)
+	| 0x7f:-> `Waitstop (st >> 8)
+	| sig:  -> `Waitsig sig
+	;;
+}
+
--- /dev/null
+++ b/support/syscall-gen/syscalls+openbsd:6.2.master
@@ -1,0 +1,571 @@
+;	$OpenBSD: syscalls.master,v 1.177 2017/08/12 00:03:10 tedu Exp $
+;	$NetBSD: syscalls.master,v 1.32 1996/04/23 10:24:21 mycroft Exp $
+
+;	@(#)syscalls.master	8.2 (Berkeley) 1/13/94
+
+; OpenBSD system call name/number "master" file.
+; (See syscalls.conf to see what it is processed into.)
+;
+; Fields: number type [type-dependent ...]
+;	number	system call number, must be in order
+;	type	one of the types described below, or one of the
+;		compatibility options defined in syscalls.conf
+;
+; types:
+;	INDIR	included, but don't define the syscall args structure,
+;		and allow it to be "really" varargs
+;	NOARGS	included, but don't define the syscall args structure
+;	NODEF	included, but don't define the syscall number
+;	NOLOCK	don't acquire the kernel lock when calling this syscall
+;	OBSOL	obsolete, not included in system
+;	STD	always included
+;	UNIMPL	unimplemented, not included in system
+;
+; The compat options are defined in the syscalls.conf file, and the
+; compat option name is prefixed to the syscall name.  Other than
+; that, they're like NODEF (for 'compat' options), or STD (for
+; 'libcompat' options).
+;
+; The type-dependent arguments are as follows:
+; For STD, NODEF, NOARGS, and compat syscalls:
+;	{ pseudo-proto } [alias]
+; For other syscalls:
+;	[comment]
+;
+; #ifdef's, etc. may be included, and are copied to the output files.
+; #include's are copied to the syscall switch definition file only.
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/signal.h>
+#include <sys/mount.h>
+#include <sys/syscallargs.h>
+#include <sys/poll.h>
+
+; Reserved/unimplemented system calls in the range 0-150 inclusive
+; are reserved for use in future Berkeley releases.
+; Additional system calls implemented in vendor and other
+; redistributions should be placed in the reserved range at the end
+; of the current calls.
+
+0	INDIR		{ int sys_syscall(int number, ...); }
+1	STD		{ void sys_exit(int rval); }
+2	STD		{ int sys_fork(void); }
+3	STD		{ ssize_t sys_read(int fd, void *buf, size_t nbyte); }
+4	STD		{ ssize_t sys_write(int fd, const void *buf, \
+			    size_t nbyte); }
+5	STD		{ int sys_open(const char *path, \
+			    int flags, ... mode_t mode); }
+6	STD		{ int sys_close(int fd); }
+7	STD NOLOCK	{ int sys_getentropy(void *buf, size_t nbyte); }
+8	STD		{ int sys___tfork(const struct __tfork *param, \
+			    size_t psize); }
+9	STD		{ int sys_link(const char *path, const char *link); }
+10	STD		{ int sys_unlink(const char *path); }
+11	STD		{ pid_t sys_wait4(pid_t pid, int *status, \
+			    int options, struct rusage *rusage); }
+12	STD		{ int sys_chdir(const char *path); }
+13	STD		{ int sys_fchdir(int fd); }
+14	STD		{ int sys_mknod(const char *path, mode_t mode, \
+			    dev_t dev); }
+15	STD		{ int sys_chmod(const char *path, mode_t mode); }
+16	STD		{ int sys_chown(const char *path, uid_t uid, \
+			    gid_t gid); }
+17	STD		{ int sys_obreak(char *nsize); } break
+18	STD NOLOCK	{ int sys_getdtablecount(void); }
+19	STD		{ int sys_getrusage(int who, \
+			    struct rusage *rusage); }
+20	STD NOLOCK	{ pid_t sys_getpid(void); }
+21	STD		{ int sys_mount(const char *type, const char *path, \
+			    int flags, void *data); }
+22	STD		{ int sys_unmount(const char *path, int flags); }
+23	STD		{ int sys_setuid(uid_t uid); }
+24	STD NOLOCK	{ uid_t sys_getuid(void); }
+25	STD NOLOCK	{ uid_t sys_geteuid(void); }
+#ifdef PTRACE
+26	STD		{ int sys_ptrace(int req, pid_t pid, caddr_t addr, \
+			    int data); }
+#else
+26	UNIMPL		ptrace
+#endif
+27	STD		{ ssize_t sys_recvmsg(int s, struct msghdr *msg, \
+			    int flags); }
+28	STD		{ ssize_t sys_sendmsg(int s, \
+			    const struct msghdr *msg, int flags); }
+29	STD		{ ssize_t sys_recvfrom(int s, void *buf, size_t len, \
+			    int flags, struct sockaddr *from, \
+			    socklen_t *fromlenaddr); }
+30	STD		{ int sys_accept(int s, struct sockaddr *name, \
+			    socklen_t *anamelen); }
+31	STD		{ int sys_getpeername(int fdes, struct sockaddr *asa, \
+			    socklen_t *alen); }
+32	STD		{ int sys_getsockname(int fdes, struct sockaddr *asa, \
+			    socklen_t *alen); }
+33	STD		{ int sys_access(const char *path, int amode); }
+34	STD		{ int sys_chflags(const char *path, u_int flags); }
+35	STD		{ int sys_fchflags(int fd, u_int flags); }
+36	STD		{ void sys_sync(void); }
+37	OBSOL		o58_kill
+38	STD		{ int sys_stat(const char *path, struct stat *ub); }
+39	STD		{ pid_t sys_getppid(void); }
+40	STD		{ int sys_lstat(const char *path, struct stat *ub); }
+41	STD		{ int sys_dup(int fd); }
+42	STD		{ int sys_fstatat(int fd, const char *path, \
+			    struct stat *buf, int flag); }
+43	STD NOLOCK	{ gid_t sys_getegid(void); }
+44	STD		{ int sys_profil(caddr_t samples, size_t size, \
+			    u_long offset, u_int scale); }
+#ifdef KTRACE
+45	STD		{ int sys_ktrace(const char *fname, int ops, \
+			    int facs, pid_t pid); }
+#else
+45	UNIMPL		ktrace
+#endif
+46	STD		{ int sys_sigaction(int signum, \
+			    const struct sigaction *nsa, \
+			    struct sigaction *osa); }
+47	STD NOLOCK	{ gid_t sys_getgid(void); }
+48	STD NOLOCK	{ int sys_sigprocmask(int how, sigset_t mask); }
+49	OBSOL		ogetlogin
+50	STD		{ int sys_setlogin(const char *namebuf); }
+#ifdef ACCOUNTING
+51	STD		{ int sys_acct(const char *path); }
+#else
+51	UNIMPL		acct
+#endif
+52	STD		{ int sys_sigpending(void); }
+53	STD		{ int sys_fstat(int fd, struct stat *sb); }
+54	STD		{ int sys_ioctl(int fd, \
+			    u_long com, ... void *data); }
+55	STD		{ int sys_reboot(int opt); }
+56	STD		{ int sys_revoke(const char *path); }
+57	STD		{ int sys_symlink(const char *path, \
+			    const char *link); }
+58	STD		{ ssize_t sys_readlink(const char *path, \
+			    char *buf, size_t count); }
+59	STD		{ int sys_execve(const char *path, \
+			    char * const *argp, char * const *envp); }
+60	STD		{ mode_t sys_umask(mode_t newmask); }
+61	STD		{ int sys_chroot(const char *path); }
+62	STD		{ int sys_getfsstat(struct statfs *buf, size_t bufsize, \
+			    int flags); }
+63	STD		{ int sys_statfs(const char *path, \
+			    struct statfs *buf); }
+64	STD		{ int sys_fstatfs(int fd, struct statfs *buf); }
+65	STD		{ int sys_fhstatfs(const fhandle_t *fhp, \
+			    struct statfs *buf); }
+66	STD		{ int sys_vfork(void); }
+67	STD NOLOCK	{ int sys_gettimeofday(struct timeval *tp, \
+			    struct timezone *tzp); }
+68	STD		{ int sys_settimeofday(const struct timeval *tv, \
+			    const struct timezone *tzp); }
+69	STD		{ int sys_setitimer(int which, \
+			    const struct itimerval *itv, \
+			    struct itimerval *oitv); }
+70	STD		{ int sys_getitimer(int which, \
+			    struct itimerval *itv); }
+71	STD		{ int sys_select(int nd, fd_set *in, fd_set *ou, \
+			    fd_set *ex, struct timeval *tv); }
+72	STD		{ int sys_kevent(int fd, \
+			    const struct kevent *changelist, int nchanges, \
+			    struct kevent *eventlist, int nevents, \
+			    const struct timespec *timeout); }
+73	STD		{ int sys_munmap(void *addr, size_t len); }
+74	STD		{ int sys_mprotect(void *addr, size_t len, \
+			    int prot); }
+75	STD		{ int sys_madvise(void *addr, size_t len, \
+			    int behav); }
+76	STD		{ int sys_utimes(const char *path, \
+			    const struct timeval *tptr); }
+77	STD		{ int sys_futimes(int fd, \
+			    const struct timeval *tptr); }
+78	STD		{ int sys_mincore(void *addr, size_t len, \
+			    char *vec); }
+79	STD NOLOCK	{ int sys_getgroups(int gidsetsize, \
+			    gid_t *gidset); }
+80	STD		{ int sys_setgroups(int gidsetsize, \
+			    const gid_t *gidset); }
+81	STD		{ int sys_getpgrp(void); }
+82	STD		{ int sys_setpgid(pid_t pid, pid_t pgid); }
+83	STD NOLOCK	{ int sys_futex(uint32_t *f, int op, int val, \
+			    const struct timespec *timeout, uint32_t *g); }
+84	STD		{ int sys_utimensat(int fd, const char *path, \
+			    const struct timespec *times, int flag); }
+85	STD		{ int sys_futimens(int fd, \
+			    const struct timespec *times); }
+86	STD		{ int sys_kbind(const struct __kbind *param, \
+			    size_t psize, int64_t proc_cookie); }
+87	STD NOLOCK	{ int sys_clock_gettime(clockid_t clock_id, \
+			    struct timespec *tp); }
+88	STD		{ int sys_clock_settime(clockid_t clock_id, \
+			    const struct timespec *tp); }
+89	STD NOLOCK	{ int sys_clock_getres(clockid_t clock_id, \
+			    struct timespec *tp); }
+90	STD		{ int sys_dup2(int from, int to); }
+91	STD		{ int sys_nanosleep(const struct timespec *rqtp, \
+			    struct timespec *rmtp); }
+92	STD		{ int sys_fcntl(int fd, int cmd, ... void *arg); }
+93	STD		{ int sys_accept4(int s, struct sockaddr *name, \
+			    socklen_t *anamelen, int flags); }
+94	STD		{ int sys___thrsleep(const volatile void *ident, \
+			    clockid_t clock_id, const struct timespec *tp, \
+			    void *lock, const int *abort); }
+95	STD		{ int sys_fsync(int fd); }
+96	STD		{ int sys_setpriority(int which, id_t who, int prio); }
+97	STD		{ int sys_socket(int domain, int type, int protocol); }
+98	STD		{ int sys_connect(int s, const struct sockaddr *name, \
+			    socklen_t namelen); }
+99	STD		{ int sys_getdents(int fd, void *buf, size_t buflen); }
+100	STD		{ int sys_getpriority(int which, id_t who); }
+101	STD		{ int sys_pipe2(int *fdp, int flags); }
+102	STD		{ int sys_dup3(int from, int to, int flags); }
+103	STD		{ int sys_sigreturn(struct sigcontext *sigcntxp); }
+104	STD		{ int sys_bind(int s, const struct sockaddr *name, \
+			    socklen_t namelen); }
+105	STD		{ int sys_setsockopt(int s, int level, int name, \
+			    const void *val, socklen_t valsize); }
+106	STD		{ int sys_listen(int s, int backlog); }
+107	STD		{ int sys_chflagsat(int fd, const char *path, \
+			    u_int flags, int atflags); }
+108	STD 		{ int sys_pledge(const char *request, const char **paths); }
+109	STD		{ int sys_ppoll(struct pollfd *fds, \
+			    u_int nfds, const struct timespec *ts, \
+			    const sigset_t *mask); }
+110	STD		{ int sys_pselect(int nd, fd_set *in, fd_set *ou, \
+			    fd_set *ex, const struct timespec *ts, \
+			    const sigset_t *mask); }
+111	STD		{ int sys_sigsuspend(int mask); }
+112	STD		{ int sys_sendsyslog(const void *buf, size_t nbyte, \
+			    int flags); }
+#ifdef KTRACE
+113	STD		{ int sys_fktrace(int fd, int ops, \
+			    int facs, pid_t pid); }
+#else
+113	UNIMPL		fktrace
+#endif
+114	OBSOL		osendmsg
+115	OBSOL		vtrace
+116	OBSOL		t32_gettimeofday
+117	OBSOL		t32_getrusage
+118	STD		{ int sys_getsockopt(int s, int level, int name, \
+			    void *val, socklen_t *avalsize); }
+119	STD		{ int sys_thrkill(pid_t tid, int signum, void *tcb); }
+120	STD		{ ssize_t sys_readv(int fd, \
+			    const struct iovec *iovp, int iovcnt); }
+121	STD		{ ssize_t sys_writev(int fd, \
+			    const struct iovec *iovp, int iovcnt); }
+122	STD		{ int sys_kill(int pid, int signum); }
+123	STD		{ int sys_fchown(int fd, uid_t uid, gid_t gid); }
+124	STD		{ int sys_fchmod(int fd, mode_t mode); }
+125	OBSOL		orecvfrom
+126	STD		{ int sys_setreuid(uid_t ruid, uid_t euid); }
+127	STD		{ int sys_setregid(gid_t rgid, gid_t egid); }
+128	STD		{ int sys_rename(const char *from, const char *to); }
+129	OBSOL		otruncate
+130	OBSOL		oftruncate
+131	STD		{ int sys_flock(int fd, int how); }
+132	STD		{ int sys_mkfifo(const char *path, mode_t mode); }
+133	STD		{ ssize_t sys_sendto(int s, const void *buf, \
+			    size_t len, int flags, const struct sockaddr *to, \
+			    socklen_t tolen); }
+134	STD		{ int sys_shutdown(int s, int how); }
+135	STD		{ int sys_socketpair(int domain, int type, \
+			    int protocol, int *rsv); }
+136	STD		{ int sys_mkdir(const char *path, mode_t mode); }
+137	STD		{ int sys_rmdir(const char *path); }
+138	OBSOL		t32_utimes
+139	OBSOL		4.2 sigreturn
+140	STD		{ int sys_adjtime(const struct timeval *delta, \
+			    struct timeval *olddelta); }
+141	STD		{ int sys_getlogin_r(char *namebuf, u_int namelen); }
+142	OBSOL		ogethostid
+143	OBSOL		osethostid
+144	OBSOL		ogetrlimit
+145	OBSOL		osetrlimit
+146	OBSOL		okillpg
+147	STD		{ int sys_setsid(void); }
+148	STD		{ int sys_quotactl(const char *path, int cmd, \
+			    int uid, char *arg); }
+149	OBSOL		oquota
+150	OBSOL		ogetsockname
+
+; Syscalls 151-180 inclusive are reserved for vendor-specific
+; system calls.  (This includes various calls added for compatibility
+; with other Unix variants.)
+; Some of these calls are now supported by BSD...
+151	UNIMPL
+152	UNIMPL
+153	UNIMPL
+154	UNIMPL
+#if defined(NFSCLIENT) || defined(NFSSERVER)
+155	STD		{ int sys_nfssvc(int flag, void *argp); }
+#else
+155	UNIMPL
+#endif
+156	OBSOL		ogetdirentries
+157	OBSOL		statfs25
+158	OBSOL		fstatfs25
+159	UNIMPL
+160	UNIMPL
+161	STD		{ int sys_getfh(const char *fname, fhandle_t *fhp); }
+162	OBSOL		ogetdomainname
+163	OBSOL		osetdomainname
+164	UNIMPL		ouname
+165	STD		{ int sys_sysarch(int op, void *parms); }
+166	UNIMPL
+167	UNIMPL
+168	UNIMPL
+169	OBSOL		semsys10
+170	OBSOL		msgsys10
+171	OBSOL		shmsys10
+172	UNIMPL
+173	STD		{ ssize_t sys_pread(int fd, void *buf, \
+			  size_t nbyte, int pad, off_t offset); }
+174	STD		{ ssize_t sys_pwrite(int fd, const void *buf, \
+			  size_t nbyte, int pad, off_t offset); }
+175	UNIMPL		ntp_gettime
+176	UNIMPL		ntp_adjtime
+177	UNIMPL
+178	UNIMPL
+179	UNIMPL
+180	UNIMPL
+
+; Syscalls 181-199 are used by/reserved for BSD
+181	STD		{ int sys_setgid(gid_t gid); }
+182	STD		{ int sys_setegid(gid_t egid); }
+183	STD		{ int sys_seteuid(uid_t euid); }
+184	OBSOL		lfs_bmapv
+185	OBSOL		lfs_markv
+186	OBSOL		lfs_segclean
+187	OBSOL		lfs_segwait
+188	OBSOL		stat35
+189	OBSOL		fstat35
+190	OBSOL		lstat35
+191	STD		{ long sys_pathconf(const char *path, int name); }
+192	STD		{ long sys_fpathconf(int fd, int name); }
+193	STD		{ int sys_swapctl(int cmd, const void *arg, int misc); }
+194	STD		{ int sys_getrlimit(int which, \
+			    struct rlimit *rlp); }
+195	STD		{ int sys_setrlimit(int which, \
+			    const struct rlimit *rlp); }
+196	OBSOL		ogetdirentries48
+197	STD		{ void *sys_mmap(void *addr, size_t len, int prot, \
+			    int flags, int fd, long pad, off_t pos); }
+198	INDIR		{ quad_t sys___syscall(quad_t num, ...); }
+199	STD		{ off_t sys_lseek(int fd, int pad, off_t offset, \
+			    int whence); }
+200	STD		{ int sys_truncate(const char *path, int pad, \
+			    off_t length); }
+201	STD		{ int sys_ftruncate(int fd, int pad, off_t length); }
+202	STD		{ int sys_sysctl(const int *name, u_int namelen, \
+			    void *old, size_t *oldlenp, void *new, \
+			    size_t newlen); }
+203	STD		{ int sys_mlock(const void *addr, size_t len); }
+204	STD		{ int sys_munlock(const void *addr, size_t len); }
+205	UNIMPL		sys_undelete
+206	OBSOL		t32_futimes
+207	STD		{ pid_t sys_getpgid(pid_t pid); }
+208	OBSOL		nnpfspioctl
+209	STD		{ int sys_utrace(const char *label, const void *addr, \
+			    size_t len); }
+;
+; Syscalls 210-219 were reserved for dynamically loaded syscalls
+;
+210	UNIMPL
+211	UNIMPL
+212	UNIMPL
+213	UNIMPL
+214	UNIMPL
+215	UNIMPL
+216	UNIMPL
+217	UNIMPL
+218	UNIMPL
+219	UNIMPL
+; System calls 220-240 are reserved for use by OpenBSD
+#ifdef SYSVSEM
+220	UNIMPL
+221	STD		{ int sys_semget(key_t key, int nsems, int semflg); }
+#else
+220	UNIMPL		semctl
+221	UNIMPL		semget
+#endif
+222	OBSOL		semop35
+223	OBSOL		semconfig35
+#ifdef SYSVMSG
+224	UNIMPL
+225	STD		{ int sys_msgget(key_t key, int msgflg); }
+226	STD		{ int sys_msgsnd(int msqid, const void *msgp, size_t msgsz, \
+			    int msgflg); }
+227	STD		{ int sys_msgrcv(int msqid, void *msgp, size_t msgsz, \
+			    long msgtyp, int msgflg); }
+#else
+224	UNIMPL		msgctl
+225	UNIMPL		msgget
+226	UNIMPL		msgsnd
+227	UNIMPL		msgrcv
+#endif
+#ifdef SYSVSHM
+228	STD		{ void *sys_shmat(int shmid, const void *shmaddr, \
+			    int shmflg); }
+229	UNIMPL
+230	STD		{ int sys_shmdt(const void *shmaddr); }
+#else
+228	UNIMPL		shmat
+229	UNIMPL		shmctl
+230	UNIMPL		shmdt
+#endif
+231	OBSOL		shmget35
+232	OBSOL		t32_clock_gettime
+233	OBSOL		t32_clock_settime
+234	OBSOL		t32_clock_getres
+235	UNIMPL		timer_create
+236	UNIMPL		timer_delete
+237	UNIMPL		timer_settime
+238	UNIMPL		timer_gettime
+239	UNIMPL		timer_getoverrun
+;
+; System calls 240-249 are reserved for other IEEE Std1003.1b syscalls
+;
+240	OBSOL		t32_nanosleep
+241	UNIMPL
+242	UNIMPL
+243	UNIMPL
+244	UNIMPL
+245	UNIMPL
+246	UNIMPL
+247	UNIMPL
+248	UNIMPL
+249	UNIMPL
+250	STD		{ int sys_minherit(void *addr, size_t len, \
+			    int inherit); }
+251	OBSOL		rfork
+252	STD		{ int sys_poll(struct pollfd *fds, \
+			    u_int nfds, int timeout); }
+253	STD NOLOCK	{ int sys_issetugid(void); }
+254	STD		{ int sys_lchown(const char *path, uid_t uid, gid_t gid); }
+255	STD		{ pid_t sys_getsid(pid_t pid); }
+256	STD		{ int sys_msync(void *addr, size_t len, int flags); }
+257	OBSOL		semctl35
+258	OBSOL		shmctl35
+259	OBSOL		msgctl35
+260	UNIMPL
+261	UNIMPL
+262	UNIMPL
+263	STD		{ int sys_pipe(int *fdp); }
+264	STD		{ int sys_fhopen(const fhandle_t *fhp, int flags); }
+265	UNIMPL
+266	UNIMPL
+267	STD		{ ssize_t sys_preadv(int fd, \
+			  const struct iovec *iovp, int iovcnt, \
+			  int pad, off_t offset); }
+268	STD		{ ssize_t sys_pwritev(int fd, \
+			  const struct iovec *iovp, int iovcnt, \
+			  int pad, off_t offset); }
+269	STD		{ int sys_kqueue(void); }
+270	OBSOL		t32_kevent
+271	STD		{ int sys_mlockall(int flags); }
+272	STD		{ int sys_munlockall(void); }
+273	UNIMPL		sys_getpeereid
+274	UNIMPL		sys_extattrctl
+275	UNIMPL		sys_extattr_set_file
+276	UNIMPL		sys_extattr_get_file
+277	UNIMPL		sys_extattr_delete_file
+278	UNIMPL		sys_extattr_set_fd
+279	UNIMPL		sys_extattr_get_fd
+280	UNIMPL		sys_extattr_delete_fd
+281	STD NOLOCK	{ int sys_getresuid(uid_t *ruid, uid_t *euid, \
+			    uid_t *suid); }
+282	STD		{ int sys_setresuid(uid_t ruid, uid_t euid, \
+			    uid_t suid); }
+283	STD NOLOCK	{ int sys_getresgid(gid_t *rgid, gid_t *egid, \
+			    gid_t *sgid); }
+284	STD		{ int sys_setresgid(gid_t rgid, gid_t egid, \
+			    gid_t sgid); }
+285	OBSOL		sys_omquery
+286	STD		{ void *sys_mquery(void *addr, size_t len, int prot, \
+			    int flags, int fd, long pad, off_t pos); }
+287	STD		{ int sys_closefrom(int fd); }
+288	STD		{ int sys_sigaltstack(const struct sigaltstack *nss, \
+			    struct sigaltstack *oss); }
+#ifdef SYSVSHM
+289	STD		{ int sys_shmget(key_t key, size_t size, int shmflg); }
+#else
+289	UNIMPL		shmget
+#endif
+#ifdef SYSVSEM
+290	STD		{ int sys_semop(int semid, struct sembuf *sops, \
+			    size_t nsops); }
+#else
+290    UNIMPL		semop
+#endif
+291	OBSOL		t32_stat
+292	OBSOL		t32_fstat
+293	OBSOL		t32_lstat
+294	STD		{ int sys_fhstat(const fhandle_t *fhp, \
+			    struct stat *sb); }
+#ifdef SYSVSEM
+295	STD		{ int sys___semctl(int semid, int semnum, int cmd, \
+			    union semun *arg); }
+#else
+295	UNIMPL
+#endif
+#ifdef SYSVSHM
+296	STD		{ int sys_shmctl(int shmid, int cmd, \
+			    struct shmid_ds *buf); }
+#else
+296	UNIMPL
+#endif
+#ifdef SYSVMSG
+297	STD		{ int sys_msgctl(int msqid, int cmd, \
+			    struct msqid_ds *buf); }
+#else
+297	UNIMPL
+#endif
+298	STD		{ int sys_sched_yield(void); }
+299	STD NOLOCK	{ pid_t sys_getthrid(void); }
+300	OBSOL		t32___thrsleep
+301	STD		{ int sys___thrwakeup(const volatile void *ident, \
+			    int n); }
+302	STD		{ void sys___threxit(pid_t *notdead); }
+303	STD		{ int sys___thrsigdivert(sigset_t sigmask, \
+			    siginfo_t *info, const struct timespec *timeout); }
+304	STD		{ int sys___getcwd(char *buf, size_t len); }
+305	STD		{ int sys_adjfreq(const int64_t *freq, \
+			    int64_t *oldfreq); }
+306	OBSOL		getfsstat53
+307	OBSOL		statfs53
+308	OBSOL		fstatfs53
+309	OBSOL		fhstatfs53
+310	STD		{ int sys_setrtable(int rtableid); }
+311	STD NOLOCK	{ int sys_getrtable(void); }
+312	OBSOL		t32_getdirentries
+313	STD		{ int sys_faccessat(int fd, const char *path, \
+			    int amode, int flag); }
+314	STD		{ int sys_fchmodat(int fd, const char *path, \
+			    mode_t mode, int flag); }
+315	STD		{ int sys_fchownat(int fd, const char *path, \
+			    uid_t uid, gid_t gid, int flag); }
+316	OBSOL		t32_fstatat
+317	STD		{ int sys_linkat(int fd1, const char *path1, int fd2, \
+			    const char *path2, int flag); }
+318	STD		{ int sys_mkdirat(int fd, const char *path, \
+			    mode_t mode); }
+319	STD		{ int sys_mkfifoat(int fd, const char *path, \
+			    mode_t mode); }
+320	STD		{ int sys_mknodat(int fd, const char *path, \
+			    mode_t mode, dev_t dev); }
+321	STD		{ int sys_openat(int fd, const char *path, int flags, \
+			    ... mode_t mode); }
+322	STD		{ ssize_t sys_readlinkat(int fd, const char *path, \
+			    char *buf, size_t count); }
+323	STD		{ int sys_renameat(int fromfd, const char *from, \
+			    int tofd, const char *to); }
+324	STD		{ int sys_symlinkat(const char *path, int fd, \
+			    const char *link); }
+325	STD		{ int sys_unlinkat(int fd, const char *path, \
+			    int flag); }
+326	OBSOL		t32_utimensat
+327	OBSOL		t32_futimens
+328	OBSOL		__tfork51
+329	STD NOLOCK	{ void sys___set_tcb(void *tcb); }
+330	STD NOLOCK	{ void *sys___get_tcb(void); }
--- /dev/null
+++ b/support/syscall-gen/types+openbsd:6.2-x64.frag
@@ -1,0 +1,472 @@
+type size	= int64	/* spans entire address space */
+type usize	= uint64	/* unsigned size */
+type off	= int64	/* file offsets */
+type intptr	= uint64/* can hold any pointer losslessly */
+type time	= int64	/* milliseconds since epoch */
+type pid	= int32	/* process id */
+type scno	= int64	/*syscall*/
+type fdopt	= int64	/* fd options */
+type fd		= int32	/* fd */
+type whence	= uint64	/* seek from whence */
+type mprot	= int64	/* memory protection */
+type mopt	= int64	/* memory mapping options */
+type socktype	= int64	/* socket type */
+type sockproto	= int64	/* socket protocol */
+type sockopt	= int32	/* socket option */
+type sockfam	= uint8	/* socket family */
+type filemode	= uint32
+type filetype	= uint8
+type fcntlcmd	= int64
+type signo	= int32
+type sigflags	= int32
+type sigset	= uint32
+type msg	= void
+
+type clock = union
+	`Clockrealtime
+	`Clockmonotonic
+	`Clockproccputime
+	`Clockthreadcputime
+	`Clockuptime
+;;
+
+type waitstatus = union
+	`Waitfail int32
+	`Waitexit int32
+	`Waitsig  int32
+	`Waitstop int32
+;;
+
+type rlimit = struct
+	cur	: uint64	/* current (soft) limit */
+	max	: uint64	/* maximum value for rlim_cur */
+;;
+
+type timespec = struct
+	sec	: uint64
+	nsec	: uint64 
+;;
+
+type timeval = struct
+	sec	: uint64
+	usec	: uint64
+;;
+
+type timezone = struct
+	minwest	: int32	/* minutes west of Greenwich */
+	dsttime	: int32	/* type of dst correction */
+;;
+
+type pollfd = struct
+	fd      : fd
+	events  : uint16
+	revents : uint16
+;;
+
+type itimerval = struct
+	interval	: timeval	/* timer interval */
+	value		: timeval	/* current value */
+;;
+
+type sigaction = struct
+	handler	: byte#	/* code pointer */
+	mask	: sigset
+	flags	: sigflags
+;;
+/*
+ * Information pushed on stack when a signal is delivered.
+ * This is used by the kernel to restore state following
+ * execution of the signal handler.  It is also made available
+ * to the handler to allow it to restore state properly if
+ * a non-standard exit is performed.
+ */
+type sigcontext = struct
+	/* plain match trapframe */
+	rdi	: int64
+	rsi	: int64
+	rdx	: int64
+	rcx	: int64
+	r8	: int64
+	r9	: int64
+	r10	: int64
+	r11	: int64
+	r12	: int64
+	r13	: int64
+	r14	: int64
+	r15	: int64
+	rbp	: int64
+	rbx	: int64
+	rax	: int64
+	gs	: int64
+	fs	: int64
+	es	: int64
+	ds	: int64
+	trapno	: int64
+	err	: int64
+	rip	: int64
+	cs	: int64
+	rflags	: int64
+	rsp	: int64
+	ss	: int64
+
+	fpstate	: fxsave64#
+	__pad	: int32
+	mask	: int32
+	cookie	: int64
+;;
+
+type sigaltstack = struct
+	sp	: void#
+	size	: size
+	flags	: int32
+;;
+
+type fxsave64 = struct
+	fcw	: int16
+	fsw	: int16
+	ftw	: int8
+	unused1	: int8
+	fop	: int16
+	rip	: int64
+	rdp	: int64
+	mxcsr	: int32
+	mxcsrmask	: int32
+	st	: int64[8][2]   /* 8 normal FP regs */
+	xmm	: int64[16][2] /* 16 SSE2 registers */
+	unused3	: int8[96]
+;;
+
+const Simaxsz	= 128
+const Sipad	= (Simaxsz / 4) - 3
+type siginfo = struct
+	signo	: int
+	code	: int
+	errno	: int
+	pad	: int[Sipad]
+;;
+
+type rusage = struct
+	utime	: timeval /* user time */
+	stime	: timeval /* system time */
+	maxrss	: uint64 /* max resident set size*/
+	ixrss	: uint64 /* shared text size */
+	idrss	: uint64 /* unshared data size */
+	isrss	: uint64 /* unshared stack size */
+	minflt	: uint64 /* page reclaims */
+	majflt	: uint64 /* page faults */
+	nswap	: uint64 /* swaps */
+	inblock	: uint64 /* block input ops */
+	oublock	: uint64 /* block output ops */
+	msgsnd	: uint64 /* messages sent */	
+	msgrcv	: uint64 /* messages received */
+	nsignals : uint64 /* signals received */
+	nvcsw	: uint64 /* voluntary context switches */
+	nivcsw	: uint64 /* involuntary context switches */
+;;
+
+type tforkparams = struct
+	tcb	: void#
+	tid	: pid#
+	stk	: byte#
+;;
+
+type statbuf = struct
+	mode	: filemode
+	dev	: uint32 
+	ino	: uint64
+	nlink	: uint32
+	uid	: uint32
+	gid	: uint32
+	rdev	: uint32
+	atime	: timespec
+	mtime	: timespec
+	ctime	: timespec
+	size	: off
+	blocks	: int64
+	blksize	: uint32
+	flags	: uint32
+	gen	: uint32
+	birthtim	: timespec 
+;;
+
+type semun = struct
+	semarr	: void#
+;;
+
+const Mfsnamelen 	= 16	/* length of fs type name, including nul */
+const Mnamelen		= 90	/* length of buffer for returned name */
+
+type statfs = struct
+	flags	: uint32	/* copy of mount flags */
+	bsize	: uint32	/* file system block size */
+	iosize	: uint32	/* optimal transfer block size */
+
+		        	/* unit is f_bsize */
+	blocks	: uint64	/* total data blocks in file system */
+	bfree	: uint64	/* free blocks in fs */
+	bavail	: int64		/* free blocks avail to non-superuser */
+
+	files	: int64		/* total file nodes in file system */
+	ffree	: int64		/* free file nodes in fs */
+	favail	: int64		/* free file nodes avail to non-root */
+
+	syncwr	: int64		/* count of sync writes since mount */
+	syncrd	: int64		/* count of sync reads since mount */
+	asyncwr	: int64		/* count of async writes since mount */
+	asyncrd	: int64		/* count of async reads since mount */
+
+	fsid	: fsid		/* file system id */
+	namemax	: uint32	/* maximum filename length */
+	owner	: uid		/* user that mounted the file system */
+	ctime	: uint64	/* last mount [-u] time */
+
+	fstypename	: byte[Mfsnamelen];	/* fs type name */
+	mntonname	: byte[Mnamelen];	/* directory on which mounted */
+	mntfromname	: byte[Mnamelen];	/* mounted file system */
+	mntfromspec	: byte[Mnamelen];	/* special for mount request */
+	///union mount_info mount_info;	/* per-filesystem mount options */
+	__mountinfo	: byte[160];	/* storage for 'union mount_info' */
+;;
+
+type utsname = struct
+	system	: byte[32]
+	node : byte[32] 
+	release : byte[32]
+	version : byte[32]
+	machine : byte[32]
+;;
+
+type sockaddr = struct
+	len	: byte
+	fam	: sockfam
+	data	: byte[14] /* what is the *actual* length? */
+;;
+
+type sockaddr_in = struct
+	len	: byte
+	fam	: sockfam
+	port	: uint16
+	addr	: byte[4]
+	zero	: byte[8]
+;;
+
+type sockaddr_in6 = struct
+	len	: byte
+	fam	: sockfam
+	port	: uint16
+	flow	: uint32
+	addr	: byte[16]
+	scope	: uint32
+;;
+
+type sockaddr_un = struct
+	len	: uint8
+	fam	: sockfam
+	path	: byte[104]
+;;
+
+type sockaddr_storage = struct
+	len	: byte
+	fam	: sockfam
+	__pad1  : byte[6]
+	__align : int64
+	__pad2  : byte[240]
+;;	
+
+type dirent = struct
+	fileno	: uint64
+	off	: uint64
+	reclen	: uint16
+	ftype	: uint8
+	namlen	: uint8
+	__pad	: byte[4]
+	name	: byte[256]	
+;;
+
+type iovec = struct
+	base	: byte#
+	len	: uint64
+;;
+
+/* open options */
+const Ordonly  	: fdopt = 0x0
+const Owronly  	: fdopt = 0x1
+const Ordwr    	: fdopt = 0x2
+const Oappend  	: fdopt = 0x8
+const Ondelay  	: fdopt = 0x4
+const Oshlock	: fdopt = 0x10		/* open with shared file lock */
+const Oexlock	: fdopt = 0x20		/* open with exclusive file lock */
+const Oasync	: fdopt = 0x40		/* signal pgrp when data ready */
+const Osync	: fdopt = 0x80		/* backwards compatibility */
+const Onofollow	: fdopt = 0x100
+const Ocreat   	: fdopt = 0x200
+const Otrunc   	: fdopt = 0x400
+const Oexcl   	: fdopt = 0x800
+const Ocloexec	: fdopt = 0x10000
+const Odsync	: fdopt = Osync		/* synchronous data writes */
+const Orsync	: fdopt = Osync		/* synchronous reads */
+const Odir	: fdopt = 0x20000
+
+/* poll options */
+const Pollin	: uint16 = 0x0001
+const Pollpri	: uint16 = 0x0002
+const Pollout	: uint16 = 0x0004
+const Pollerr	: uint16 = 0x0008
+const Pollhup	: uint16 = 0x0010
+const Pollnval	: uint16 = 0x0020
+const Pollnorm	: uint16 = 0x0040
+const Pollrdband: uint16 = 0x0080
+const Pollwrband: uint16 = 0x0100
+
+/* stat modes */	
+const Sifmt	: filemode = 0xf000
+const Sififo	: filemode = 0x1000
+const Sifchr	: filemode = 0x2000
+const Sifdir	: filemode = 0x4000
+const Sifblk	: filemode = 0x6000
+const Sifreg	: filemode = 0x8000
+const Siflnk	: filemode = 0xa000
+const Sifsock 	: filemode = 0xc000
+const Sisvtx 	: filemode = 0x0200
+
+/* mmap protection */
+const Mprotnone	: mprot = 0x0
+const Mprotrd	: mprot = 0x1
+const Mprotwr	: mprot = 0x2
+const Mprotexec	: mprot = 0x4
+const Mprotrw	: mprot = 0x3
+
+/* mmap options */
+const Mshared	: mopt = 0x1
+const Mpriv	: mopt = 0x2
+const Mfixed	: mopt = 0x10
+const Mfile	: mopt = 0x0
+const Manon	: mopt = 0x1000
+const Mnoreplace	: mopt = 0x0800
+
+/* file types */
+const Dtunknown	: filetype = 0
+const Dtfifo	: filetype = 1
+const Dtchr	: filetype = 2
+const Dtdir	: filetype = 4
+const Dtblk	: filetype = 6
+const Dtreg	: filetype = 8
+const Dtlnk	: filetype = 10
+const Dtsock	: filetype = 12
+
+/* socket families. INCOMPLETE. */
+const Afunspec	: sockfam = 0
+const Afunix	: sockfam = 1
+const Afinet	: sockfam = 2
+const Afinet6	: sockfam = 24
+
+/* socket types. */
+const Sockstream	: socktype = 1
+const Sockdgram		: socktype = 2
+const Sockraw		: socktype = 3
+const Sockrdm		: socktype = 4
+const Sockseqpacket	: socktype = 5
+
+/* socket options */
+const Sodebug		: sockopt = 0x0001	/* turn on debugging info recording */
+const Soacceptconn	: sockopt = 0x0002	/* socket has had listen() */
+const Soreuseaddr	: sockopt = 0x0004	/* allow local address reuse */
+const Sokeepalive	: sockopt = 0x0008	/* keep connections alive */
+const Sodontroute	: sockopt = 0x0010	/* just use interface addresses */
+const Sobroadcast	: sockopt = 0x0020	/* permit sending of broadcast msgs */
+const Souseloopback	: sockopt = 0x0040	/* bypass hardware when possible */
+const Solinger		: sockopt = 0x0080	/* linger on close if data present */
+const Sooobinline	: sockopt = 0x0100	/* leave received OOB data in line */
+const Soreuseport	: sockopt = 0x0200	/* allow local address & port reuse */
+const Sotimestamp	: sockopt = 0x0800	/* timestamp received dgram traffic */
+const Sobindany		: sockopt = 0x1000	/* allow bind to any address */
+const Sosndbuf		: sockopt = 0x1001	/* send buffer size */
+const Sorcvbuf		: sockopt = 0x1002	/* receive buffer size */
+const Sosndlowat	: sockopt = 0x1003	/* send low-water mark */
+const Sorcvlowat	: sockopt = 0x1004	/* receive low-water mark */
+const Sosndtimeo	: sockopt = 0x1005	/* send timeout */
+const Sorcvtimeo	: sockopt = 0x1006	/* receive timeout */
+const Soerror		: sockopt = 0x1007	/* get error status and clear */
+const Sotype		: sockopt = 0x1008	/* get socket type */
+const Sonetproc		: sockopt = 0x1020	/* multiplex; network processing */
+const Sortable		: sockopt = 0x1021	/* routing table to be used */
+const Sopeercred	: sockopt = 0x1022	/* get connect-time credentials */
+const Sosplice		: sockopt = 0x1023	/* splice data to other socket */
+
+/* socket option levels */
+const Solsocket		: sockproto = 0xffff
+
+/* network protocols */
+const Ipproto_ip	: sockproto = 0
+const Ipproto_icmp	: sockproto = 1
+const Ipproto_tcp	: sockproto = 6
+const Ipproto_udp	: sockproto = 17
+const Ipproto_raw	: sockproto = 255
+
+const Seekset	: whence = 0
+const Seekcur	: whence = 1
+const Seekend	: whence = 2
+
+/* system specific constants */
+const Maxpathlen	: size = 1024
+
+/* fcntl constants */
+const Fdupfd	 : fcntlcmd = 0		/* duplicate file descriptor */
+const Fgetfd	 : fcntlcmd = 1		/* get file descriptor flags */
+const Fsetfd	 : fcntlcmd = 2		/* set file descriptor flags */
+const Fgetfl	 : fcntlcmd = 3		/* get file status flags */
+const Fsetfl	 : fcntlcmd = 4		/* set file status flags */
+const Fgetown	 : fcntlcmd = 5		/* get SIGIO/SIGURG proc/pgrp */
+const Fsetown	 : fcntlcmd = 6		/* set SIGIO/SIGURG proc/pgrp */
+const Fogetlk	 : fcntlcmd = 7		/* get record locking information */
+const Fosetlk	 : fcntlcmd = 8		/* set record locking information */
+
+/* return value for a failed mapping */
+const Mapbad	: byte# = (-1 : byte#)
+
+/* signal flags */
+const Saonstack		: sigflags = 0x0001	/* take signal on signal stack */
+const Sarestart		: sigflags = 0x0002	/* restart system on signal return */
+const Saresethand	: sigflags = 0x0004	/* reset to SIG_DFL when taking signal */
+const Sanodefer		: sigflags = 0x0010	/* don't mask the signal we're delivering */
+const Sanocldwait	: sigflags = 0x0020	/* don't create zombies (assign to pid 1) */
+const Sanocldstop	: sigflags = 0x0008	/* do not generate SIGCHLD on child stop */
+const Sasiginfo		: sigflags = 0x0040	/* generate siginfo_t */
+
+/* signals */
+const Sighup	: signo = 1	/* hangup */
+const Sigint	: signo = 2	/* interrupt */
+const Sigquit	: signo = 3	/* quit */
+const Sigill	: signo = 4	/* illegal instruction (not reset when caught) */
+const Sigtrap	: signo = 5	/* trace trap (not reset when caught) */
+const Sigabrt	: signo = 6	/* abort() */
+const Sigiot	: signo = Sigabrt	/* compatibility */
+const Sigemt	: signo = 7	/* EMT instruction */
+const Sigfpe	: signo = 8	/* floating point exception */
+const Sigkill	: signo = 9	/* kill (cannot be caught or ignored) */
+const Sigbus	: signo = 10	/* bus error */
+const Sigsegv	: signo = 11	/* segmentation violation */
+const Sigsys	: signo = 12	/* bad argument to system call */
+const Sigpipe	: signo = 13	/* write on a pipe with no one to read it */
+const Sigalrm	: signo = 14	/* alarm clock */
+const Sigterm	: signo = 15	/* software termination signal from kill */
+const Sigurg	: signo = 16	/* urgent condition on IO channel */
+const Sigstop	: signo = 17	/* sendable stop signal not from tty */
+const Sigtstp	: signo = 18	/* stop signal from tty */
+const Sigcont	: signo = 19	/* continue a stopped process */
+const Sigchld	: signo = 20	/* to parent on child stop or exit */
+const Sigttin	: signo = 21	/* to readers pgrp upon background tty read */
+const Sigttou	: signo = 22	/* like TTIN for output if (tp->t_local&LTOSTOP) */
+const Sigio	: signo = 23	/* input/output possible signal */
+const Sigxcpu	: signo = 24	/* exceeded CPU time limit */
+const Sigxfsz	: signo = 25	/* exceeded file size limit */
+const Sigvtalrm : signo = 26	/* virtual time alarm */
+const Sigprof	: signo = 27	/* profiling time alarm */
+const Sigwinch	: signo = 28	/* window size changes */
+const Siginfo	: signo = 29	/* information request */
+const Sigusr1	: signo = 30	/* user defined signal 1 */
+const Sigusr2	: signo = 31	/* user defined signal 2 */
+const Sigthr	: signo = 32	/* thread library AST */
+
+extern const syscall : (sc:scno, args:... -> int64)
+extern var __cenvp : byte##