shithub: mc

Download patch

ref: 727d551a71f7046d7e688369021282922e62f9f7
parent: c5c9df2188a6332b1c637ff56a157c881a981ff8
author: Ori Bernstein <[email protected]>
date: Thu Aug 21 20:07:21 EDT 2014

Wrap up syscall args in trivial 'a()' function.

    This shouldn't even cost performance once we have an inliner...

--- a/libstd/sys-linux.myr
+++ b/libstd/sys-linux.myr
@@ -599,16 +599,24 @@
 	const uname 	: (buf : utsname# -> int)
 ;;
 
+/* 
+wraps a syscall argument, converting it to 64 bits for the syscall function. This is
+effectively the same as casting all the args, but shorter than writing castto(int64)
+*/
+generic a = {x : @t
+	-> x castto(uint64)
+}
+
 extern const cstring	: (str : byte[:] -> byte#)
 extern const alloca	: (sz : size	-> byte#)
 extern const __cenvp : byte##
 
 /* process management */
-const exit	= {status;		syscall(Sysexit, status castto(int64))}
-const getpid	= {;			-> syscall(Sysgetpid, 1)}
-const kill	= {pid, sig;		-> syscall(Syskill, pid, sig)}
+const exit	= {status;		syscall(Sysexit, a(status))}
+const getpid	= {;			-> syscall(Sysgetpid)}
+const kill	= {pid, sig;		-> syscall(Syskill, a(pid), a(sig))}
 const fork	= {;			-> syscall(Sysfork)}
-const wait4	= {pid, loc, opt, usage;	-> syscall(Syswait4, pid, loc, opt, usage)}
+const wait4	= {pid, loc, opt, usage;	-> syscall(Syswait4, a(pid), a(loc), a(opt), a(usage))}
 const waitpid	= {pid, loc, opt;
 	var rusage
 	-> wait4(pid, loc, opt, &rusage)
@@ -625,7 +633,7 @@
 		cargs[i] = cstring(args[i])
 	;;
 	cargs[args.len] = 0 castto(byte#)
-	-> syscall(Sysexecve, cstring(cmd), p, __cenvp)
+	-> syscall(Sysexecve, cstring(cmd), a(p), a(__cenvp))
 }
 
 const execve	= {cmd, args, env
@@ -652,20 +660,20 @@
 	;;
 	cenv[env.len] = 0 castto(byte#)
 
-	-> syscall(Sysexecve, cstring(cmd), p, cenv)
+	-> syscall(Sysexecve, cstring(cmd), a(p), a(cenv))
 }
 
 /* file manipulation */
-const open	= {path, opts;		-> syscall(Sysopen, cstring(path), opts, 0o777) castto(fd)}
-const openmode	= {path, opts, mode;	-> syscall(Sysopen, cstring(path), opts, mode) castto(fd)}
-const close	= {fd;			-> syscall(Sysclose, fd castto(uint64))}
-const creat	= {path, mode;		-> syscall(Syscreat, cstring(path), mode) castto(fd)}
-const read	= {fd, buf;		-> syscall(Sysread, fd castto(uint64), buf castto(byte#), buf.len castto(uint64)) castto(size)}
-const write	= {fd, buf;		-> syscall(Syswrite, fd castto(uint64), buf castto(byte#), buf.len castto(uint64)) castto(size)}
-const lseek	= {fd, off, whence;	-> syscall(Syslseek, fd castto(uint64), off, whence)}
-const stat	= {path, sb;		-> syscall(Sysstat, cstring(path), sb)}
-const fstat	= {fd, sb;		-> syscall(Sysfstat, fd castto(uint64), sb)}
-const mkdir	= {path, mode;		-> syscall(Sysmkdir, cstring(path), mode) castto(int64)}
+const open	= {path, opts;		-> syscall(Sysopen, cstring(path), a(opts), a(0o777)) castto(fd)}
+const openmode	= {path, opts, mode;	-> syscall(Sysopen, cstring(path), a(opts), a(mode)) castto(fd)}
+const close	= {fd;			-> syscall(Sysclose, a(fd))}
+const creat	= {path, mode;		-> syscall(Syscreat, cstring(path), a(mode)) castto(fd)}
+const read	= {fd, buf;		-> syscall(Sysread, a(fd), buf castto(byte#), a(buf.len)) castto(size)}
+const write	= {fd, buf;		-> syscall(Syswrite, a(fd), buf castto(byte#), a(buf.len)) castto(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 fstat	= {fd, sb;		-> syscall(Sysfstat, a(fd), a(sb))}
+const mkdir	= {path, mode;		-> syscall(Sysmkdir, cstring(path), a(mode)) castto(int64)}
 const ioctl	= {fd, req, args
 	var arg : byte#
 	var ap
@@ -672,36 +680,40 @@
 
 	ap = vastart(&args)
 	(arg, ap) = vanext(ap)
-	-> syscall(Sysioctl, fd castto(uint64), req, arg) castto(int64)
+	-> syscall(Sysioctl, a(fd), a(req), a(arg)) castto(int64)
 }
-const getdents64	= {fd, buf;	-> syscall(Sysgetdents64, fd castto(uint64), buf castto(byte#), buf.len)}
+const getdents64	= {fd, buf;	-> syscall(Sysgetdents64, a(fd), buf castto(byte#), a(buf.len))}
 
 /* file stuff */
 const pipe	= {fds;	-> syscall(Syspipe, fds castto(fd#))}
-const dup 	= {fd;	-> syscall(Sysdup, fd castto(uint64)) castto(fd)}
-const dup2 	= {src, dst;	-> syscall(Sysdup2, src castto(uint64), dst castto(uint64)) castto(fd)}
+const dup 	= {fd;	-> syscall(Sysdup, a(fd)) castto(fd)}
+const dup2 	= {src, dst;	-> syscall(Sysdup2, a(src), a(dst)) castto(fd)}
 
 /* epoll */
-const epollcreate	= {flg;	-> syscall(Sysepoll_create1, flg castto(uint64)) castto(fd)}
-const epollctl	= {epfd, op, fd, evt;	-> syscall(Sysepoll_ctl, epfd castto(uint64), op castto(uint64), fd castto(uint64), evt castto(uint64)) castto(int)}
-const epollwait	= {epfd, evts, timeout;	-> syscall(Sysepoll_wait, epfd castto(uint64), evts castto(epollevt#), evts.len castto(uint64), timeout castto(uint64)) castto(int)}
-const poll	= {pfd, timeout;	-> syscall(Syspoll, pfd castto(pollfd#), pfd.len castto(uint64), timeout castto(uint64)) castto(int)}
+const poll	= {pfd, timeout;	-> syscall(Syspoll, pfd castto(pollfd#), a(pfd.len), a(timeout)) castto(int)}
+const epollctl	= {epfd, op, fd, evt;
+	-> syscall(Sysepoll_ctl, a(epfd), a(op), a(fd), a(evt)) castto(int)}
+const epollwait	= {epfd, evts, timeout;
+	-> syscall(Sysepoll_wait, a(epfd), evts castto(epollevt#), a(evts.len), a(timeout)) castto(int)}
+const epollcreate	= {flg;	-> syscall(Sysepoll_create1, a(flg)) castto(fd)}
 
 /* networking */
-const socket	= {dom, stype, proto;	-> syscall(Syssocket, dom castto(int64), stype, proto) castto(fd)}
-const connect	= {sock, addr, len;	-> syscall(Sysconnect, sock, addr, len) castto(int)}
-const bind	= {sock, addr, len;	-> syscall(Sysbind, sock, addr, len) castto(int)}
-const listen	= {sock, backlog;	-> syscall(Syslisten, sock, backlog castto(int64)) castto(int)}
-const accept	= {sock, addr, lenp;	-> syscall(Sysaccept, sock, addr, lenp) castto(fd)}
+const socket	= {dom, stype, proto;	-> syscall(Syssocket, a(dom), a(stype), a(proto)) castto(fd)}
+const connect	= {sock, addr, len;	-> syscall(Sysconnect, a(sock), a(addr), a(len)) castto(int)}
+const bind	= {sock, addr, len;	-> syscall(Sysbind, a(sock), a(addr), a(len)) castto(int)}
+const listen	= {sock, backlog;	-> syscall(Syslisten, a(sock), a(backlog)) castto(int)}
+const accept	= {sock, addr, lenp;	-> syscall(Sysaccept, a(sock), a(addr), a(lenp)) castto(fd)}
 
 /* memory mapping */
-const munmap	= {addr, len;		-> syscall(Sysmunmap, addr, len)}
-const mmap	= {addr, len, prot, flags, fd, off;	-> syscall(Sysmmap, addr, len, prot, flags, fd castto(uint64), off) castto(byte#)}
+const munmap	= {addr, len;		-> syscall(Sysmunmap, a(addr), a(len))}
+const mmap	= {addr, len, prot, flags, fd, off;
+	-> syscall(Sysmmap, a(addr), a(len), a(prot), a(flags), a(fd), a(off)) castto(byte#)
+}
 
 /* time */
-const clock_getres = {clk, ts;	-> syscall(Sysclock_getres, clockid(clk), ts) castto(int32)}
-const clock_gettime = {clk, ts;	-> syscall(Sysclock_gettime, clockid(clk), ts) castto(int32)}
-const clock_settime = {clk, ts;	-> syscall(Sysclock_settime, clockid(clk), ts) castto(int32)}
+const clock_getres = {clk, ts;	-> syscall(Sysclock_getres, clockid(clk), a(ts)) castto(int32)}
+const clock_gettime = {clk, ts;	-> syscall(Sysclock_gettime, clockid(clk), a(ts)) castto(int32)}
+const clock_settime = {clk, ts;	-> syscall(Sysclock_settime, clockid(clk), a(ts)) castto(int32)}
 
 const sleep = {time
 	var req, rem
@@ -709,9 +721,7 @@
 	-> nanosleep(&req, &rem)
 }
 
-const nanosleep	= {req, rem;
-	-> syscall(Sysnanosleep, req, rem) castto(int32)
-}
+const nanosleep	= {req, rem;	-> syscall(Sysnanosleep, a(req), a(rem)) castto(int32)}
 
 /* system information */
 const uname	= {buf;	-> syscall(Sysuname, buf) castto(int)}