shithub: riscv

Download patch

ref: b7b3406657ef87fef57c3b639296d5cd33a5c3ae
parent: 0cdb32cc18b953fd22e86ba6fc6e24787f254576
author: cinap_lenrek <cinap_lenrek@felloff.net>
date: Sun Feb 2 11:03:59 EST 2014 

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.


--- a/sys/src/9/port/alloc.c
+++ b/sys/src/9/port/alloc.c
@@ -135,7 +135,7 @@
 /* - 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 @@
 	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 @@
 		}
 	}
 	if(Npadlong){
-		v = (uintptr*)v+Npadlong;
+		v = (ulong*)v+Npadlong;
 		setmalloctag(v, getcallerpc(&size));
 	}
 	memset(v, 0, size);
@@ -192,11 +192,11 @@
 {
 	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 @@
 {
 	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 @@
 {
 	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 @@
 free(void *v)
 {
 	if(v != nil)
-		poolfree(mainmem, (uintptr*)v-Npadlong);
+		poolfree(mainmem, (ulong*)v-Npadlong);
 }
 
 void*
@@ -249,12 +249,12 @@
 	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 @@
 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 @@
 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 @@
 	USED(v);
 	if(Npadlong <= MallocOffset)
 		return ~0;
-	return ((uintptr*)v)[-Npadlong+MallocOffset];
+	return (int)((ulong*)v)[-Npadlong+MallocOffset];
 }
 
 uintptr
@@ -313,6 +309,6 @@
 {
 	USED(v);
 	if(Npadlong <= ReallocOffset)
-		return ((uintptr*)v)[-Npadlong+ReallocOffset];
-	return ~0;
+		return ~0;
+	return (int)((ulong*)v)[-Npadlong+ReallocOffset];
 }
--- a/sys/src/libc/port/malloc.c
+++ b/sys/src/libc/port/malloc.c
@@ -170,7 +170,7 @@
 /* - 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 @@
 {
 	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 @@
 {
 	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 @@
 {
 	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 @@
 free(void *v)
 {
 	if(v != nil)
-		poolfree(mainmem, (uintptr*)v-Npadlong);
+		poolfree(mainmem, (ulong*)v-Npadlong);
 }
 
 void*
@@ -261,11 +261,11 @@
 	}
 
 	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 @@
 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 @@
 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 @@
 	USED(v);
 	if(Npadlong <= MallocOffset)
 		return ~0;
-	return ((uintptr*)v)[-Npadlong+MallocOffset];
+	return (int)((ulong*)v)[-Npadlong+MallocOffset];
 }
 
 uintptr
@@ -327,8 +323,8 @@
 {
 	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 @@
 {
 	if(v == nil)
 		return nil;
-
-	return &((uintptr*)v)[-Npadlong];
+	return &((ulong*)v)[-Npadlong];
 }
-- 
⑨