kernel: apply uintptr for ulong when a pointer is stored

this change is in preparation for amd64. the systab calling
convention was also changed to return uintptr (as segattach
returns a pointer) and the arguments are now passed as
va_list which handles amd64 arguments properly (all arguments
are passed in 64bit quantities on the stack, tho the upper
part will not be initialized when the element is smaller
than 8 bytes).

this is partial. xalloc needs to be converted in the future.

34 files changed, 660 insertions, 556 deletions

diff --git a/sys/src/9/alphapc/mmu.c b/sys/src/9/alphapc/mmu.c
index 05ff63a5e..c15d176d7 100644
--- a/sys/src/9/alphapc/mmu.c
+++ b/sys/src/9/alphapc/mmu.c
@@ -274,7 +274,7 @@ upafree(ulong, int)
 }
 
 void
-checkmmu(ulong, ulong)
+checkmmu(uintptr, uintptr)
 {
 }
 
diff --git a/sys/src/9/alphapc/trap.c b/sys/src/9/alphapc/trap.c
index 70317bb0c..0861abbce 100644
--- a/sys/src/9/alphapc/trap.c
+++ b/sys/src/9/alphapc/trap.c
@@ -728,7 +728,7 @@ syscall(Ureg *aur)
 
 		up->s = *((Sargs*)(sp+2*BY2WD));
 		up->psstate = sysctab[scallnr];
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -794,8 +794,8 @@ kprocchild(Proc *p, void (*func)(void*), void *arg)
 	p->kparg = arg;
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	Ureg *ur;
 	ulong *sp;
@@ -809,7 +809,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
 	return USTKTOP-BY2WD;			/* address of user-level clock */
 }
 
-ulong
+uintptr
 userpc(void)
 {
 	Ureg *ur;
@@ -842,7 +842,7 @@ setkernur(Ureg *xp, Proc *p)
 	xp->r26 = (ulong)sched;
 }
 
-ulong
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ur;
diff --git a/sys/src/9/bitsy/mmu.c b/sys/src/9/bitsy/mmu.c
index ba89a6b13..8e1a46315 100644
--- a/sys/src/9/bitsy/mmu.c
+++ b/sys/src/9/bitsy/mmu.c
@@ -523,7 +523,7 @@ peekmmu(ulong va)
 }
 
 void
-checkmmu(ulong, ulong)
+checkmmu(uintptr, uintptr)
 {
 }
 
diff --git a/sys/src/9/bitsy/trap.c b/sys/src/9/bitsy/trap.c
index 60df33d31..d71d96664 100644
--- a/sys/src/9/bitsy/trap.c
+++ b/sys/src/9/bitsy/trap.c
@@ -557,7 +557,7 @@ syscall(Ureg* ureg)
 		up->s = *((Sargs*)(sp+BY2WD));
 		up->psstate = sysctab[scallnr];
 
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -757,7 +757,7 @@ setkernur(Ureg *ureg, Proc *p)
 /*
  *  return the userpc the last exception happened at
  */
-ulong
+uintptr
 userpc(void)
 {
 	Ureg *ureg;
@@ -829,8 +829,8 @@ forkchild(Proc *p, Ureg *ureg)
 /*
  *  setup stack, initial PC, and any arch dependent regs for an execing user proc.
  */
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
@@ -901,7 +901,7 @@ dumpstack(void)
 /*
  *  pc output by ps
  */
-ulong
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ureg;
diff --git a/sys/src/9/boot/boot.c b/sys/src/9/boot/boot.c
index 5ec3118fb..96ea7fc26 100644
--- a/sys/src/9/boot/boot.c
+++ b/sys/src/9/boot/boot.c
@@ -30,7 +30,7 @@ boot(int argc, char *argv[])
 
 		print("argc=%d\n", argc);
 		for(i = 0; i < argc; i++)
-			print("%lux %s ", (ulong)argv[i], argv[i]);
+			print("%p %s ", argv[i], argv[i]);
 		print("\n");
 	}
 	USED(argc);
diff --git a/sys/src/9/kw/syscall.c b/sys/src/9/kw/syscall.c
index 7cf9e20c7..fc148dee9 100644
--- a/sys/src/9/kw/syscall.c
+++ b/sys/src/9/kw/syscall.c
@@ -224,7 +224,7 @@ syscall(Ureg* ureg)
 
 	/*	iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
 
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -275,8 +275,8 @@ syscall(Ureg* ureg)
 	kexit(ureg);
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
diff --git a/sys/src/9/mtx/mmu.c b/sys/src/9/mtx/mmu.c
index 6d14aaa1c..6332272ca 100644
--- a/sys/src/9/mtx/mmu.c
+++ b/sys/src/9/mtx/mmu.c
@@ -235,7 +235,7 @@ putmmu(ulong va, ulong pa, Page *pg)
 }
 
 void
-checkmmu(ulong, ulong)
+checkmmu(uintptr, uintptr)
 {
 }
 
diff --git a/sys/src/9/mtx/trap.c b/sys/src/9/mtx/trap.c
index 2d81677f9..d0a16225f 100644
--- a/sys/src/9/mtx/trap.c
+++ b/sys/src/9/mtx/trap.c
@@ -533,8 +533,8 @@ evenaddr(ulong addr)
 	}
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
@@ -566,7 +566,7 @@ forkchild(Proc *p, Ureg *ur)
 	p->insyscall = 0;
 }
 
-ulong
+uintptr
 userpc(void)
 {
 	Ureg *ureg;
@@ -600,7 +600,7 @@ setkernur(Ureg* ureg, Proc* p)
 	ureg->sp = p->sched.sp+4;
 }
 
-ulong
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ureg;
diff --git a/sys/src/9/omap/syscall.c b/sys/src/9/omap/syscall.c
index 378a08a21..0a3916690 100644
--- a/sys/src/9/omap/syscall.c
+++ b/sys/src/9/omap/syscall.c
@@ -222,7 +222,7 @@ syscall(Ureg* ureg)
 
 	/*	iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
 
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -271,8 +271,9 @@ syscall(Ureg* ureg)
 	kexit(ureg);
 }
 
-long	/* void* */
-execregs(ulong entry, ulong ssize, ulong nargs)
+
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
diff --git a/sys/src/9/omap4/arch.c b/sys/src/9/omap4/arch.c
index b08753039..cfecb1ddb 100644
--- a/sys/src/9/omap4/arch.c
+++ b/sys/src/9/omap4/arch.c
@@ -11,13 +11,13 @@
 
 void (*proctrace)(Proc *, int, vlong);
 
-ulong
+uintptr
 userpc(void)
 {
 	return dbgpc(up);
 }
 
-ulong
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ureg;
@@ -101,8 +101,8 @@ forkchild(Proc *p, Ureg *ureg)
 	p->insyscall = 0;
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
diff --git a/sys/src/9/pc/dat.h b/sys/src/9/pc/dat.h
index 8ba2d018e..a4544debf 100644
--- a/sys/src/9/pc/dat.h
+++ b/sys/src/9/pc/dat.h
@@ -38,7 +38,7 @@ struct Lock
 {
 	ulong	key;
 	ulong	sr;
-	ulong	pc;
+	uintptr	pc;
 	Proc	*p;
 	Mach	*m;
 	ushort	isilock;
diff --git a/sys/src/9/pc/mmu.c b/sys/src/9/pc/mmu.c
index 8ee3f96ce..ca5046133 100644
--- a/sys/src/9/pc/mmu.c
+++ b/sys/src/9/pc/mmu.c
@@ -475,14 +475,14 @@ putmmu(ulong va, ulong pa, Page*)
  * Error checking only.
  */
 void
-checkmmu(ulong va, ulong pa)
+checkmmu(uintptr va, uintptr pa)
 {
 	if(up->mmupdb == 0)
 		return;
 	if(!(vpd[PDX(va)]&PTEVALID) || !(vpt[VPTX(va)]&PTEVALID))
 		return;
 	if(PPN(vpt[VPTX(va)]) != pa)
-		print("%ld %s: va=%#08lux pa=%#08lux pte=%#08lux\n",
+		print("%ld %s: va=%#p pa=%#p pte=%#08lux\n",
 			up->pid, up->text,
 			va, pa, vpt[VPTX(va)]);
 }
diff --git a/sys/src/9/pc/trap.c b/sys/src/9/pc/trap.c
index 867767198..c8a43bbb5 100644
--- a/sys/src/9/pc/trap.c
+++ b/sys/src/9/pc/trap.c
@@ -760,8 +760,7 @@ syscall(Ureg* ureg)
 			error(Ebadarg);
 		}
 		up->psstate = sysctab[scallnr];
-
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -975,8 +974,8 @@ if(0) print("%s %lud: noted %.8lux %.8lux\n",
 	}
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
@@ -996,7 +995,7 @@ execregs(ulong entry, ulong ssize, ulong nargs)
 /*
  *  return the userpc the last exception happened at
  */
-ulong
+uintptr
 userpc(void)
 {
 	Ureg *ureg;
diff --git a/sys/src/9/port/allocb.c b/sys/src/9/port/allocb.c
index 97176d76d..60d538325 100644
--- a/sys/src/9/port/allocb.c
+++ b/sys/src/9/port/allocb.c
@@ -21,7 +21,7 @@ static Block*
 _allocb(int size)
 {
 	Block *b;
-	ulong addr;
+	uintptr addr;
 
 	if((b = mallocz(sizeof(Block)+size+Hdrspc, 0)) == nil)
 		return nil;
@@ -34,13 +34,13 @@ _allocb(int size)
 	_xinc(&b->ref);
 
 	/* align start of data portion by rounding up */
-	addr = (ulong)b;
+	addr = (uintptr)b;
 	addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
 	b->base = (uchar*)addr;
 
 	/* align end of data portion by rounding down */
 	b->lim = ((uchar*)b) + msize(b);
-	addr = (ulong)(b->lim);
+	addr = (uintptr)(b->lim);
 	addr = addr & ~(BLOCKALIGN-1);
 	b->lim = (uchar*)addr;
 
diff --git a/sys/src/9/port/auth.c b/sys/src/9/port/auth.c
index 2c8e8a34d..04b96a57d 100644
--- a/sys/src/9/port/auth.c
+++ b/sys/src/9/port/auth.c
@@ -19,59 +19,68 @@ iseve(void)
 	return strcmp(eve, up->user) == 0;
 }
 
-long
-sysfversion(ulong *arg)
+uintptr
+sysfversion(va_list list)
 {
+	uint msize, arglen;
 	char *vers;
-	uint arglen, m, msize;
 	Chan *c;
+	int fd;
 
-	msize = arg[1];
-	vers = (char*)arg[2];
-	arglen = arg[3];
-	validaddr(arg[2], arglen, 1);
+	fd = va_arg(list, int);
+	msize = va_arg(list, uint);
+	vers = va_arg(list, char*);
+	arglen = va_arg(list, uint);
+	validaddr((uintptr)vers, arglen, 1);
 	/* check there's a NUL in the version string */
 	if(arglen==0 || memchr(vers, 0, arglen)==0)
 		error(Ebadarg);
-	c = fdtochan(arg[0], ORDWR, 0, 1);
+	c = fdtochan(fd, ORDWR, 0, 1);
 	if(waserror()){
 		cclose(c);
 		nexterror();
 	}
-
-	m = mntversion(c, vers, msize, arglen);
-
+	msize = mntversion(c, vers, msize, arglen);
 	cclose(c);
 	poperror();
-	return m;
+	return msize;
 }
 
-long
-sys_fsession(ulong *arg)
+uintptr
+sys_fsession(va_list list)
 {
-	/* deprecated; backwards compatibility only */
+	int fd;
+	char *str;
+	uint len;
 
-	if(arg[2] == 0)
+	/* deprecated; backwards compatibility only */
+	fd = va_arg(list, int);
+	str = va_arg(list, char*);
+	len = va_arg(list, uint);
+	if(len == 0)
 		error(Ebadarg);
-	validaddr(arg[1], arg[2], 1);
-	((uchar*)arg[1])[0] = '\0';
+	validaddr((uintptr)str, len, 1);
+	*str = '\0';
+	USED(fd);
 	return 0;
 }
 
-long
-sysfauth(ulong *arg)
+uintptr
+sysfauth(va_list list)
 {
 	Chan *c, *ac;
 	char *aname;
 	int fd;
 
-	validaddr(arg[1], 1, 0);
-	aname = validnamedup((char*)arg[1], 1);
+	fd = va_arg(list, int);
+	aname = va_arg(list, char*);
+	validaddr((uintptr)aname, 1, 0);
+	aname = validnamedup(aname, 1);
 	if(waserror()){
 		free(aname);
 		nexterror();
 	}
-	c = fdtochan(arg[0], ORDWR, 0, 1);
+	c = fdtochan(fd, ORDWR, 0, 1);
 	if(waserror()){
 		cclose(c);
 		nexterror();
@@ -96,8 +105,7 @@ sysfauth(ulong *arg)
 
 	/* always mark it close on exec */
 	ac->flag |= CCEXEC;
-
-	return fd;
+	return (uintptr)fd;
 }
 
 /*
diff --git a/sys/src/9/port/chan.c b/sys/src/9/port/chan.c
index c74fb5d51..7f91578e6 100644
--- a/sys/src/9/port/chan.c
+++ b/sys/src/9/port/chan.c
@@ -1721,14 +1721,14 @@ char isfrog[256]={
  * to access unchecked addresses.) 
  */
 static char*
-validname0(char *aname, int slashok, int dup, ulong pc)
+validname0(char *aname, int slashok, int dup, uintptr pc)
 {
 	char *ename, *name, *s;
 	int c, n;
 	Rune r;
 
 	name = aname;
-	if((ulong)name < KZERO){
+	if((uintptr)name < KZERO){
 		if(!dup)
 			print("warning: validname called from %#p with user pointer", pc);
 		ename = vmemchr(name, 0, (1<<16));
diff --git a/sys/src/9/port/devkprof.c b/sys/src/9/port/devkprof.c
index 85ca17a58..c6d73a74e 100644
--- a/sys/src/9/port/devkprof.c
+++ b/sys/src/9/port/devkprof.c
@@ -11,8 +11,8 @@
 
 struct
 {
-	int	minpc;
-	int	maxpc;
+	uintptr	minpc;
+	uintptr	maxpc;
 	int	nbuf;
 	int	time;
 	ulong	*buf;
@@ -30,7 +30,7 @@ Dirtab kproftab[]={
 };
 
 static void
-_kproftimer(ulong pc)
+_kproftimer(uintptr pc)
 {
 	extern void spldone(void);
 
@@ -40,7 +40,7 @@ _kproftimer(ulong pc)
 	 *  if the pc is coming out of spllo or splx,
 	 *  use the pc saved when we went splhi.
 	 */
-	if(pc>=(ulong)spllo && pc<=(ulong)spldone)
+	if(pc>=(uintptr)spllo && pc<=(uintptr)spldone)
 		pc = m->splpc;
 
 	kprof.buf[0] += TK2MS(1);
@@ -67,7 +67,7 @@ kprofattach(char *spec)
 
 	/* allocate when first used */
 	kprof.minpc = KTZERO;
-	kprof.maxpc = (ulong)etext;
+	kprof.maxpc = (uintptr)etext;
 	kprof.nbuf = (kprof.maxpc-kprof.minpc) >> LRES;
 	n = kprof.nbuf*SZ;
 	if(kprof.buf == 0) {
diff --git a/sys/src/9/port/devproc.c b/sys/src/9/port/devproc.c
index 2207a627a..57ebebb1a 100644
--- a/sys/src/9/port/devproc.c
+++ b/sys/src/9/port/devproc.c
@@ -152,7 +152,7 @@ static char *sname[]={ "Text", "Data", "Bss", "Stack", "Shared", "Phys", };
 #define	NOTEID(q)	((q).vers)
 
 void	procctlreq(Proc*, char*, int);
-int	procctlmemio(Proc*, ulong, int, void*, int);
+int	procctlmemio(Proc*, uintptr, int, void*, int);
 Chan*	proctext(Chan*, Proc*);
 Segment* txt2data(Proc*, Segment*);
 int	procstopped(void*);
@@ -699,7 +699,7 @@ procread(Chan *c, void *va, long n, vlong off)
 	int i, j, m, navail, ne, rsize;
 	long l;
 	uchar *rptr;
-	ulong offset;
+	uintptr offset;
 	Confmem *cm;
 	Mntwalk *mw;
 	Proc *p;
@@ -766,9 +766,9 @@ procread(Chan *c, void *va, long n, vlong off)
 			error(Eperm);
 
 		/* validate kernel addresses */
-		if(offset < (ulong)end) {
-			if(offset+n > (ulong)end)
-				n = (ulong)end - offset;
+		if(offset < (uintptr)end) {
+			if(offset+n > (uintptr)end)
+				n = (uintptr)end - offset;
 			memmove(a, (char*)offset, n);
 			return n;
 		}
@@ -910,7 +910,7 @@ procread(Chan *c, void *va, long n, vlong off)
 			sg = p->seg[i];
 			if(sg == 0)
 				continue;
-			j += sprint(statbuf+j, "%-6s %c%c %.8lux %.8lux %4ld\n",
+			j += sprint(statbuf+j, "%-6s %c%c %p %p %4ld\n",
 				sname[sg->type&SG_TYPE],
 				sg->type&SG_RONLY ? 'R' : ' ',
 				sg->profile ? 'P' : ' ',
@@ -1533,13 +1533,13 @@ procstopped(void *a)
 }
 
 int
-procctlmemio(Proc *p, ulong offset, int n, void *va, int read)
+procctlmemio(Proc *p, uintptr offset, int n, void *va, int read)
 {
 	KMap *k;
 	Pte *pte;
 	Page *pg;
 	Segment *s;
-	ulong soff, l;
+	uintptr soff, l;
 	char *a = va, *b;
 
 	for(;;) {
diff --git a/sys/src/9/port/fault.c b/sys/src/9/port/fault.c
index b7fc8e9f2..828175202 100644
--- a/sys/src/9/port/fault.c
+++ b/sys/src/9/port/fault.c
@@ -6,7 +6,7 @@
 #include	"../port/error.h"
 
 int
-fault(ulong addr, int read)
+fault(uintptr addr, int read)
 {
 	Segment *s;
 	char *sps;
@@ -70,18 +70,19 @@ faulterror(char *s, Chan *c, int freemem)
 	pexit(s, freemem);
 }
 
-void	(*checkaddr)(ulong, Segment *, Page *);
-ulong	addr2check;
+void	(*checkaddr)(uintptr, Segment *, Page *);
+uintptr	addr2check;
 
 int
-fixfault(Segment *s, ulong addr, int read, int doputmmu)
+fixfault(Segment *s, uintptr addr, int read, int doputmmu)
 {
 	int type;
 	int ref;
 	Pte **p, *etp;
-	ulong mmuphys=0, soff;
+	ulong mmuphys=0;
+	uintptr soff;
 	Page **pg, *lkp, *new;
-	Page *(*fn)(Segment*, ulong);
+	Page *(*fn)(Segment*, uintptr);
 
 	addr &= ~(BY2PG-1);
 	soff = addr-s->base;
@@ -198,14 +199,14 @@ fixfault(Segment *s, ulong addr, int read, int doputmmu)
 }
 
 void
-pio(Segment *s, ulong addr, ulong soff, Page **p)
+pio(Segment *s, uintptr addr, uintptr soff, Page **p)
 {
 	Page *new;
 	KMap *k;
 	Chan *c;
 	int n, ask;
 	char *kaddr;
-	ulong daddr;
+	uintptr daddr;
 	Page *loadrec;
 
 retry:
@@ -310,7 +311,7 @@ done:
  * Called only in a system call
  */
 int
-okaddr(ulong addr, ulong len, int write)
+okaddr(uintptr addr, ulong len, int write)
 {
 	Segment *s;
 
@@ -332,10 +333,10 @@ okaddr(ulong addr, ulong len, int write)
 }
 
 void
-validaddr(ulong addr, ulong len, int write)
+validaddr(uintptr addr, ulong len, int write)
 {
 	if(!okaddr(addr, len, write)){
-		pprint("suicide: invalid address %#lux/%lud in sys call pc=%#lux\n", addr, len, userpc());
+		pprint("suicide: invalid address %#p/%lud in sys call pc=%#p\n", addr, len, userpc());
 		postnote(up, 1, "sys: bad address in syscall", NDebug);
 		error(Ebadarg);
 	}
@@ -348,10 +349,10 @@ void*
 vmemchr(void *s, int c, int n)
 {
 	int m;
-	ulong a;
+	uintptr a;
 	void *t;
 
-	a = (ulong)s;
+	a = (uintptr)s;
 	while(PGROUND(a) != PGROUND(a+n-1)){
 		/* spans pages; handle this page */
 		m = BY2PG - (a & (BY2PG-1));
@@ -369,7 +370,7 @@ vmemchr(void *s, int c, int n)
 }
 
 Segment*
-seg(Proc *p, ulong addr, int dolock)
+seg(Proc *p, uintptr addr, int dolock)
 {
 	Segment **s, **et, *n;
 
@@ -392,12 +393,13 @@ seg(Proc *p, ulong addr, int dolock)
 	return 0;
 }
 
-extern void checkmmu(ulong, ulong);
+extern void checkmmu(uintptr, uintptr);
+
 void
 checkpages(void)
 {
 	int checked;
-	ulong addr, off;
+	uintptr addr, off;
 	Pte *p;
 	Page *pg;
 	Segment **sp, **ep, *s;
diff --git a/sys/src/9/port/mksystab b/sys/src/9/port/mksystab
index 71975c118..93831211e 100755
--- a/sys/src/9/port/mksystab
+++ b/sys/src/9/port/mksystab
@@ -5,7 +5,7 @@ file=/sys/src/libc/9syscall/sys.h
 cat <<'!'
 #include "/sys/src/libc/9syscall/sys.h"
 
-typedef long Syscall(ulong*);
+typedef uintptr Syscall(va_list);
 
 !
 
diff --git a/sys/src/9/port/page.c b/sys/src/9/port/page.c
index f9eda93f7..d76fc4038 100644
--- a/sys/src/9/port/page.c
+++ b/sys/src/9/port/page.c
@@ -118,7 +118,7 @@ pagechainhead(Page *p)
 }
 
 Page*
-newpage(int clear, Segment **s, ulong va)
+newpage(int clear, Segment **s, uintptr va)
 {
 	Page *p;
 	KMap *k;
@@ -409,7 +409,7 @@ cachepage(Page *p, Image *i)
 }
 
 void
-cachedel(Image *i, ulong daddr)
+cachedel(Image *i, uintptr daddr)
 {
 	Page *f;
 
@@ -434,7 +434,7 @@ retry:
 }
 
 Page *
-lookpage(Image *i, ulong daddr)
+lookpage(Image *i, uintptr daddr)
 {
 	Page *f;
 
@@ -574,7 +574,7 @@ checkpagerefs(void)
 	nwrong = 0;
 	for(i=0; i<np; i++){
 		if(palloc.pages[i].ref != ref[i]){
-			iprint("page %#.8lux ref %d actual %lud\n", 
+			iprint("page %#p ref %d actual %lud\n", 
 				palloc.pages[i].pa, palloc.pages[i].ref, ref[i]);
 			ref[i] = 1;
 			nwrong++;
@@ -627,7 +627,7 @@ portcountpagerefs(ulong *ref, int print)
 						continue;
 					if(print){
 						if(ref[pagenumber(entry)])
-							iprint("page %#.8lux in segment %#p\n", entry->pa, s);
+							iprint("page %#p in segment %#p\n", entry->pa, s);
 						continue;
 					}
 					if(ref[pagenumber(entry)]++ == 0)
diff --git a/sys/src/9/port/portdat.h b/sys/src/9/port/portdat.h
index 4edd4e732..062a6ac56 100644
--- a/sys/src/9/port/portdat.h
+++ b/sys/src/9/port/portdat.h
@@ -83,7 +83,7 @@ struct RWlock
 	Lock	use;
 	Proc	*head;		/* list of waiting processes */
 	Proc	*tail;
-	ulong	wpc;		/* pc of writer */
+	uintptr	wpc;		/* pc of writer */
 	Proc	*wproc;		/* writing proc */
 	int	readers;	/* number of readers */
 	int	writer;		/* number of writers */
@@ -97,7 +97,7 @@ struct Alarms
 
 struct Sargs
 {
-	ulong	args[MAXSYSARG];
+	uchar	args[MAXSYSARG*BY2WD];
 };
 
 /*
@@ -313,9 +313,9 @@ enum
 struct Page
 {
 	Lock;
-	ulong	pa;			/* Physical address in memory */
-	ulong	va;			/* Virtual address for user */
-	ulong	daddr;			/* Disc address on swap */
+	uintptr	pa;			/* Physical address in memory */
+	uintptr	va;			/* Virtual address for user */
+	uintptr	daddr;			/* Disc address on swap */
 	ulong	gen;			/* Generation counter for swap */
 	ushort	ref;			/* Reference count */
 	char	modref;			/* Simulated modify/reference bits */
@@ -378,9 +378,9 @@ enum
 };
 
 #define PG_ONSWAP	1
-#define onswap(s)	(((ulong)s)&PG_ONSWAP)
-#define pagedout(s)	(((ulong)s)==0 || onswap(s))
-#define swapaddr(s)	(((ulong)s)&~PG_ONSWAP)
+#define onswap(s)	(((uintptr)s)&PG_ONSWAP)
+#define pagedout(s)	(((uintptr)s)==0 || onswap(s))
+#define swapaddr(s)	(((uintptr)s)&~PG_ONSWAP)
 
 #define SEGMAXSIZE	(SEGMAPSIZE*PTEMAPMEM)
 
@@ -388,9 +388,9 @@ struct Physseg
 {
 	ulong	attr;			/* Segment attributes */
 	char	*name;			/* Attach name */
-	ulong	pa;			/* Physical address */
+	uintptr	pa;			/* Physical address */
 	ulong	size;			/* Maximum segment size in pages */
-	Page	*(*pgalloc)(Segment*, ulong);	/* Allocation if we need it */
+	Page	*(*pgalloc)(Segment*, uintptr);	/* Allocation if we need it */
 	void	(*pgfree)(Page*);
 };
 
@@ -409,11 +409,11 @@ struct Segment
 	QLock	lk;
 	ushort	steal;		/* Page stealer lock */
 	ushort	type;		/* segment type */
-	ulong	base;		/* virtual base */
-	ulong	top;		/* virtual top */
+	uintptr	base;		/* virtual base */
+	uintptr	top;		/* virtual top */
 	ulong	size;		/* size in pages */
-	ulong	fstart;		/* start address in file for demand load */
-	ulong	flen;		/* length of segment in file */
+	uintptr	fstart;		/* start address in file for demand load */
+	uintptr	flen;		/* length of segment in file */
 	int	flushme;	/* maintain icache for this segment */
 	Image	*image;		/* text in file attached to this segment */
 	Physseg *pseg;
@@ -490,8 +490,8 @@ enum
 
 struct Pallocmem
 {
-	ulong base;
-	ulong npage;
+	uintptr	base;
+	ulong	npage;
 };
 
 struct Palloc
@@ -671,7 +671,7 @@ struct Proc
 	ulong	privatemem;	/* proc does not let anyone read mem */
 	int	hang;		/* hang at next exec for debug */
 	int	procctl;	/* Control for /proc debugging */
-	ulong	pc;		/* DEBUG only */
+	uintptr	pc;		/* DEBUG only */
 
 	Lock	rlock;		/* sync sleep/wakeup with postnote */
 	Rendez	*r;		/* rendezvous point slept on */
@@ -734,7 +734,7 @@ struct Proc
 	Edf	*edf;		/* if non-null, real-time proc, edf contains scheduling params */
 	int	trace;		/* process being traced? */
 
-	ulong	qpc;		/* pc calling last blocking qlock */
+	uintptr	qpc;		/* pc calling last blocking qlock */
 	QLock	*eql;		/* interruptable eqlock */
 
 	int	setargs;	/* process changed its args */
diff --git a/sys/src/9/port/portfns.h b/sys/src/9/port/portfns.h
index 6b27eaf2c..3cfad6b54 100644
--- a/sys/src/9/port/portfns.h
+++ b/sys/src/9/port/portfns.h
@@ -9,12 +9,12 @@ void		alarmkproc(void*);
 Block*		allocb(int);
 int		anyhigher(void);
 int		anyready(void);
-Image*		attachimage(int, Chan*, ulong, ulong);
+Image*		attachimage(int, Chan*, uintptr, ulong);
 Page*		auxpage(void);
 Block*		bl2mem(uchar*, Block*, int);
 int		blocklen(Block*);
 void		bootlinks(void);
-void		cachedel(Image*, ulong);
+void		cachedel(Image*, uintptr);
 void		cachepage(Page*, Image*);
 void		callwithureg(void(*)(Ureg*));
 char*		chanpath(Chan*);
@@ -51,7 +51,7 @@ int		cread(Chan*, uchar*, int, vlong);
 void		cunmount(Chan*, Chan*);
 void		cupdate(Chan*, uchar*, int, vlong);
 void		cwrite(Chan*, uchar*, int, vlong);
-ulong		dbgpc(Proc*);
+uintptr		dbgpc(Proc*);
 long		decref(Ref*);
 int		decrypt(void*, void*, int);
 void		delay(int);
@@ -99,17 +99,17 @@ int		eqchantdqid(Chan*, int, int, Qid, int);
 int		eqqid(Qid, Qid);
 void		error(char*);
 void		eqlock(QLock*);
-long		execregs(ulong, ulong, ulong);
+uintptr		execregs(uintptr, ulong, ulong);
 void		exhausted(char*);
 void		exit(int);
 uvlong		fastticks(uvlong*);
 uvlong		fastticks2ns(uvlong);
 uvlong		fastticks2us(uvlong);
-int		fault(ulong, int);
+int		fault(uintptr, int);
 void		fdclose(int, int);
 Chan*		fdtochan(int, int, int, int);
 int		findmount(Chan**, Mhead**, int, int, Qid);
-int		fixfault(Segment*, ulong, int, int);
+int		fixfault(Segment*, uintptr, int, int);
 void		flushmmu(void);
 void		forceclosefgrp(void);
 void		forkchild(Proc*, Ureg*);
@@ -120,8 +120,8 @@ void		freeblist(Block*);
 int		freebroken(void);
 void		freepte(Segment*, Pte*);
 void		getcolor(ulong, ulong*, ulong*, ulong*);
-ulong		getmalloctag(void*);
-ulong		getrealloctag(void*);
+uintptr		getmalloctag(void*);
+uintptr		getrealloctag(void*);
 void		gotolabel(Label*);
 char*		getconfenv(void);
 long		hostdomainwrite(char*, int);
@@ -129,7 +129,7 @@ long		hostownerwrite(char*, int);
 void		hzsched(void);
 Block*		iallocb(int);
 void		iallocsummary(void);
-long		ibrk(ulong, int);
+long		ibrk(uintptr, int);
 void		ilock(Lock*);
 void		iunlock(Lock*);
 long		incref(Ref*);
@@ -138,7 +138,7 @@ int		iprint(char*, ...);
 void		isdir(Chan*);
 int		iseve(void);
 int		islo(void);
-Segment*	isoverlap(Proc*, ulong, int);
+Segment*	isoverlap(Proc*, uintptr, int);
 int		ispages(void*);
 int		isphysseg(char*);
 void		ixsummary(void);
@@ -146,7 +146,7 @@ void		kickpager(void);
 void		killbig(char*);
 void		kproc(char*, void(*)(void*), void*);
 void		kprocchild(Proc*, void (*)(void*), void*);
-void		(*kproftimer)(ulong);
+void		(*kproftimer)(uintptr);
 void		ksetenv(char*, char*, int);
 void		kstrcpy(char*, char*, int);
 void		kstrdup(char**, char*);
@@ -158,7 +158,7 @@ void		logn(Log*, int, void*, int);
 long		logread(Log*, void*, ulong, long);
 void		log(Log*, int, char*, ...);
 Cmdtab*		lookupcmd(Cmdbuf*, Cmdtab*, int);
-Page*		lookpage(Image*, ulong);
+Page*		lookpage(Image*, uintptr);
 #define		MS2NS(n) (((vlong)(n))*1000000LL)
 void		machinit(void);
 void*		mallocz(ulong, int);
@@ -167,7 +167,7 @@ void*		mallocalign(ulong, ulong, long, ulong);
 void		mallocsummary(void);
 Block*		mem2bl(uchar*, int);
 int		mcountseg(Segment*);
-void		mfreeseg(Segment*, ulong, int);
+void		mfreeseg(Segment*, uintptr, int);
 void		microdelay(int);
 uvlong		mk64fract(uvlong, uvlong);
 void		mkqid(Qid*, vlong, ulong, int);
@@ -189,7 +189,7 @@ Chan*		newchan(void);
 int		newfd(Chan*);
 Mhead*		newmhead(Chan*);
 Mount*		newmount(Mhead*, Chan*, int, char*);
-Page*		newpage(int, Segment **, ulong);
+Page*		newpage(int, Segment **, uintptr);
 Path*		newpath(char*);
 Pgrp*		newpgrp(void);
 Rgrp*		newrgrp(void);
@@ -198,7 +198,7 @@ void		nexterror(void);
 int		notify(Ureg*);
 int		nrand(int);
 uvlong		ns2fastticks(uvlong);
-int		okaddr(ulong, ulong, int);
+int		okaddr(uintptr, ulong, int);
 int		openmode(ulong);
 Block*		packblock(Block*);
 Block*		padblock(Block*, int);
@@ -214,7 +214,7 @@ void		pexit(char*, int);
 void		pgrpcpy(Pgrp*, Pgrp*);
 void		pgrpnote(ulong, char*, long, int);
 int		pidalloc(Proc*);
-void		pio(Segment *, ulong, ulong, Page **);
+void		pio(Segment *, uintptr, uintptr, Page **);
 #define		poperror()		up->nerrlab--
 void		portcountpagerefs(ulong*, int);
 int		postnote(Proc*, int, char*, int);
@@ -287,7 +287,7 @@ void		ready(Proc*);
 void*		realloc(void *v, ulong size);
 void		rebootcmd(int, char**);
 void		reboot(void*, void*, ulong);
-void		relocateseg(Segment*, ulong);
+void		relocateseg(Segment*, uintptr);
 void		renameuser(char*, char*);
 void		resched(char*);
 void		resrcwait(char*);
@@ -302,14 +302,14 @@ void		scheddump(void);
 void		schedinit(void);
 void		(*screenputs)(char*, int);
 long		seconds(void);
-ulong		segattach(Proc*, ulong, char *, ulong, ulong);
-void		segclock(ulong);
+uintptr		segattach(Proc*, ulong, char *, uintptr, ulong);
+void		segclock(uintptr);
 void		segpage(Segment*, Page*);
 int		setcolor(ulong, ulong, ulong, ulong);
 void		setkernur(Ureg*, Proc*);
 int		setlabel(Label*);
-void		setmalloctag(void*, ulong);
-void		setrealloctag(void*, ulong);
+void		setmalloctag(void*, uintptr);
+void		setrealloctag(void*, uintptr);
 void		setregisters(Ureg*, char*, char*, int);
 void		setswapchan(Chan*);
 char*		skipslash(char*);
@@ -322,11 +322,11 @@ void		splxpc(int);
 char*		srvname(Chan*);
 void		srvrenameuser(char*, char*);
 void		shrrenameuser(char*, char*);
-int		swapcount(ulong);
+int		swapcount(uintptr);
 int		swapfull(void);
 void		swapinit(void);
-void		syscallfmt(ulong syscallno, ulong pc, va_list list);
-void		sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop);
+void		syscallfmt(ulong syscallno, uintptr pc, va_list list);
+void		sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop);
 void		timeradd(Timer*);
 void		timerdel(Timer*);
 void		timersinit(void);
@@ -356,9 +356,9 @@ long		unionread(Chan*, void*, long);
 void		unlock(Lock*);
 uvlong		us2fastticks(uvlong);
 void		userinit(void);
-ulong		userpc(void);
+uintptr		userpc(void);
 long		userwrite(char*, int);
-void		validaddr(ulong, ulong, int);
+void		validaddr(uintptr, ulong, int);
 void		validname(char*, int);
 char*		validnamedup(char*, int);
 void		validstat(uchar*, int);
@@ -378,8 +378,8 @@ void		xsummary(void);
 void		yield(void);
 Segment*	data2txt(Segment*);
 Segment*	dupseg(Segment**, int, int);
-Segment*	newseg(int, ulong, ulong);
-Segment*	seg(Proc*, ulong, int);
+Segment*	newseg(int, uintptr, ulong);
+Segment*	seg(Proc*, uintptr, int);
 void		hnputv(void*, uvlong);
 void		hnputl(void*, uint);
 void		hnputs(void*, ushort);
diff --git a/sys/src/9/port/proc.c b/sys/src/9/port/proc.c
index fd2461f5f..fdac770fa 100644
--- a/sys/src/9/port/proc.c
+++ b/sys/src/9/port/proc.c
@@ -743,7 +743,7 @@ sleep(Rendez *r, int (*f)(void*), void *arg)
 	s = splhi();
 
 	if(up->nlocks.ref)
-		print("process %lud sleeps with %lud locks held, last lock %#p locked at pc %#lux, sleep called from %#p\n",
+		print("process %lud sleeps with %lud locks held, last lock %#p locked at pc %#p, sleep called from %#p\n",
 			up->pid, up->nlocks.ref, up->lastlock, up->lastlock->pc, getcallerpc(&r));
 	lock(r);
 	lock(&up->rlock);
@@ -1283,9 +1283,10 @@ dumpaproc(Proc *p)
 	s = p->psstate;
 	if(s == 0)
 		s = statename[p->state];
-	print("%3lud:%10s pc %8lux dbgpc %8lux  %8s (%s) ut %ld st %ld bss %lux qpc %lux nl %lud nd %lud lpc %lux pri %lud\n",
+	print("%3lud:%10s pc %#p dbgpc %#p  %8s (%s) ut %ld st %ld bss %lux qpc %#p nl %lud nd %lud lpc %#p pri %lud\n",
 		p->pid, p->text, p->pc, dbgpc(p),  s, statename[p->state],
-		p->time[0], p->time[1], bss, p->qpc, p->nlocks.ref, p->delaysched, p->lastlock ? p->lastlock->pc : 0, p->priority);
+		p->time[0], p->time[1], bss, p->qpc, p->nlocks.ref, p->delaysched,
+		p->lastlock ? p->lastlock->pc : 0, p->priority);
 }
 
 void
diff --git a/sys/src/9/port/segment.c b/sys/src/9/port/segment.c
index 04923d9e7..bbc6cc6c3 100644
--- a/sys/src/9/port/segment.c
+++ b/sys/src/9/port/segment.c
@@ -47,7 +47,7 @@ initseg(void)
 }
 
 Segment *
-newseg(int type, ulong base, ulong size)
+newseg(int type, uintptr base, ulong size)
 {
 	Segment *s;
 	int mapsize;
@@ -125,7 +125,7 @@ putseg(Segment *s)
 }
 
 void
-relocateseg(Segment *s, ulong offset)
+relocateseg(Segment *s, uintptr offset)
 {
 	Page **pg, *x;
 	Pte *pte, **p, **endpte;
@@ -214,7 +214,7 @@ void
 segpage(Segment *s, Page *p)
 {
 	Pte **pte;
-	ulong off;
+	uintptr off;
 	Page **pg;
 
 	if(p->va < s->base || p->va >= s->top)
@@ -234,7 +234,7 @@ segpage(Segment *s, Page *p)
 }
 
 Image*
-attachimage(int type, Chan *c, ulong base, ulong len)
+attachimage(int type, Chan *c, uintptr base, ulong len)
 {
 	Image *i, **l;
 
@@ -392,10 +392,11 @@ putimage(Image *i)
 }
 
 long
-ibrk(ulong addr, int seg)
+ibrk(uintptr addr, int seg)
 {
 	Segment *s, *ns;
-	ulong newtop, newsize;
+	uintptr newtop;
+	ulong newsize;
 	int i, mapsize;
 	Pte **map;
 
@@ -492,10 +493,10 @@ mcountseg(Segment *s)
  *  called with s->lk locked
  */
 void
-mfreeseg(Segment *s, ulong start, int pages)
+mfreeseg(Segment *s, uintptr start, int pages)
 {
 	int i, j, size;
-	ulong soff;
+	uintptr soff;
 	Page *pg;
 	Page *list;
 
@@ -553,11 +554,11 @@ out:
 }
 
 Segment*
-isoverlap(Proc *p, ulong va, int len)
+isoverlap(Proc *p, uintptr va, int len)
 {
 	int i;
 	Segment *ns;
-	ulong newtop;
+	uintptr newtop;
 
 	newtop = va+len;
 	for(i = 0; i < NSEG; i++) {
@@ -615,8 +616,8 @@ isphysseg(char *name)
 	return rv;
 }
 
-ulong
-segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
+uintptr
+segattach(Proc *p, ulong attr, char *name, uintptr va, ulong len)
 {
 	int sno;
 	Segment *s, *os;
@@ -625,7 +626,7 @@ segattach(Proc *p, ulong attr, char *name, ulong va, ulong len)
 	if(va != 0 && va >= USTKTOP)
 		error(Ebadarg);
 
-	validaddr((ulong)name, 1, 0);
+	validaddr((uintptr)name, 1, 0);
 	vmemchr(name, 0, ~0);
 
 	for(sno = 0; sno < NSEG; sno++)
@@ -708,16 +709,17 @@ pteflush(Pte *pte, int s, int e)
 	}
 }
 
-long
-syssegflush(ulong *arg)
+uintptr
+syssegflush(va_list list)
 {
 	Segment *s;
-	ulong addr, l;
+	ulong len, l;
 	Pte *pte;
-	int chunk, ps, pe, len;
+	int chunk, ps, pe;
+	uintptr addr;
 
-	addr = arg[0];
-	len = arg[1];
+	addr = va_arg(list, uintptr);
+	len = va_arg(list, ulong);
 
 	while(len > 0) {
 		s = seg(up, addr, 1);
@@ -760,7 +762,7 @@ syssegflush(ulong *arg)
 }
 
 void
-segclock(ulong pc)
+segclock(uintptr pc)
 {
 	Segment *s;
 
diff --git a/sys/src/9/port/swap.c b/sys/src/9/port/swap.c
index 0340d566b..69d822fc6 100644
--- a/sys/src/9/port/swap.c
+++ b/sys/src/9/port/swap.c
@@ -77,7 +77,7 @@ putswap(Page *p)
 	uchar *idx;
 
 	lock(&swapalloc);
-	idx = &swapalloc.swmap[((ulong)p)/BY2PG];
+	idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
 	if(*idx == 0)
 		panic("putswap %#p ref == 0", p);
 
@@ -111,7 +111,7 @@ dupswap(Page *p)
 	uchar *idx;
 
 	lock(&swapalloc);
-	idx = &swapalloc.swmap[((ulong)p)/BY2PG];
+	idx = &swapalloc.swmap[((uintptr)p)/BY2PG];
 	if(*idx == 255)
 		swapalloc.xref++;
 	else {
@@ -122,7 +122,7 @@ dupswap(Page *p)
 }
 
 int
-swapcount(ulong daddr)
+swapcount(uintptr daddr)
 {
 	return swapalloc.swmap[daddr/BY2PG];
 }
@@ -309,7 +309,7 @@ canflush(Proc *p, Segment *s)
 static void
 pagepte(int type, Page **pg)
 {
-	ulong daddr;
+	uintptr daddr;
 	Page *outp;
 
 	outp = *pg;
diff --git a/sys/src/9/port/syscallfmt.c b/sys/src/9/port/syscallfmt.c
index 23eba4e95..3d1753b02 100644
--- a/sys/src/9/port/syscallfmt.c
+++ b/sys/src/9/port/syscallfmt.c
@@ -20,7 +20,7 @@ fmtrwdata(Fmt* f, char* a, int n, char* suffix)
 		fmtprint(f, "0x0%s", suffix);
 		return;
 	}
-	validaddr((ulong)a, n, 0);
+	validaddr((uintptr)a, n, 0);
 	t = smalloc(n+1);
 	t[n] = 0;
 	for(i = 0; i < n; i++)
@@ -43,7 +43,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
 		fmtprint(f, "0/\"\"%s", suffix);
 		return;
 	}
-	validaddr((ulong)a, 1, 0);
+	validaddr((uintptr)a, 1, 0);
 	n = ((char*)vmemchr(a, 0, 0x7fffffff) - a) + 1;
 	t = smalloc(n+1);
 	memmove(t, a, n);
@@ -53,7 +53,7 @@ fmtuserstring(Fmt* f, char* a, char* suffix)
 }
 
 void
-syscallfmt(ulong syscallno, ulong pc, va_list list)
+syscallfmt(ulong syscallno, uintptr pc, va_list list)
 {
 	long l;
 	Fmt fmt;
@@ -72,7 +72,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
 		fmtprint(&fmt, "%s ", sysctab[syscallno]?
 			sysctab[syscallno]: "huh?");
 
-	fmtprint(&fmt, "%ulx ", pc);
+	fmtprint(&fmt, "%p ", pc);
 	switch(syscallno){
 	case SYSR1:
 		p = va_arg(list, uintptr);
@@ -113,7 +113,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
 		argv = va_arg(list, char**);
 		evenaddr(PTR2UINT(argv));
 		for(;;){
-			validaddr((ulong)argv, sizeof(char**), 0);
+			validaddr((uintptr)argv, sizeof(char**), 0);
 			a = *(char **)argv;
 			if(a == nil)
 				break;
@@ -307,7 +307,7 @@ syscallfmt(ulong syscallno, ulong pc, va_list list)
 }
 
 void
-sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
+sysretfmt(ulong syscallno, va_list list, uintptr ret, uvlong start, uvlong stop)
 {
 	long l;
 	void* v;
@@ -324,9 +324,9 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
 	case ALARM:
 	case _WRITE:
 	case PWRITE:
-		if(ret == -1)
+		if((long)ret == -1)
 			errstr = up->syserrstr;
-		fmtprint(&fmt, " = %ld", ret);
+		fmtprint(&fmt, " = %ld", (long)ret);
 		break;
 	case EXEC:
 	case SEGBRK:
@@ -341,10 +341,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
 		l = va_arg(list, unsigned long);
 		if(ret > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %ld", l, ret);
+			fmtprint(&fmt, "%lud = %ld", l, (long)ret);
 		}
 		else{
-			fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, ret);
+			fmtprint(&fmt, "%#p/\"\" %lud = %ld", a, l, (long)ret);
 			errstr = up->syserrstr;
 		}
 		break;
@@ -357,10 +357,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
 			l = va_arg(list, unsigned long);
 		if(ret > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %ld", l, ret);
+			fmtprint(&fmt, "%lud = %ld", l, (long)ret);
 		}
 		else{
-			fmtprint(&fmt, "\"\" %lud = %ld", l, ret);
+			fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
 			errstr = up->syserrstr;
 		}
 		break;
@@ -371,10 +371,10 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
 		l = va_arg(list, unsigned long);
 		if(ret > 0){
 			fmtuserstring(&fmt, a, " ");
-			fmtprint(&fmt, "%lud = %ld", l, ret);
+			fmtprint(&fmt, "%lud = %ld", l, (long)ret);
 		}
 		else{
-			fmtprint(&fmt, "\"\" %lud = %ld", l, ret);
+			fmtprint(&fmt, "\"\" %lud = %ld", l, (long)ret);
 			errstr = up->syserrstr;
 		}
 		break;
@@ -397,7 +397,7 @@ sysretfmt(ulong syscallno, va_list list, long ret, uvlong start, uvlong stop)
 			vl = va_arg(list, vlong);
 			fmtprint(&fmt, " %lld", vl);
 		}
-		fmtprint(&fmt, " = %ld", ret);
+		fmtprint(&fmt, " = %ld", (long)ret);
 		break;
 	}
 	fmtprint(&fmt, " %s %#llud %#llud\n", errstr, start, stop);
diff --git a/sys/src/9/port/sysfile.c b/sys/src/9/port/sysfile.c
index b810a4256..20edecf1f 100644
--- a/sys/src/9/port/sysfile.c
+++ b/sys/src/9/port/sysfile.c
@@ -113,7 +113,6 @@ newfd2(int fd[2], Chan *c[2])
 	f->fd[fd[0]] = c[0];
 	f->fd[fd[1]] = c[1];
 	unlockfgrp(f);
-
 	return 0;
 }
 
@@ -155,7 +154,6 @@ fdtochan(int fd, int mode, int chkmnt, int iref)
 			cclose(c);
 		error(Ebadusefd);
 	}
-
 	return c;
 }
 
@@ -170,29 +168,36 @@ openmode(ulong o)
 	return o;
 }
 
-long
-sysfd2path(ulong *arg)
+uintptr
+sysfd2path(va_list list)
 {
 	Chan *c;
+	char *buf;
+	uint len;
+	int fd;
 
-	validaddr(arg[1], arg[2], 1);
-
-	c = fdtochan(arg[0], -1, 0, 1);
-	snprint((char*)arg[1], arg[2], "%s", chanpath(c));
+	fd = va_arg(list, int);
+	buf = va_arg(list, char*);
+	len = va_arg(list, uint);
+	validaddr((uintptr)buf, len, 1);
+	c = fdtochan(fd, -1, 0, 1);
+	snprint(buf, len, "%s", chanpath(c));
 	cclose(c);
 	return 0;
 }
 
-long
-syspipe(ulong *arg)
+uintptr
+syspipe(va_list list)
 {
-	int fd[2];
+	int *fd;
 	Chan *c[2];
 	Dev *d;
 	static char *datastr[] = {"data", "data1"};
 
-	validaddr(arg[0], 2*BY2WD, 1);
-	evenaddr(arg[0]);
+	fd = va_arg(list, int*);
+	validaddr((uintptr)fd, 2*sizeof(int), 1);
+	evenaddr((uintptr)fd);
+
 	d = devtab[devno('|', 0)];
 	c[0] = namec("#|", Atodir, 0, 0);
 	c[1] = 0;
@@ -215,24 +220,23 @@ syspipe(ulong *arg)
 	if(newfd2(fd, c) < 0)
 		error(Enofd);
 	poperror();
-
-	((long*)arg[0])[0] = fd[0];
-	((long*)arg[0])[1] = fd[1];
 	return 0;
 }
 
-long
-sysdup(ulong *arg)
+uintptr
+sysdup(va_list list)
 {
 	int fd;
 	Chan *c, *oc;
 	Fgrp *f = up->fgrp;
 
+	fd = va_arg(list, int);
+
 	/*
 	 * Close after dup'ing, so date > #d/1 works
 	 */
-	c = fdtochan(arg[0], -1, 0, 1);
-	fd = arg[1];
+	c = fdtochan(fd, -1, 0, 1);
+	fd = va_arg(list, int);
 	if(fd != -1){
 		lock(f);
 		if(fd<0 || growfd(f, fd)<0) {
@@ -258,19 +262,22 @@ sysdup(ulong *arg)
 			error(Enofd);
 		poperror();
 	}
-
-	return fd;
+	return (uintptr)fd;
 }
 
-long
-sysopen(ulong *arg)
+uintptr
+sysopen(va_list list)
 {
 	int fd;
 	Chan *c;
+	char *name;
+	ulong mode;
 
-	openmode(arg[1]);	/* error check only */
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Aopen, arg[1], 0);
+	name = va_arg(list, char*);
+	mode = va_arg(list, ulong);
+	openmode(mode);	/* error check only */
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Aopen, mode, 0);
 	if(waserror()){
 		cclose(c);
 		nexterror();
@@ -279,7 +286,7 @@ sysopen(ulong *arg)
 	if(fd < 0)
 		error(Enofd);
 	poperror();
-	return fd;
+	return (uintptr)fd;
 }
 
 void
@@ -311,12 +318,14 @@ fdclose(int fd, int flag)
 	cclose(c);
 }
 
-long
-sysclose(ulong *arg)
+uintptr
+sysclose(va_list list)
 {
-	fdtochan(arg[0], -1, 0, 0);
-	fdclose(arg[0], 0);
+	int fd;
 
+	fd = va_arg(list, int);
+	fdtochan(fd, -1, 0, 0);
+	fdclose(fd, 0);
 	return 0;
 }
 
@@ -625,17 +634,14 @@ mountfix(Chan *c, uchar *op, long n, long maxn)
 }
 
 static long
-read(ulong *arg, vlong *offp)
+read(int fd, uchar *p, long n, vlong *offp)
 {
-	long n, nn, nnn;
-	uchar *p;
+	long nn, nnn;
 	Chan *c;
 	vlong off;
 
-	n = arg[2];
-	validaddr(arg[1], n, 1);
-	p = (void*)arg[1];
-	c = fdtochan(arg[0], OREAD, 1, 1);
+	validaddr((uintptr)p, n, 1);
+	c = fdtochan(fd, OREAD, 1, 1);
 
 	if(waserror()){
 		cclose(c);
@@ -688,43 +694,51 @@ read(ulong *arg, vlong *offp)
 
 	poperror();
 	cclose(c);
-
 	return nnn;
 }
 
-long
-sys_read(ulong *arg)
+uintptr
+sys_read(va_list list)
 {
-	return read(arg, nil);
+	int fd;
+	void *buf;
+	long len;
+
+	fd = va_arg(list, int);
+	buf = va_arg(list, void*);
+	len = va_arg(list, long);
+	return (uintptr)read(fd, buf, len, nil);
 }
 
-long
-syspread(ulong *arg)
+uintptr
+syspread(va_list list)
 {
-	vlong v;
-	va_list list;
-
-	/* use varargs to guarantee alignment of vlong */
-	va_start(list, arg[2]);
-	v = va_arg(list, vlong);
-	va_end(list);
-
-	if(v == ~0ULL)
-		return read(arg, nil);
-
-	return read(arg, &v);
+	int fd;
+	void *buf;
+	long len;
+	vlong off, *offp;
+
+	fd = va_arg(list, int);
+	buf = va_arg(list, void*);
+	len = va_arg(list, long);
+	off = va_arg(list, vlong);
+	if(off != ~0ULL)
+		offp = &off;
+	else
+		offp = nil;
+	return (uintptr)read(fd, buf, len, offp);
 }
 
 static long
-write(ulong *arg, vlong *offp)
+write(int fd, void *buf, long len, vlong *offp)
 {
 	Chan *c;
 	long m, n;
 	vlong off;
 
-	validaddr(arg[1], arg[2], 0);
+	validaddr((uintptr)buf, len, 0);
 	n = 0;
-	c = fdtochan(arg[0], OWRITE, 1, 1);
+	c = fdtochan(fd, OWRITE, 1, 1);
 	if(waserror()) {
 		if(offp == nil){
 			lock(c);
@@ -738,7 +752,7 @@ write(ulong *arg, vlong *offp)
 	if(c->qid.type & QTDIR)
 		error(Eisdir);
 
-	n = arg[2];
+	n = len;
 
 	if(offp == nil){	/* use and maintain channel's offset */
 		lock(c);
@@ -751,8 +765,7 @@ write(ulong *arg, vlong *offp)
 	if(off < 0)
 		error(Enegoff);
 
-	m = devtab[c->type]->write(c, (void*)arg[1], n, off);
-
+	m = devtab[c->type]->write(c, buf, n, off);
 	if(offp == nil && m < n){
 		lock(c);
 		c->offset -= n - m;
@@ -761,47 +774,51 @@ write(ulong *arg, vlong *offp)
 
 	poperror();
 	cclose(c);
-
 	return m;
 }
 
-long
-sys_write(ulong *arg)
+uintptr
+sys_write(va_list list)
 {
-	return write(arg, nil);
+	int fd;
+	void *buf;
+	long len;
+
+	fd = va_arg(list, int);
+	buf = va_arg(list, void*);
+	len = va_arg(list, long);
+	return (uintptr)write(fd, buf, len, nil);
 }
 
-long
-syspwrite(ulong *arg)
+uintptr
+syspwrite(va_list list)
 {
-	vlong v;
-	va_list list;
-
-	/* use varargs to guarantee alignment of vlong */
-	va_start(list, arg[2]);
-	v = va_arg(list, vlong);
-	va_end(list);
-
-	if(v == ~0ULL)
-		return write(arg, nil);
-
-	return write(arg, &v);
+	int fd;
+	void *buf;
+	long len;
+	vlong off, *offp;
+
+	fd = va_arg(list, int);
+	buf = va_arg(list, void*);
+	len = va_arg(list, long);
+	off = va_arg(list, vlong);
+	if(off != ~0ULL)
+		offp = &off;
+	else
+		offp = nil;
+	return (uintptr)write(fd, buf, len, offp);
 }
 
-static void
-sseek(ulong *arg)
+static vlong
+sseek(int fd, vlong o, int type)
 {
 	Chan *c;
 	uchar buf[sizeof(Dir)+100];
 	Dir dir;
 	int n;
 	vlong off;
-	union {
-		vlong v;
-		ulong u[2];
-	} o;
 
-	c = fdtochan(arg[1], -1, 1, 1);
+	c = fdtochan(fd, -1, 1, 1);
 	if(waserror()){
 		cclose(c);
 		nexterror();
@@ -810,11 +827,9 @@ sseek(ulong *arg)
 		error(Eisstream);
 
 	off = 0;
-	o.u[0] = arg[2];
-	o.u[1] = arg[3];
-	switch(arg[4]){
+	switch(type){
 	case 0:
-		off = o.v;
+		off = o;
 		if((c->qid.type & QTDIR) && off != 0)
 			error(Eisdir);
 		if(off < 0)
@@ -826,7 +841,7 @@ sseek(ulong *arg)
 		if(c->qid.type & QTDIR)
 			error(Eisdir);
 		lock(c);	/* lock for read/write update */
-		off = o.v + c->offset;
+		off = o + c->offset;
 		if(off < 0){
 			unlock(c);
 			error(Enegoff);
@@ -841,7 +856,7 @@ sseek(ulong *arg)
 		n = devtab[c->type]->stat(c, buf, sizeof buf);
 		if(convM2D(buf, n, &dir, nil) == 0)
 			error("internal error: stat error in seek");
-		off = dir.length + o.v;
+		off = dir.length + o;
 		if(off < 0)
 			error(Enegoff);
 		c->offset = off;
@@ -850,38 +865,41 @@ sseek(ulong *arg)
 	default:
 		error(Ebadarg);
 	}
-	*(vlong*)arg[0] = off;
 	c->uri = 0;
 	c->dri = 0;
 	cclose(c);
 	poperror();
+	return off;
 }
 
-long
-sysseek(ulong *arg)
+uintptr
+sysseek(va_list list)
 {
-	validaddr(arg[0], BY2V, 1);
-	sseek(arg);
+	int fd, t;
+	vlong n, *v;
+
+	v = va_arg(list, vlong*);
+	validaddr((uintptr)v, sizeof(vlong), 1);
+
+	fd = va_arg(list, int);
+	n = va_arg(list, vlong);
+	t = va_arg(list, int);
+
+	*v = sseek(fd, n, t);
+
 	return 0;
 }
 
-long
-sysoseek(ulong *arg)
+uintptr
+sysoseek(va_list list)
 {
-	union {
-		vlong v;
-		ulong u[2];
-	} o;
-	ulong a[5];
-
-	o.v = (long)arg[1];
-	a[0] = (ulong)&o.v;
-	a[1] = arg[0];
-	a[2] = o.u[0];
-	a[3] = o.u[1];
-	a[4] = arg[2];
-	sseek(a);
-	return o.v;
+	int fd, t;
+	long n;
+
+	fd = va_arg(list, int);
+	n = va_arg(list, long);
+	t = va_arg(list, int);
+	return (uintptr)sseek(fd, n, t);
 }
 
 void
@@ -926,58 +944,67 @@ pathlast(Path *p)
 	return p->s;
 }
 
-long
-sysfstat(ulong *arg)
+uintptr
+sysfstat(va_list list)
 {
 	Chan *c;
+	int fd;
 	uint l;
+	uchar *s;
 
-	l = arg[2];
-	validaddr(arg[1], l, 1);
-	c = fdtochan(arg[0], -1, 0, 1);
+	fd = va_arg(list, int);
+	s = va_arg(list, uchar*);
+	l = va_arg(list, uint);
+	validaddr((uintptr)s, l, 1);
+
+	c = fdtochan(fd, -1, 0, 1);
 	if(waserror()) {
 		cclose(c);
 		nexterror();
 	}
-	l = devtab[c->type]->stat(c, (uchar*)arg[1], l);
+	l = devtab[c->type]->stat(c, s, l);
 	poperror();
 	cclose(c);
 	return l;
 }
 
-long
-sysstat(ulong *arg)
+uintptr
+sysstat(va_list list)
 {
 	char *name;
 	Chan *c;
-	uint l;
-
-	l = arg[2];
-	validaddr(arg[1], l, 1);
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Aaccess, 0, 0);
+	uint l, r;
+	uchar *s;
+
+	name = va_arg(list, char*);
+	s = va_arg(list, uchar*);
+	l = va_arg(list, uint);
+	validaddr((uintptr)s, l, 1);
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Aaccess, 0, 0);
 	if(waserror()){
 		cclose(c);
 		nexterror();
 	}
-	l = devtab[c->type]->stat(c, (uchar*)arg[1], l);
+	r = devtab[c->type]->stat(c, s, l);
 	name = pathlast(c->path);
 	if(name)
-		l = dirsetname(name, strlen(name), (uchar*)arg[1], l, arg[2]);
+		r = dirsetname(name, strlen(name), s, r, l);
 
 	poperror();
 	cclose(c);
-	return l;
+	return r;
 }
 
-long
-syschdir(ulong *arg)
+uintptr
+syschdir(va_list list)
 {
 	Chan *c;
+	char *name;
 
-	validaddr(arg[0], 1, 0);
-
-	c = namec((char*)arg[0], Atodir, 0, 0);
+	name = va_arg(list, char*);
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Atodir, 0, 0);
 	cclose(up->dot);
 	up->dot = c;
 	return 0;
@@ -999,7 +1026,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
 		error(Ebadarg);
 
 	if(ismount){
-		validaddr((ulong)spec, 1, 0);
+		validaddr((uintptr)spec, 1, 0);
 		spec = validnamedup(spec, 1);
 		if(waserror()){
 			free(spec);
@@ -1033,7 +1060,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
 		cclose(bc);
 	}else{
 		spec = 0;
-		validaddr((ulong)arg0, 1, 0);
+		validaddr((uintptr)arg0, 1, 0);
 		c0 = namec(arg0, Abind, 0, 0);
 	}
 
@@ -1042,7 +1069,7 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
 		nexterror();
 	}
 
-	validaddr((ulong)arg1, 1, 0);
+	validaddr((uintptr)arg1, 1, 0);
 	c1 = namec(arg1, Amount, 0, 0);
 	if(waserror()){
 		cclose(c1);
@@ -1063,33 +1090,59 @@ bindmount(int ismount, int fd, int afd, char* arg0, char* arg1, ulong flag, char
 	return ret;
 }
 
-long
-sysbind(ulong *arg)
+uintptr
+sysbind(va_list list)
 {
-	return bindmount(0, -1, -1, (char*)arg[0], (char*)arg[1], arg[2], nil);
+	char *arg0, *arg1;
+	ulong flag;
+
+	arg0 = va_arg(list, char*);
+	arg1 = va_arg(list, char*);
+	flag = va_arg(list, ulong);
+	return (uintptr)bindmount(0, -1, -1, arg0, arg1, flag, nil);
 }
 
-long
-sysmount(ulong *arg)
+uintptr
+sysmount(va_list list)
 {
-	return bindmount(1, arg[0], arg[1], nil, (char*)arg[2], arg[3], (char*)arg[4]);
+	char *arg1, *spec;
+	ulong flag;
+	int fd, afd;
+
+	fd = va_arg(list, int);
+	afd = va_arg(list, int);
+	arg1 = va_arg(list, char*);
+	flag = va_arg(list, ulong);
+	spec = va_arg(list, char*);
+	return (uintptr)bindmount(1, fd, afd, nil, arg1, flag, spec);
 }
 
-long
-sys_mount(ulong *arg)
+uintptr
+sys_mount(va_list list)
 {
-	return bindmount(1, arg[0], -1, nil, (char*)arg[1], arg[2], (char*)arg[3]);
+	char *arg1, *spec;
+	ulong flag;
+	int fd;
+
+	fd = va_arg(list, int);
+	arg1 = va_arg(list, char*);
+	flag = va_arg(list, ulong);
+	spec = va_arg(list, char*);
+	return (uintptr)bindmount(1, fd, -1, nil, arg1, flag, spec);
 }
 
-long
-sysunmount(ulong *arg)
+uintptr
+sysunmount(va_list list)
 {
 	Chan *cmount, *cmounted;
+	char *name, *old;
 
-	cmounted = 0;
+	name = va_arg(list, char*);
+	old = va_arg(list, char*);
 
-	validaddr(arg[1], 1, 0);
-	cmount = namec((char *)arg[1], Amount, 0, 0);
+	cmounted = 0;
+	validaddr((uintptr)old, 1, 0);
+	cmount = namec(old, Amount, 0, 0);
 	if(waserror()) {
 		cclose(cmount);
 		if(cmounted)
@@ -1097,15 +1150,15 @@ sysunmount(ulong *arg)
 		nexterror();
 	}
 
-	if(arg[0]) {
+	if(name) {
 		/*
 		 * This has to be namec(..., Aopen, ...) because
 		 * if arg[0] is something like /srv/cs or /fd/0,
 		 * opening it is the only way to get at the real
 		 * Chan underneath.
 		 */
-		validaddr(arg[0], 1, 0);
-		cmounted = namec((char*)arg[0], Aopen, OREAD, 0);
+		validaddr((uintptr)name, 1, 0);
+		cmounted = namec(name, Aopen, OREAD, 0);
 	}
 	cunmount(cmount, cmounted);
 	poperror();
@@ -1115,15 +1168,19 @@ sysunmount(ulong *arg)
 	return 0;
 }
 
-long
-syscreate(ulong *arg)
+uintptr
+syscreate(va_list list)
 {
-	int fd;
+	int fd, mode, perm;
+	char *name;
 	Chan *c;
 
-	openmode(arg[1]&~OEXCL);	/* error check only; OEXCL okay here */
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Acreate, arg[1], arg[2]);
+	name = va_arg(list, char*);
+	mode = va_arg(list, int);
+	perm = va_arg(list, int);
+	openmode(mode&~OEXCL);	/* error check only; OEXCL okay here */
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Acreate, mode, perm);
 	if(waserror()) {
 		cclose(c);
 		nexterror();
@@ -1132,16 +1189,18 @@ syscreate(ulong *arg)
 	if(fd < 0)
 		error(Enofd);
 	poperror();
-	return fd;
+	return (uintptr)fd;
 }
 
-long
-sysremove(ulong *arg)
+uintptr
+sysremove(va_list list)
 {
+	char *name;
 	Chan *c;
 
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Aremove, 0, 0);
+	name = va_arg(list, char*);
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Aremove, 0, 0);
 	/*
 	 * Removing mount points is disallowed to avoid surprises
 	 * (which should be removed: the mount point or the mounted Chan?).
@@ -1191,31 +1250,39 @@ wstat(Chan *c, uchar *d, int nd)
 	return l;
 }
 
-long
-syswstat(ulong *arg)
+uintptr
+syswstat(va_list list)
 {
+	char *name;
+	uchar *s;
 	Chan *c;
 	uint l;
 
-	l = arg[2];
-	validaddr(arg[1], l, 0);
-	validstat((uchar*)arg[1], l);
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Aaccess, 0, 0);
-	return wstat(c, (uchar*)arg[1], l);
+	name = va_arg(list, char*);
+	s = va_arg(list, uchar*);
+	l = va_arg(list, uint);
+	validaddr((uintptr)s, l, 0);
+	validstat(s, l);
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Aaccess, 0, 0);
+	return (uintptr)wstat(c, s, l);
 }
 
-long
-sysfwstat(ulong *arg)
+uintptr
+sysfwstat(va_list list)
 {
+	uchar *s;
 	Chan *c;
 	uint l;
+	int fd;
 
-	l = arg[2];
-	validaddr(arg[1], l, 0);
-	validstat((uchar*)arg[1], l);
-	c = fdtochan(arg[0], -1, 1, 1);
-	return wstat(c, (uchar*)arg[1], l);
+	fd = va_arg(list, int);
+	s = va_arg(list, uchar*);
+	l = va_arg(list, uint);
+	validaddr((uintptr)s, l, 0);
+	validstat(s, l);
+	c = fdtochan(fd, -1, 1, 1);
+	return (uintptr)wstat(c, s, l);
 }
 
 static void
@@ -1252,19 +1319,21 @@ packoldstat(uchar *buf, Dir *d)
 	PBIT16(p, d->dev);
 }
 
-long
-sys_stat(ulong *arg)
+uintptr
+sys_stat(va_list list)
 {
 	Chan *c;
 	uint l;
-	uchar buf[128];	/* old DIRLEN plus a little should be plenty */
+	uchar *s, buf[128];	/* old DIRLEN plus a little should be plenty */
 	char strs[128], *name;
 	Dir d;
 	char old[] = "old stat system call - recompile";
 
-	validaddr(arg[1], 116, 1);
-	validaddr(arg[0], 1, 0);
-	c = namec((char*)arg[0], Aaccess, 0, 0);
+	name = va_arg(list, char*);
+	s = va_arg(list, uchar*);
+	validaddr((uintptr)s, 116, 1);
+	validaddr((uintptr)name, 1, 0);
+	c = namec(name, Aaccess, 0, 0);
 	if(waserror()){
 		cclose(c);
 		nexterror();
@@ -1279,26 +1348,29 @@ sys_stat(ulong *arg)
 	l = convM2D(buf, l, &d, strs);
 	if(l == 0)
 		error(old);
-	packoldstat((uchar*)arg[1], &d);
+	packoldstat(s, &d);
 	
 	poperror();
 	cclose(c);
 	return 0;
 }
 
-long
-sys_fstat(ulong *arg)
+uintptr
+sys_fstat(va_list list)
 {
 	Chan *c;
 	char *name;
 	uint l;
-	uchar buf[128];	/* old DIRLEN plus a little should be plenty */
+	uchar *s, buf[128];	/* old DIRLEN plus a little should be plenty */
 	char strs[128];
 	Dir d;
 	char old[] = "old fstat system call - recompile";
+	int fd;
 
-	validaddr(arg[1], 116, 1);
-	c = fdtochan(arg[0], -1, 0, 1);
+	fd = va_arg(list, int);
+	s = va_arg(list, uchar*);
+	validaddr((uintptr)s, 116, 1);
+	c = fdtochan(fd, -1, 0, 1);
 	if(waserror()){
 		cclose(c);
 		nexterror();
@@ -1313,23 +1385,23 @@ sys_fstat(ulong *arg)
 	l = convM2D(buf, l, &d, strs);
 	if(l == 0)
 		error(old);
-	packoldstat((uchar*)arg[1], &d);
+	packoldstat(s, &d);
 	
 	poperror();
 	cclose(c);
 	return 0;
 }
 
-long
-sys_wstat(ulong *)
+uintptr
+sys_wstat(va_list)
 {
 	error("old wstat system call - recompile");
-	return -1;
+	return (uintptr)-1;
 }
 
-long
-sys_fwstat(ulong *)
+uintptr
+sys_fwstat(va_list)
 {
 	error("old fwstat system call - recompile");
-	return -1;
+	return (uintptr)-1;
 }
diff --git a/sys/src/9/port/sysproc.c b/sys/src/9/port/sysproc.c
index ab37bb68c..2a1b15b94 100644
--- a/sys/src/9/port/sysproc.c
+++ b/sys/src/9/port/sysproc.c
@@ -14,8 +14,8 @@ int	shargs(char*, int, char**);
 extern void checkpages(void);
 extern void checkpagerefs(void);
 
-long
-sysr1(ulong*)
+uintptr
+sysr1(va_list)
 {
 	if(!iseve())
 		error(Eperm);
@@ -29,8 +29,8 @@ abortion(void*)
 	pexit("fork aborted", 1);
 }
 
-long
-sysrfork(ulong *arg)
+uintptr
+sysrfork(va_list list)
 {
 	Proc *p;
 	int n, i;
@@ -41,7 +41,7 @@ sysrfork(ulong *arg)
 	ulong pid, flag;
 	Mach *wm;
 
-	flag = arg[0];
+	flag = va_arg(list, ulong);
 	/* Check flags before we commit */
 	if((flag & (RFFDG|RFCFDG)) == (RFFDG|RFCFDG))
 		error(Ebadarg);
@@ -221,7 +221,7 @@ sysrfork(ulong *arg)
 		procwired(p, wm->machno);
 	ready(p);
 	sched();
-	return pid;
+	return (uintptr)pid;
 }
 
 static ulong
@@ -233,29 +233,30 @@ l2be(long l)
 	return (cp[0]<<24) | (cp[1]<<16) | (cp[2]<<8) | cp[3];
 }
 
-long
-sysexec(ulong *arg)
+uintptr
+sysexec(va_list list)
 {
 	Segment *s, *ts;
-	ulong t, d, b;
 	int i;
 	Chan *tc;
-	char **argv, **argp;
+	char **argv, **argp, **argp0;
 	char *a, *charp, *args, *file, *file0;
 	char *progarg[sizeof(Exec)/2+1], *elem, progelem[64];
-	ulong ssize, tstk, nargs, nbytes, n, bssend;
+	ulong magic, ssize, nargs, nbytes, n;
+	uintptr t, d, b, entry, bssend, text, data, bss, tstk;
 	int indir;
 	Exec exec;
 	char line[sizeof(Exec)];
 	Fgrp *f;
 	Image *img;
-	ulong magic, text, entry, data, bss;
 	Tos *tos;
 
 	a = nil;
 	elem = nil;
-	validaddr(arg[0], 1, 0);
-	file0 = validnamedup((char*)arg[0], 1);
+	file0 = va_arg(list, char*);
+	validaddr((uintptr)file0, 1, 0);
+	argp0 = va_arg(list, char**);
+	file0 = validnamedup(file0, 1);
 	if(waserror()){
 		free(file0);
 		free(elem);
@@ -305,8 +306,7 @@ sysexec(ulong *arg)
 		 */
 		progarg[n++] = file;
 		progarg[n] = 0;
-		validaddr(arg[1], BY2WD, 1);
-		arg[1] += BY2WD;
+		argp0++;
 		file = progarg[0];
 		if(strlen(elem) >= sizeof progelem)
 			error(Ebadexec);
@@ -338,14 +338,14 @@ sysexec(ulong *arg)
 			nargs++;
 		}
 	}
-	evenaddr(arg[1]);
-	argp = (char**)arg[1];
-	validaddr((ulong)argp, BY2WD, 0);
+	argp = argp0;
+	evenaddr((uintptr)argp);
+	validaddr((uintptr)argp, BY2WD, 0);
 	while(*argp){
 		a = *argp++;
-		if(((ulong)argp&(BY2PG-1)) < BY2WD)
-			validaddr((ulong)argp, BY2WD, 0);
-		validaddr((ulong)a, 1, 0);
+		if(((uintptr)argp&(BY2PG-1)) < BY2WD)
+			validaddr((uintptr)argp, BY2WD, 0);
+		validaddr((uintptr)a, 1, 0);
 		nbytes += ((char*)vmemchr(a, 0, 0x7FFFFFFF) - a) + 1;
 		nargs++;
 	}
@@ -393,12 +393,12 @@ sysexec(ulong *arg)
 	if(indir)
 		argp = progarg;
 	else
-		argp = (char**)arg[1];
+		argp = argp0;
 
 	for(i=0; i<nargs; i++){
 		if(indir && *argp==0) {
 			indir = 0;
-			argp = (char**)arg[1];
+			argp = argp0;
 		}
 		*argv++ = charp + (USTKTOP-tstk);
 		n = strlen(*argp) + 1;
@@ -557,45 +557,45 @@ return0(void*)
 	return 0;
 }
 
-long
-syssleep(ulong *arg)
+uintptr
+syssleep(va_list list)
 {
+	long ms;
 
-	int n;
-
-	n = arg[0];
-	if(n <= 0) {
+	ms = va_arg(list, long);
+	if(ms <= 0) {
 		if (up->edf && (up->edf->flags & Admitted))
 			edfyield();
 		else
 			yield();
-		return 0;
+	} else {
+		if(ms < TK2MS(1))
+			ms = TK2MS(1);
+		tsleep(&up->sleep, return0, 0, ms);
 	}
-	if(n < TK2MS(1))
-		n = TK2MS(1);
-	tsleep(&up->sleep, return0, 0, n);
 	return 0;
 }
 
-long
-sysalarm(ulong *arg)
+uintptr
+sysalarm(va_list list)
 {
-	return procalarm(arg[0]);
+	return (uintptr)procalarm(va_arg(list, ulong));
 }
 
-long
-sysexits(ulong *arg)
+
+uintptr
+sysexits(va_list list)
 {
 	char *status;
 	char *inval = "invalid exit string";
 	char buf[ERRMAX];
 
-	status = (char*)arg[0];
+	status = va_arg(list, char*);
 	if(status){
 		if(waserror())
 			status = inval;
 		else{
-			validaddr((ulong)status, 1, 0);
+			validaddr((uintptr)status, 1, 0);
 			if(vmemchr(status, 0, ERRMAX) == 0){
 				memmove(buf, status, ERRMAX);
 				buf[ERRMAX-1] = 0;
@@ -606,53 +606,57 @@ sysexits(ulong *arg)
 
 	}
 	pexit(status, 1);
-	return 0;		/* not reached */
+	return 0;	/* not reached */
 }
 
-long
-sys_wait(ulong *arg)
+uintptr
+sys_wait(va_list list)
 {
 	int pid;
 	Waitmsg w;
 	OWaitmsg *ow;
 
-	if(arg[0] == 0)
-		return pwait(nil);
-
-	validaddr(arg[0], sizeof(OWaitmsg), 1);
-	evenaddr(arg[0]);
-	pid = pwait(&w);
-	if(pid >= 0){
-		ow = (OWaitmsg*)arg[0];
-		readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE);
-		readnum(0, ow->time+TUser*NUMSIZE, NUMSIZE, w.time[TUser], NUMSIZE);
-		readnum(0, ow->time+TSys*NUMSIZE, NUMSIZE, w.time[TSys], NUMSIZE);
-		readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE);
-		strncpy(ow->msg, w.msg, sizeof(ow->msg)-1);
-		ow->msg[sizeof(ow->msg)-1] = '\0';
+	ow = va_arg(list, OWaitmsg*);
+	if(ow == 0)
+		pid = pwait(nil);
+	else {
+		validaddr((uintptr)ow, sizeof(OWaitmsg), 1);
+		evenaddr((uintptr)ow);
+		pid = pwait(&w);
+		if(pid >= 0){
+			readnum(0, ow->pid, NUMSIZE, w.pid, NUMSIZE);
+			readnum(0, ow->time+TUser*NUMSIZE, NUMSIZE, w.time[TUser], NUMSIZE);
+			readnum(0, ow->time+TSys*NUMSIZE, NUMSIZE, w.time[TSys], NUMSIZE);
+			readnum(0, ow->time+TReal*NUMSIZE, NUMSIZE, w.time[TReal], NUMSIZE);
+			strncpy(ow->msg, w.msg, sizeof(ow->msg)-1);
+			ow->msg[sizeof(ow->msg)-1] = '\0';
+		}
 	}
-	return pid;
+	return (uintptr)pid;
 }
 
-long
-sysawait(ulong *arg)
+uintptr
+sysawait(va_list list)
 {
 	int i;
 	int pid;
+	char *p;
 	Waitmsg w;
-	ulong n;
+	uint n;
 
-	n = arg[1];
-	validaddr(arg[0], n, 1);
+	p = va_arg(list, char*);
+	n = va_arg(list, uint);
+	validaddr((uintptr)p, n, 1);
 	pid = pwait(&w);
 	if(pid < 0)
-		return -1;
-	i = snprint((char*)arg[0], n, "%d %lud %lud %lud %q",
-		w.pid,
-		w.time[TUser], w.time[TSys], w.time[TReal],
-		w.msg);
-
-	return i;
+		i = -1;
+	else {
+		i = snprint(p, n, "%d %lud %lud %lud %q",
+			w.pid,
+			w.time[TUser], w.time[TSys], w.time[TReal],
+			w.msg);
+	}
+	return (uintptr)i;
 }
 
 void
@@ -668,14 +672,14 @@ werrstr(char *fmt, ...)
 	va_end(va);
 }
 
-static long
+static int
 generrstr(char *buf, uint nbuf)
 {
 	char tmp[ERRMAX];
 
 	if(nbuf == 0)
 		error(Ebadarg);
-	validaddr((ulong)buf, nbuf, 1);
+	validaddr((uintptr)buf, nbuf, 1);
 	if(nbuf > sizeof tmp)
 		nbuf = sizeof tmp;
 	memmove(tmp, buf, nbuf);
@@ -688,44 +692,51 @@ generrstr(char *buf, uint nbuf)
 	return 0;
 }
 
-long
-syserrstr(ulong *arg)
+uintptr
+syserrstr(va_list list)
 {
-	return generrstr((char*)arg[0], arg[1]);
+	char *buf;
+	uint len;
+
+	buf = va_arg(list, char*);
+	len = va_arg(list, uint);
+	return (uintptr)generrstr(buf, len);
 }
 
 /* compatibility for old binaries */
-long
-sys_errstr(ulong *arg)
+uintptr
+sys_errstr(va_list list)
 {
-	return generrstr((char*)arg[0], 64);
+	return (uintptr)generrstr(va_arg(list, char*), 64);
 }
 
-long
-sysnotify(ulong *arg)
+uintptr
+sysnotify(va_list list)
 {
-	if(arg[0] != 0)
-		validaddr(arg[0], sizeof(ulong), 0);
-	up->notify = (int(*)(void*, char*))(arg[0]);
+	int (*f)(void*, char*);
+	f = va_arg(list, void*);
+	if(f != 0)
+		validaddr((uintptr)f, sizeof(void*), 0);
+	up->notify = f;
 	return 0;
 }
 
-long
-sysnoted(ulong *arg)
+uintptr
+sysnoted(va_list list)
 {
-	if(arg[0]!=NRSTR && !up->notified)
+	if(va_arg(list, int) !=NRSTR && !up->notified)
 		error(Egreg);
 	return 0;
 }
 
-long
-syssegbrk(ulong *arg)
+uintptr
+syssegbrk(va_list list)
 {
 	int i;
-	ulong addr;
+	uintptr addr;
 	Segment *s;
 
-	addr = arg[0];
+	addr = va_arg(list, uintptr);
 	for(i = 0; i < NSEG; i++) {
 		s = up->seg[i];
 		if(s == 0 || addr < s->base || addr >= s->top)
@@ -736,27 +747,37 @@ syssegbrk(ulong *arg)
 		case SG_STACK:
 			error(Ebadarg);
 		default:
-			return ibrk(arg[1], i);
+			return (uintptr)ibrk(va_arg(list, uintptr), i);
 		}
 	}
-
 	error(Ebadarg);
-	return 0;		/* not reached */
+	return 0;	/* not reached */
 }
 
-long
-syssegattach(ulong *arg)
+uintptr
+syssegattach(va_list list)
 {
-	return segattach(up, arg[0], (char*)arg[1], arg[2], arg[3]);
+	ulong attr;
+	char *name;
+	uintptr va;
+	ulong len;
+
+	attr = va_arg(list, ulong);
+	name = va_arg(list, char*);
+	va = va_arg(list, uintptr);
+	len = va_arg(list, ulong);
+	return segattach(up, attr, name, va, len);
 }
 
-long
-syssegdetach(ulong *arg)
+uintptr
+syssegdetach(va_list list)
 {
 	int i;
-	ulong addr;
+	uintptr addr;
 	Segment *s;
 
+	addr = va_arg(list, uintptr);
+
 	qlock(&up->seglock);
 	if(waserror()){
 		qunlock(&up->seglock);
@@ -764,7 +785,6 @@ syssegdetach(ulong *arg)
 	}
 
 	s = 0;
-	addr = arg[0];
 	for(i = 0; i < NSEG; i++)
 		if(s = up->seg[i]) {
 			qlock(&s->lk);
@@ -795,17 +815,19 @@ found:
 	return 0;
 }
 
-long
-syssegfree(ulong *arg)
+uintptr
+syssegfree(va_list list)
 {
 	Segment *s;
-	ulong from, to;
+	uintptr from, to;
 
-	from = arg[0];
+	from = va_arg(list, uintptr);
 	s = seg(up, from, 1);
 	if(s == nil)
 		error(Ebadarg);
-	to = (from + arg[1]) & ~(BY2PG-1);
+	to = va_arg(list, ulong);
+	to += from;
+	to &= ~(BY2PG-1);
 	from = PGROUND(from);
 
 	if(to > s->top) {
@@ -816,24 +838,24 @@ syssegfree(ulong *arg)
 	mfreeseg(s, from, (to - from) / BY2PG);
 	qunlock(&s->lk);
 	flushmmu();
-
 	return 0;
 }
 
 /* For binary compatibility */
-long
-sysbrk_(ulong *arg)
+uintptr
+sysbrk_(va_list list)
 {
-	return ibrk(arg[0], BSEG);
+	return (uintptr)ibrk(va_arg(list, uintptr), BSEG);
 }
 
-long
-sysrendezvous(ulong *arg)
+uintptr
+sysrendezvous(va_list list)
 {
-	uintptr tag, val;
+	uintptr tag, val, new;
 	Proc *p, **l;
 
-	tag = arg[0];
+	tag = va_arg(list, uintptr);
+	new = va_arg(list, uintptr);
 	l = &REND(up->rgrp, tag);
 
 	lock(up->rgrp);
@@ -841,7 +863,7 @@ sysrendezvous(ulong *arg)
 		if(p->rendtag == tag) {
 			*l = p->rendhash;
 			val = p->rendval;
-			p->rendval = arg[1];
+			p->rendval = new;
 			unlock(up->rgrp);
 
 			ready(p);
@@ -853,7 +875,7 @@ sysrendezvous(ulong *arg)
 
 	/* Going to sleep here */
 	up->rendtag = tag;
-	up->rendval = arg[1];
+	up->rendval = new;
 	up->rendhash = *l;
 	*l = up;
 	up->state = Rendezvous;
@@ -1102,65 +1124,62 @@ tsemacquire(Segment *s, long *addr, ulong ms)
 	return 1;
 }
 
-long
-syssemacquire(ulong *arg)
+uintptr
+syssemacquire(va_list list)
 {
 	int block;
 	long *addr;
 	Segment *s;
 
-	evenaddr(arg[0]);
-	addr = (long*)arg[0];
-	block = arg[1];
-
-	s = seg(up, (ulong)addr, 0);
-	if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
-		validaddr((ulong)addr, sizeof(long), 1);
+	addr = va_arg(list, long*);
+	block = va_arg(list, int);
+	evenaddr((uintptr)addr);
+	s = seg(up, (uintptr)addr, 0);
+	if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
+		validaddr((uintptr)addr, sizeof(long), 1);
 		error(Ebadarg);
 	}
 	if(*addr < 0)
 		error(Ebadarg);
-	return semacquire(s, addr, block);
+	return (uintptr)semacquire(s, addr, block);
 }
 
-long
-systsemacquire(ulong *arg)
+uintptr
+systsemacquire(va_list list)
 {
 	long *addr;
 	ulong ms;
 	Segment *s;
 
-	evenaddr(arg[0]);
-	addr = (long*)arg[0];
-	ms = arg[1];
-
-	s = seg(up, (ulong)addr, 0);
-	if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
-		validaddr((ulong)addr, sizeof(long), 1);
+	addr = va_arg(list, long*);
+	ms = va_arg(list, ulong);
+	evenaddr((uintptr)addr);
+	s = seg(up, (uintptr)addr, 0);
+	if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
+		validaddr((uintptr)addr, sizeof(long), 1);
 		error(Ebadarg);
 	}
 	if(*addr < 0)
 		error(Ebadarg);
-	return tsemacquire(s, addr, ms);
+	return (uintptr)tsemacquire(s, addr, ms);
 }
 
-long
-syssemrelease(ulong *arg)
+uintptr
+syssemrelease(va_list list)
 {
 	long *addr, delta;
 	Segment *s;
 
-	evenaddr(arg[0]);
-	addr = (long*)arg[0];
-	delta = arg[1];
-
-	s = seg(up, (ulong)addr, 0);
-	if(s == nil || (s->type&SG_RONLY) != 0 || (ulong)addr+sizeof(long) > s->top){
-		validaddr((ulong)addr, sizeof(long), 1);
+	addr = va_arg(list, long*);
+	delta = va_arg(list, long);
+	evenaddr((uintptr)addr);
+	s = seg(up, (uintptr)addr, 0);
+	if(s == nil || (s->type&SG_RONLY) != 0 || (uintptr)addr+sizeof(long) > s->top){
+		validaddr((uintptr)addr, sizeof(long), 1);
 		error(Ebadarg);
 	}
 	/* delta == 0 is a no-op, not a release */
 	if(delta < 0 || *addr < 0)
 		error(Ebadarg);
-	return semrelease(s, addr, delta);
+	return (uintptr)semrelease(s, addr, delta);
 }
diff --git a/sys/src/9/port/systab.h b/sys/src/9/port/systab.h
index c80b55508..3ac2e960a 100644
--- a/sys/src/9/port/systab.h
+++ b/sys/src/9/port/systab.h
@@ -1,6 +1,6 @@
 #include "/sys/src/libc/9syscall/sys.h"
 
-typedef long Syscall(ulong*);
+typedef uintptr Syscall(va_list);
 
 Syscall sysr1;
 Syscall sys_errstr;
diff --git a/sys/src/9/port/taslock.c b/sys/src/9/port/taslock.c
index b93aaf832..641b84d16 100644
--- a/sys/src/9/port/taslock.c
+++ b/sys/src/9/port/taslock.c
@@ -51,12 +51,12 @@ dumplockmem(char *tag, Lock *l)
 }
 
 void
-lockloop(Lock *l, ulong pc)
+lockloop(Lock *l, uintptr pc)
 {
 	Proc *p;
 
 	p = l->p;
-	print("lock %#p loop key %#lux pc %#lux held by pc %#lux proc %lud\n",
+	print("lock %#p loop key %#lux pc %#p held by pc %#p proc %lud\n",
 		l, l->key, pc, l->pc, p ? p->pid : 0);
 	dumpaproc(up);
 	if(p != nil)
@@ -67,7 +67,7 @@ int
 lock(Lock *l)
 {
 	int i;
-	ulong pc;
+	uintptr pc;
 
 	pc = getcallerpc(&l);
 
@@ -98,7 +98,7 @@ lock(Lock *l)
 				 * Priority inversion, yield on a uniprocessor; on a
 				 * multiprocessor, the other processor will unlock
 				 */
-				print("inversion %#p pc %#lux proc %lud held by pc %#lux proc %lud\n",
+				print("inversion %#p pc %#p proc %lud held by pc %#p proc %lud\n",
 					l, pc, up ? up->pid : 0, l->pc, l->p ? l->p->pid : 0);
 				up->edf->d = todget(nil);	/* yield to process with lock */
 			}
@@ -129,7 +129,7 @@ void
 ilock(Lock *l)
 {
 	ulong x;
-	ulong pc;
+	uintptr pc;
 
 	pc = getcallerpc(&l);
 	lockstats.locks++;
@@ -203,9 +203,9 @@ unlock(Lock *l)
 	if(l->key == 0)
 		print("unlock: not locked: pc %#p\n", getcallerpc(&l));
 	if(l->isilock)
-		print("unlock of ilock: pc %lux, held by %lux\n", getcallerpc(&l), l->pc);
+		print("unlock of ilock: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
 	if(l->p != up)
-		print("unlock: up changed: pc %#p, acquired at pc %lux, lock p %#p, unlock up %#p\n", getcallerpc(&l), l->pc, l->p, up);
+		print("unlock: up changed: pc %#p, acquired at pc %#p, lock p %#p, unlock up %#p\n", getcallerpc(&l), l->pc, l->p, up);
 	l->m = nil;
 	l->key = 0;
 	coherence();
@@ -240,9 +240,9 @@ iunlock(Lock *l)
 	if(l->key == 0)
 		print("iunlock: not locked: pc %#p\n", getcallerpc(&l));
 	if(!l->isilock)
-		print("iunlock of lock: pc %#p, held by %#lux\n", getcallerpc(&l), l->pc);
+		print("iunlock of lock: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
 	if(islo())
-		print("iunlock while lo: pc %#p, held by %#lux\n", getcallerpc(&l), l->pc);
+		print("iunlock while lo: pc %#p, held by %#p\n", getcallerpc(&l), l->pc);
 
 	sr = l->sr;
 	l->m = nil;
diff --git a/sys/src/9/ppc/mmu.c b/sys/src/9/ppc/mmu.c
index c2997072e..589f251c8 100644
--- a/sys/src/9/ppc/mmu.c
+++ b/sys/src/9/ppc/mmu.c
@@ -262,7 +262,7 @@ putmmu(ulong va, ulong pa, Page *pg)
 }
 
 void
-checkmmu(ulong, ulong)
+checkmmu(uintptr, uintptr)
 {
 }
 
diff --git a/sys/src/9/ppc/trap.c b/sys/src/9/ppc/trap.c
index 7fd90f302..5099b4d14 100644
--- a/sys/src/9/ppc/trap.c
+++ b/sys/src/9/ppc/trap.c
@@ -525,8 +525,8 @@ evenaddr(ulong addr)
 	}
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;
@@ -559,7 +559,7 @@ forkchild(Proc *p, Ureg *ur)
 	p->insyscall = 0;
 }
 
-ulong
+uintptr
 userpc(void)
 {
 	Ureg *ureg;
@@ -593,7 +593,7 @@ setkernur(Ureg* ureg, Proc* p)
 	ureg->sp = p->sched.sp+4;
 }
 
-ulong
+uintptr
 dbgpc(Proc *p)
 {
 	Ureg *ureg;
@@ -651,7 +651,7 @@ syscall(Ureg* ureg)
 		up->s = *((Sargs*)(sp+BY2WD));
 		up->psstate = sysctab[scallnr];
 
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
diff --git a/sys/src/9/teg2/syscall.c b/sys/src/9/teg2/syscall.c
index c8becce22..3a1b42b0e 100644
--- a/sys/src/9/teg2/syscall.c
+++ b/sys/src/9/teg2/syscall.c
@@ -248,7 +248,7 @@ syscall(Ureg* ureg)
 
 	/*	iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
 
-		ret = systab[scallnr](up->s.args);
+		ret = systab[scallnr]((va_list)up->s.args);
 		poperror();
 	}else{
 		/* failure: save the error buffer for errstr */
@@ -304,8 +304,8 @@ syscall(Ureg* ureg)
 	kexit(ureg);
 }
 
-long
-execregs(ulong entry, ulong ssize, ulong nargs)
+uintptr
+execregs(uintptr entry, ulong ssize, ulong nargs)
 {
 	ulong *sp;
 	Ureg *ureg;