Merge branch 'master' into qbeqbe

9 files changed, 1465 insertions, 11 deletions

diff --git a/support/dumpleak.myr b/support/dumpleak.myr
index 350298a..dcd6c07 100644
--- a/support/dumpleak.myr
+++ b/support/dumpleak.myr
@@ -50,11 +50,11 @@ const main = {args
 const dump = {path, f, stats
 	while true
 		match bio.getle64(f)
-		| `bio.Ok 0:	tracealloc(path, f, stats)
-		| `bio.Ok 1:	tracefree(path, f, stats)
-		| `bio.Eof:	break
-		| `bio.Ok wat:	std.fatal("unknown action type {x}\n", wat)
-		| `bio.Err e:	std.fatal("failed to read {}: {}\n", path, e)
+		| `std.Err `bio.Eof:	break
+		| `std.Ok 0:		tracealloc(path, f, stats)
+		| `std.Ok 1:		tracefree(path, f, stats)
+		| `std.Ok wat:		std.fatal("unknown action type {x}\n", wat)
+		| `std.Err e:		std.fatal("failed to read {}: {}\n", path, e)
 		;;
 	;;
 	if !summary
@@ -78,7 +78,7 @@ const tracealloc = {path, f, stats
 	ptr = get64(path, f)
 	sz = get64(path, f)
 	stk = [][:]
-	for var i = 0; i < 10; i++
+	for var i = 0; i < 20; i++
 		std.slpush(&stk, get64(path, f))
 	;;
 	stats.allocs++
@@ -116,7 +116,7 @@ const dumptrace = {tab
 
 const get64 = {path, f
 	match bio.getle64(f)
-	| `bio.Ok v:	-> v
+	| `std.Ok v:	-> v
 	| res:	std.fatal("failed to read {}: {}\n", path, res)
 	;;
 }
diff --git a/support/syscall-gen/gencalls.awk b/support/syscall-gen/gencalls.awk
index ebed585..d625550 100644
--- a/support/syscall-gen/gencalls.awk
+++ b/support/syscall-gen/gencalls.awk
@@ -79,7 +79,7 @@ $Typefield == "STD" || (!masterfmt && $1 == "asmlinkage") {
 		tabs="\t\t"
 	else
 		tabs = "\t"
-	num = sprintf("%s%s: scno = %d", numcst, tabs, numbertab[name]);
+	num = sprintf("%s%s: scno = %d", numcst, tabs, $1);
 	scnums[nnums++] = num
 
 	if (nocode)
@@ -107,7 +107,7 @@ $Typefield == "STD" || (!masterfmt && $1 == "asmlinkage") {
 		sep = ", ";
 	}
 	call = call sprintf("\n\t -> (syscall(Sys%s", name)
-	for (i = 1; i < argc; i++) {
+	for (i = 0; i < argc; i++) {
 		call = call sprintf(", a(%s)", argname[i])
 	}
 	call = call sprintf(") : %s)\n}", ret)
diff --git a/support/syscall-gen/gensys.sh b/support/syscall-gen/gensys.sh
index 7559be9..c703642 100755
--- a/support/syscall-gen/gensys.sh
+++ b/support/syscall-gen/gensys.sh
@@ -38,6 +38,7 @@ hdrgen() {
 }
 
 rm -f have.txt want.txt gentypes+$1-$2.frag
+touch have.txt
 
 if [ `uname` = Linux ]; then
 	hdrgen $1 $2
diff --git a/support/syscall-gen/gentypes+openbsd:6.2-x64.frag b/support/syscall-gen/gentypes+openbsd:6.2-x64.frag
new file mode 100644
index 0000000..b8a4866
--- /dev/null
+++ b/support/syscall-gen/gentypes+openbsd:6.2-x64.frag
@@ -0,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]
+
+;;
+
diff --git a/support/syscall-gen/specials+openbsd:6.1-x64.frag b/support/syscall-gen/specials+openbsd:6.1-x64.frag
index 9a476f5..4cc3843 100644
--- a/support/syscall-gen/specials+openbsd:6.1-x64.frag
+++ b/support/syscall-gen/specials+openbsd:6.1-x64.frag
@@ -154,7 +154,7 @@ const mkdir	= {path, mode;		-> (syscall(Sysmkdir, cstring(path), a(mode)) : int6
 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)}
+const getdents	= {fd, buf;		-> (syscall(Sysgetdents, a(fd), a(buf), a(buf.len)) : int64)}
 
 /* signals */
 const sigaction	= {sig, act, oact;	-> (syscall(Syssigaction, a(sig), a(act), a(oact)) : int)}
diff --git a/support/syscall-gen/specials+openbsd:6.2-x64.frag b/support/syscall-gen/specials+openbsd:6.2-x64.frag
new file mode 100644
index 0000000..4cc3843
--- /dev/null
+++ b/support/syscall-gen/specials+openbsd:6.2-x64.frag
@@ -0,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(fd), 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
+	;;
+}
+
diff --git a/support/syscall-gen/syscalls+openbsd:6.2.master b/support/syscall-gen/syscalls+openbsd:6.2.master
new file mode 100644
index 0000000..d3ef28a
--- /dev/null
+++ b/support/syscall-gen/syscalls+openbsd:6.2.master
@@ -0,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); }
diff --git a/support/syscall-gen/types+openbsd:6.1-x64.frag b/support/syscall-gen/types+openbsd:6.1-x64.frag
index 4585149..48b8f5b 100644
--- a/support/syscall-gen/types+openbsd:6.1-x64.frag
+++ b/support/syscall-gen/types+openbsd:6.1-x64.frag
@@ -47,7 +47,6 @@ type timeval = struct
 	usec	: uint64
 ;;
 
-
 type pollfd = struct
 	fd      : fd
 	events  : uint16
diff --git a/support/syscall-gen/types+openbsd:6.2-x64.frag b/support/syscall-gen/types+openbsd:6.2-x64.frag
new file mode 100644
index 0000000..0d28f2e
--- /dev/null
+++ b/support/syscall-gen/types+openbsd:6.2-x64.frag
@@ -0,0 +1,477 @@
+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
+ype signo	= int32
+type sigflags	= int32
+type sigset	= uint32
+type msg	= void
+
+const Futexwait		: int = 1
+const Futexwake		: int = 2
+const Futexrequeue	: int = 3
+
+
+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##