runtime: fix 32-bit malloc for pointers >= 0x80000000

The spans array is allocated in runtime_mallocinit.  On a
32-bit system the number of entries in the spans array is
MaxArena32 / PageSize, which (2U << 30) / (1 << 12) == (1 << 19).
So we are allocating an array that can hold 19 bits for an
index that can hold 20 bits.  According to the comment in the
function, this is intentional: we only allocate enough spans
(and bitmaps) for a 2G arena, because allocating more would
probably be wasteful.

But since the span index is simply the upper 20 bits of the
memory address, this scheme only works if memory addresses are
limited to the low 2G of memory.  That would be OK if we were
careful to enforce it, but we're not.  What we are careful to
enforce, in functions like runtime_MHeap_SysAlloc, is that we
always return addresses between the heap's arena_start and
arena_start + MaxArena32.

We generally get away with it because we start allocating just
after the program end, so we only run into trouble with
programs that allocate a lot of memory, enough to get past
address 0x80000000.

This changes the code that computes a span index to subtract
arena_start on 32-bit systems just as we currently do on
64-bit systems.

From-SVN: r206501

diff --git a/libgo/runtime/malloc.goc b/libgo/runtime/malloc.goc
index b8b4a2dc373b04bda78019b0a4e78d6372744c09..a06dd11811f1ab4efc401996ebea9ea065894db7 100644 (file)
--- a/libgo/runtime/malloc.goc
+++ b/libgo/runtime/malloc.goc
@@ -637,8 +637,7 @@ runtime_settype_flush(M *mp)
 
                // (Manually inlined copy of runtime_MHeap_Lookup)
                p = (uintptr)v>>PageShift;
-               if(sizeof(void*) == 8)
-                       p -= (uintptr)runtime_mheap.arena_start >> PageShift;
+               p -= (uintptr)runtime_mheap.arena_start >> PageShift;
                s = runtime_mheap.spans[p];
 
                if(s->sizeclass == 0) {

diff --git a/libgo/runtime/mgc0.c b/libgo/runtime/mgc0.c
index 865f19304892da39e28e1b3811dbd51d2dfbd81c..8ceece37b5afb89d17462d24b2b3684eb13055fb 100644 (file)
--- a/libgo/runtime/mgc0.c
+++ b/libgo/runtime/mgc0.c
@@ -269,8 +269,7 @@ markonly(void *obj)
        // (Manually inlined copy of MHeap_LookupMaybe.)
        k = (uintptr)obj>>PageShift;
        x = k;
-       if(sizeof(void*) == 8)
-               x -= (uintptr)runtime_mheap.arena_start>>PageShift;
+       x -= (uintptr)runtime_mheap.arena_start>>PageShift;
        s = runtime_mheap.spans[x];
        if(s == nil || k < s->start || (byte*)obj >= s->limit || s->state != MSpanInUse)
                return false;
@@ -453,8 +452,7 @@ flushptrbuf(PtrTarget *ptrbuf, PtrTarget **ptrbufpos, Obj **_wp, Workbuf **_wbuf
                        // (Manually inlined copy of MHeap_LookupMaybe.)
                        k = (uintptr)obj>>PageShift;
                        x = k;
-                       if(sizeof(void*) == 8)
-                               x -= (uintptr)arena_start>>PageShift;
+                       x -= (uintptr)arena_start>>PageShift;
                        s = runtime_mheap.spans[x];
                        if(s == nil || k < s->start || obj >= s->limit || s->state != MSpanInUse)
                                continue;
@@ -501,8 +499,7 @@ flushptrbuf(PtrTarget *ptrbuf, PtrTarget **ptrbufpos, Obj **_wp, Workbuf **_wbuf
                        // Ask span about size class.
                        // (Manually inlined copy of MHeap_Lookup.)
                        x = (uintptr)obj >> PageShift;
-                       if(sizeof(void*) == 8)
-                               x -= (uintptr)arena_start>>PageShift;
+                       x -= (uintptr)arena_start>>PageShift;
                        s = runtime_mheap.spans[x];
 
                        PREFETCH(obj);
@@ -617,8 +614,7 @@ checkptr(void *obj, uintptr objti)
        if(t == nil)
                return;
        x = (uintptr)obj >> PageShift;
-       if(sizeof(void*) == 8)
-               x -= (uintptr)(runtime_mheap.arena_start)>>PageShift;
+       x -= (uintptr)(runtime_mheap.arena_start)>>PageShift;
        s = runtime_mheap.spans[x];
        objstart = (byte*)((uintptr)s->start<<PageShift);
        if(s->sizeclass != 0) {

diff --git a/libgo/runtime/mheap.c b/libgo/runtime/mheap.c
index 62070f37943faa862253a66b84513eba34be7a9c..fee493c1367f09f9495c2d3fc689b89ef1ddfb3c 100644 (file)
--- a/libgo/runtime/mheap.c
+++ b/libgo/runtime/mheap.c
@@ -73,8 +73,7 @@ runtime_MHeap_MapSpans(MHeap *h)
 
        // Map spans array, PageSize at a time.
        n = (uintptr)h->arena_used;
-       if(sizeof(void*) == 8)
-               n -= (uintptr)h->arena_start;
+       n -= (uintptr)h->arena_start;
        n = n / PageSize * sizeof(h->spans[0]);
        n = ROUND(n, PageSize);
        pagesize = getpagesize();
@@ -170,8 +169,7 @@ HaveSpan:
                runtime_MSpan_Init(t, s->start + npage, s->npages - npage);
                s->npages = npage;
                p = t->start;
-               if(sizeof(void*) == 8)
-                       p -= ((uintptr)h->arena_start>>PageShift);
+               p -= ((uintptr)h->arena_start>>PageShift);
                if(p > 0)
                        h->spans[p-1] = s;
                h->spans[p] = t;
@@ -189,8 +187,7 @@ HaveSpan:
        s->elemsize = (sizeclass==0 ? s->npages<<PageShift : (uintptr)runtime_class_to_size[sizeclass]);
        s->types.compression = MTypes_Empty;
        p = s->start;
-       if(sizeof(void*) == 8)
-               p -= ((uintptr)h->arena_start>>PageShift);
+       p -= ((uintptr)h->arena_start>>PageShift);
        for(n=0; n<npage; n++)
                h->spans[p+n] = s;
        return s;
@@ -258,8 +255,7 @@ MHeap_Grow(MHeap *h, uintptr npage)
        s = runtime_FixAlloc_Alloc(&h->spanalloc);
        runtime_MSpan_Init(s, (uintptr)v>>PageShift, ask>>PageShift);
        p = s->start;
-       if(sizeof(void*) == 8)
-               p -= ((uintptr)h->arena_start>>PageShift);
+       p -= ((uintptr)h->arena_start>>PageShift);
        h->spans[p] = s;
        h->spans[p + s->npages - 1] = s;
        s->state = MSpanInUse;
@@ -276,8 +272,7 @@ runtime_MHeap_Lookup(MHeap *h, void *v)
        uintptr p;
        
        p = (uintptr)v;
-       if(sizeof(void*) == 8)
-               p -= (uintptr)h->arena_start;
+       p -= (uintptr)h->arena_start;
        return h->spans[p >> PageShift];
 }
 
@@ -298,8 +293,7 @@ runtime_MHeap_LookupMaybe(MHeap *h, void *v)
                return nil;
        p = (uintptr)v>>PageShift;
        q = p;
-       if(sizeof(void*) == 8)
-               q -= (uintptr)h->arena_start >> PageShift;
+       q -= (uintptr)h->arena_start >> PageShift;
        s = h->spans[q];
        if(s == nil || p < s->start || (byte*)v >= s->limit || s->state != MSpanInUse)
                return nil;
@@ -346,8 +340,7 @@ MHeap_FreeLocked(MHeap *h, MSpan *s)
 
        // Coalesce with earlier, later spans.
        p = s->start;
-       if(sizeof(void*) == 8)
-               p -= (uintptr)h->arena_start >> PageShift;
+       p -= (uintptr)h->arena_start >> PageShift;
        if(p > 0 && (t = h->spans[p-1]) != nil && t->state != MSpanInUse) {
                if(t->npreleased == 0) {  // cant't touch this otherwise
                        tp = (uintptr*)(t->start<<PageShift);