fix 386 malloc tests,

detect 386 darwin breakpoint line.

R=r
DELTA=22  (4 added, 0 deleted, 18 changed)
OCL=29929
CL=29944

diff --git a/src/lib/malloc/malloc.go b/src/lib/malloc/malloc.go
index 8e4397a0b141da69ebeb21fbbd464ca4f66db894..fec53f08fd0eca561d8d68ad1168565b71321bb9 100644 (file)
--- a/src/lib/malloc/malloc.go
+++ b/src/lib/malloc/malloc.go
@@ -17,7 +17,7 @@ type Stats struct {
        EnableGC        bool;
 }
 
-func Alloc(uint64) *byte
+func Alloc(uintptr) *byte
 func Free(*byte)
 func GetStats() *Stats
 func Lookup(*byte) (*byte, uintptr)

diff --git a/src/runtime/mgc0.c b/src/runtime/mgc0.c
index 71f5fc98078c838eaabd9ac466c5e3db43a78c29..d58d6ce44d14027fae4f58663e3fa62acd09f006 100644 (file)
--- a/src/runtime/mgc0.c
+++ b/src/runtime/mgc0.c
@@ -212,7 +212,7 @@ gc(int32 force)
                else
                        gcpercent = atoi(p);
        }
-       if(gcpercent < 0 || sizeof(void*) == 4) // TODO(rsc): broken on 32-bit right now
+       if(gcpercent < 0)
                return;
 
        semacquire(&gcsema);

diff --git a/test/mallocrand.go b/test/mallocrand.go
index b933f6be450efb2dfec7c609803e3ba6d8b13890..59da01d44c531bd2f114aa3317511b0e2f545d15 100644 (file)
--- a/test/mallocrand.go
+++ b/test/mallocrand.go
@@ -39,13 +39,13 @@ func prime() {
                b := malloc.Alloc(1<<uint(i));
                malloc.Free(b);
        }
-       for i := uint64(0); i < 256; i++ {
+       for i := uintptr(0); i < 256; i++ {
                b := malloc.Alloc(i<<12);
                malloc.Free(b);
        }
 }
 
-func memset(b *byte, c byte, n uint64) {
+func memset(b *byte, c byte, n uintptr) {
        np := uintptr(n);
        for i := uintptr(0); i < np; i++ {
                *(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b))+i)) = c;
@@ -55,7 +55,7 @@ func memset(b *byte, c byte, n uint64) {
 func main() {
        flag.Parse();
 //     prime();
-       var blocks [1] struct { base *byte; siz uint64; };
+       var blocks [1] struct { base *byte; siz uintptr; };
        for i := 0; i < 1<<12; i++ {
                if i%(1<<10) == 0 && *chatty {
                        println(i);
@@ -65,19 +65,19 @@ func main() {
                //      println("Free", blocks[b].siz, blocks[b].base);
                        malloc.Free(blocks[b].base);
                        blocks[b].base = nil;
-                       allocated -= blocks[b].siz;
+                       allocated -= uint64(blocks[b].siz);
                        continue
                }
-               siz := uint64(rand.Int() >> (11 + rand.Uint32() % 20));
+               siz := uintptr(rand.Int() >> (11 + rand.Uint32() % 20));
                base := malloc.Alloc(siz);
-       //      ptr := uint64(syscall.BytePtr(base))+uint64(siz/2);
+       //      ptr := uintptr(syscall.BytePtr(base))+uintptr(siz/2);
        //      obj, size, ref, ok := allocator.find(ptr);
        //      if obj != base || *ref != 0 || !ok {
        //              panicln("find", siz, obj, ref, ok);
        //      }
                blocks[b].base = base;
                blocks[b].siz = siz;
-               allocated += siz;
+               allocated += uint64(siz);
        //      println("Alloc", siz, base);
                memset(base, 0xbb, siz);
                bigger();

diff --git a/test/mallocrep.go b/test/mallocrep.go
index 6aa8fdf8cbde67b2d1c9933d78fb5868eddf2531..6306e59ebc00b351854b71391378d5d18759eb32 100644 (file)
--- a/test/mallocrep.go
+++ b/test/mallocrep.go
@@ -36,11 +36,14 @@ func main() {
                        if i == 0 && *chatty {
                                println("First alloc:", j);
                        }
-                       b := malloc.Alloc(uint64(j));
+                       if a := malloc.GetStats().Alloc; a != 0 {
+                               panicln("no allocations but stats report", a, "bytes allocated");
+                       }
+                       b := malloc.Alloc(uintptr(j));
                        during := malloc.GetStats().Alloc;
                        malloc.Free(b);
                        if a := malloc.GetStats().Alloc; a != 0 {
-                               panicln("malloc wrong count", a, "after", j, "during", during);
+                               panic("allocated ", j, ": wrong stats: during=", during, " after=", a, " (want 0)");
                        }
                        bigger();
                }

diff --git a/test/mallocrep1.go b/test/mallocrep1.go
index 5d17dc2c6d1e55e507d8b430d4ffdf89b3b112bc..e78a9ce9ca524875c293e4364943ae1c5e38f0c4 100644 (file)
--- a/test/mallocrep1.go
+++ b/test/mallocrep1.go
@@ -44,7 +44,7 @@ func AllocAndFree(size, count int) {
        }
        n1 := stats.Alloc;
        for i := 0; i < count; i++ {
-               b[i] = malloc.Alloc(uint64(size));
+               b[i] = malloc.Alloc(uintptr(size));
                base, n := malloc.Lookup(b[i]);
                if base != b[i] || !OkAmount(uintptr(size), n) {
                        panicln("lookup failed: got", base, n, "for", b[i]);
@@ -63,14 +63,14 @@ func AllocAndFree(size, count int) {
                if *reverse {
                        i = count - 1 - j;
                }
-               alloc := stats.Alloc;
+               alloc := uintptr(stats.Alloc);
                base, n := malloc.Lookup(b[i]);
                if base != b[i] || !OkAmount(uintptr(size), n) {
                        panicln("lookup failed: got", base, n, "for", b[i]);
                }
                malloc.Free(b[i]);
-               if stats.Alloc != alloc - uint64(n) {
-                       panicln("free alloc got", stats.Alloc, "expected", alloc - uint64(n), "after free of", n);
+               if stats.Alloc != uint64(alloc - n) {
+                       panicln("free alloc got", stats.Alloc, "expected", alloc - n, "after free of", n);
                }
                if malloc.GetStats().Sys > 1e9 {
                        panicln("too much memory allocated");
@@ -100,12 +100,12 @@ func main() {
        }
        for j := 1; j <= 1<<22; j<<=1 {
                n := len(b);
-               max := uint64(1<<28);
+               max := uintptr(1<<28);
                if !*longtest {
                        max = 1<<22;
                }
-               if uint64(j)*uint64(n) > max {
-                       n = int(max / uint64(j));
+               if uintptr(j)*uintptr(n) > max {
+                       n = int(max / uintptr(j));
                }
                if n < 10 {
                        n = 10;

diff --git a/test/run b/test/run
index 5724449acbb96ae3ada0eaf942edd71cb9eac0b3..63dca3b42aaf8dc19a026f55f93bc8dcf1fe849a 100755 (executable)
--- a/test/run
+++ b/test/run
@@ -67,6 +67,7 @@ done | # clean up some stack noise
                s/ PC=0x[0-9a-f]*/ PC=xxx/
                s/^pc: 0x[0-9a-f]*/pc: xxx/
                /^Trace\/breakpoint trap/d
+               /^Trace\/BPT trap/d
                /RUNFILE/ s/line 1: *[0-9]*/line 1: PID/
                /^\$RUNFILE: line 1: PID Trace\/breakpoint trap/d' > run.out