malloctag: only store lower 32bit of malloc tag, fix getrealloctag

as erik quanstro suggests, theres not much of a point in
storing the full 64bit pc as one cannot get a code segment
bigger than 4G and amd64 makes it hard to use a pc that
isnt 64bit sign extension of 32bit.

instead, we only store ulong (as originally), but sign
extend back when returning in getmalloctag() and
getrealloctag().

getrealloctag() used to be broken. its now fixed.

2 files changed, 37 insertions, 46 deletions

diff --git a/sys/src/9/port/alloc.c b/sys/src/9/port/alloc.c
index b88475e66..fd3e41690 100644
--- a/sys/src/9/port/alloc.c
+++ b/sys/src/9/port/alloc.c
@@ -135,7 +135,7 @@ mallocsummary(void)
 /* - except the code for smalloc(), which lives only in the kernel. */
 
 /*
- * Npadlong is the number of uintptr's to leave at the beginning of 
+ * Npadlong is the number of ulong's to leave at the beginning of 
  * each allocated buffer for our own bookkeeping.  We return to the callers
  * a pointer that points immediately after our bookkeeping area.  Incoming pointers
  * must be decremented by that much, and outgoing pointers incremented.
@@ -171,7 +171,7 @@ smalloc(ulong size)
 	void *v;
 
 	for(;;) {
-		v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr));
+		v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
 		if(v != nil)
 			break;
 		if(!waserror()){
@@ -180,7 +180,7 @@ smalloc(ulong size)
 		}
 	}
 	if(Npadlong){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 	}
 	memset(v, 0, size);
@@ -192,11 +192,11 @@ malloc(ulong size)
 {
 	void *v;
 
-	v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr));
+	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
 	if(v == nil)
 		return nil;
 	if(Npadlong){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -209,9 +209,9 @@ mallocz(ulong size, int clr)
 {
 	void *v;
 
-	v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr));
+	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
 	if(Npadlong && v != nil){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -225,9 +225,9 @@ mallocalign(ulong size, ulong align, long offset, ulong span)
 {
 	void *v;
 
-	v = poolallocalign(mainmem, size+Npadlong*sizeof(uintptr), align, offset-Npadlong*sizeof(uintptr), span);
+	v = poolallocalign(mainmem, size+Npadlong*sizeof(ulong), align, offset-Npadlong*sizeof(ulong), span);
 	if(Npadlong && v != nil){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -240,7 +240,7 @@ void
 free(void *v)
 {
 	if(v != nil)
-		poolfree(mainmem, (uintptr*)v-Npadlong);
+		poolfree(mainmem, (ulong*)v-Npadlong);
 }
 
 void*
@@ -249,12 +249,12 @@ realloc(void *v, ulong size)
 	void *nv;
 
 	if(v != nil)
-		v = (uintptr*)v-Npadlong;
+		v = (ulong*)v-Npadlong;
 	if(Npadlong !=0 && size != 0)
-		size += Npadlong*sizeof(uintptr);
+		size += Npadlong*sizeof(ulong);
 
 	if(nv = poolrealloc(mainmem, v, size)){
-		nv = (uintptr*)nv+Npadlong;
+		nv = (ulong*)nv+Npadlong;
 		setrealloctag(nv, getcallerpc(&v));
 		if(v == nil)
 			setmalloctag(nv, getcallerpc(&v));
@@ -265,7 +265,7 @@ realloc(void *v, ulong size)
 ulong
 msize(void *v)
 {
-	return poolmsize(mainmem, (uintptr*)v-Npadlong)-Npadlong*sizeof(uintptr);
+	return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong);
 }
 
 void*
@@ -280,23 +280,19 @@ calloc(ulong n, ulong szelem)
 void
 setmalloctag(void *v, uintptr pc)
 {
-	uintptr *u;
 	USED(v, pc);
 	if(Npadlong <= MallocOffset || v == nil)
 		return;
-	u = v;
-	u[-Npadlong+MallocOffset] = pc;
+	((ulong*)v)[-Npadlong+MallocOffset] = (ulong)pc;
 }
 
 void
 setrealloctag(void *v, uintptr pc)
 {
-	uintptr *u;
 	USED(v, pc);
 	if(Npadlong <= ReallocOffset || v == nil)
 		return;
-	u = v;
-	u[-Npadlong+ReallocOffset] = pc;
+	((ulong*)v)[-Npadlong+ReallocOffset] = (ulong)pc;
 }
 
 uintptr
@@ -305,7 +301,7 @@ getmalloctag(void *v)
 	USED(v);
 	if(Npadlong <= MallocOffset)
 		return ~0;
-	return ((uintptr*)v)[-Npadlong+MallocOffset];
+	return (int)((ulong*)v)[-Npadlong+MallocOffset];
 }
 
 uintptr
@@ -313,6 +309,6 @@ getrealloctag(void *v)
 {
 	USED(v);
 	if(Npadlong <= ReallocOffset)
-		return ((uintptr*)v)[-Npadlong+ReallocOffset];
-	return ~0;
+		return ~0;
+	return (int)((ulong*)v)[-Npadlong+ReallocOffset];
 }
diff --git a/sys/src/libc/port/malloc.c b/sys/src/libc/port/malloc.c
index 59fad21a6..af52dce42 100644
--- a/sys/src/libc/port/malloc.c
+++ b/sys/src/libc/port/malloc.c
@@ -170,7 +170,7 @@ ppanic(Pool *p, char *fmt, ...)
 /* - except the code for malloc(), which alternately doesn't clear or does. - */
 
 /*
- * Npadlong is the number of uintptr's to leave at the beginning of 
+ * Npadlong is the number of ulongs's to leave at the beginning of 
  * each allocated buffer for our own bookkeeping.  We return to the callers
  * a pointer that points immediately after our bookkeeping area.  Incoming pointers
  * must be decremented by that much, and outgoing pointers incremented.
@@ -204,9 +204,9 @@ malloc(ulong size)
 {
 	void *v;
 
-	v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr));
+	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
 	if(Npadlong && v != nil) {
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -218,9 +218,9 @@ mallocz(ulong size, int clr)
 {
 	void *v;
 
-	v = poolalloc(mainmem, size+Npadlong*sizeof(uintptr));
+	v = poolalloc(mainmem, size+Npadlong*sizeof(ulong));
 	if(Npadlong && v != nil){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -234,9 +234,9 @@ mallocalign(ulong size, ulong align, long offset, ulong span)
 {
 	void *v;
 
-	v = poolallocalign(mainmem, size+Npadlong*sizeof(uintptr), align, offset-Npadlong*sizeof(uintptr), span);
+	v = poolallocalign(mainmem, size+Npadlong*sizeof(ulong), align, offset-Npadlong*sizeof(ulong), span);
 	if(Npadlong && v != nil){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 		setrealloctag(v, 0);
 	}
@@ -247,7 +247,7 @@ void
 free(void *v)
 {
 	if(v != nil)
-		poolfree(mainmem, (uintptr*)v-Npadlong);
+		poolfree(mainmem, (ulong*)v-Npadlong);
 }
 
 void*
@@ -261,11 +261,11 @@ realloc(void *v, ulong size)
 	}
 
 	if(v)
-		v = (uintptr*)v-Npadlong;
-	size += Npadlong*sizeof(uintptr);
+		v = (ulong*)v-Npadlong;
+	size += Npadlong*sizeof(ulong);
 
 	if(nv = poolrealloc(mainmem, v, size)){
-		nv = (uintptr*)nv+Npadlong;
+		nv = (ulong*)nv+Npadlong;
 		setrealloctag(nv, getcallerpc(&v));
 		if(v == nil)
 			setmalloctag(nv, getcallerpc(&v));
@@ -276,7 +276,7 @@ realloc(void *v, ulong size)
 ulong
 msize(void *v)
 {
-	return poolmsize(mainmem, (uintptr*)v-Npadlong)-Npadlong*sizeof(uintptr);
+	return poolmsize(mainmem, (ulong*)v-Npadlong)-Npadlong*sizeof(ulong);
 }
 
 void*
@@ -294,23 +294,19 @@ calloc(ulong n, ulong s)
 void
 setmalloctag(void *v, uintptr pc)
 {
-	uintptr *u;
 	USED(v, pc);
 	if(Npadlong <= MallocOffset || v == nil)
 		return;
-	u = v;
-	u[-Npadlong+MallocOffset] = pc;
+	((ulong*)v)[-Npadlong+MallocOffset] = (ulong)pc;
 }
 
 void
 setrealloctag(void *v, uintptr pc)
 {
-	uintptr *u;
 	USED(v, pc);
 	if(Npadlong <= ReallocOffset || v == nil)
 		return;
-	u = v;
-	u[-Npadlong+ReallocOffset] = pc;
+	((ulong*)v)[-Npadlong+ReallocOffset] = (ulong)pc;
 }
 
 uintptr
@@ -319,7 +315,7 @@ getmalloctag(void *v)
 	USED(v);
 	if(Npadlong <= MallocOffset)
 		return ~0;
-	return ((uintptr*)v)[-Npadlong+MallocOffset];
+	return (int)((ulong*)v)[-Npadlong+MallocOffset];
 }
 
 uintptr
@@ -327,8 +323,8 @@ getrealloctag(void *v)
 {
 	USED(v);
 	if(Npadlong <= ReallocOffset)
-		return ((uintptr*)v)[-Npadlong+ReallocOffset];
-	return ~0;
+		return ~0;
+	return (int)((ulong*)v)[-Npadlong+ReallocOffset];
 }
 
 void*
@@ -336,6 +332,5 @@ malloctopoolblock(void *v)
 {
 	if(v == nil)
 		return nil;
-
-	return &((uintptr*)v)[-Npadlong];
+	return &((ulong*)v)[-Npadlong];
 }