runtime: change PC, SP values in Stkframe, Panic, Defer from byte* to uintptr

uintptr is better when translating to Go,
and in a few places it's better in C too.

LGTM=r
R=golang-codereviews, r
CC=golang-codereviews, iant, khr
https://golang.org/cl/138980043

diff --git a/src/pkg/runtime/heapdump.c b/src/pkg/runtime/heapdump.c
index 29a9ae6476086428448c15ae024e651f31ca4429..59639c1afe46532f8dce46f63cefdf623c3dd639 100644 (file)
--- a/src/pkg/runtime/heapdump.c
+++ b/src/pkg/runtime/heapdump.c
@@ -309,7 +309,7 @@ dumpframe(Stkframe *s, void *arg)
                dumpbvtypes(&child->args, (byte*)s->sp + child->argoff);
        if(stackmap != nil && stackmap->n > 0) {
                bv = runtime·stackmapdata(stackmap, pcdata);
-               dumpbvtypes(&bv, s->varp - bv.n / BitsPerPointer * PtrSize);
+               dumpbvtypes(&bv, (byte*)(s->varp - bv.n / BitsPerPointer * PtrSize));
        } else {
                bv.n = -1;
        }
@@ -342,26 +342,26 @@ dumpframe(Stkframe *s, void *arg)
        // Dump fields in the local vars section
        if(stackmap == nil) {
                // No locals information, dump everything.
-               for(off = child->arglen; off < s->varp - (byte*)s->sp; off += PtrSize) {
+               for(off = child->arglen; off < s->varp - s->sp; off += PtrSize) {
                        dumpint(FieldKindPtr);
                        dumpint(off);
                }
        } else if(stackmap->n < 0) {
                // Locals size information, dump just the locals.
                size = -stackmap->n;
-               for(off = s->varp - size - (byte*)s->sp; off < s->varp - (byte*)s->sp; off += PtrSize) {
+               for(off = s->varp - size - s->sp; off <  s->varp - s->sp; off += PtrSize) {
                        dumpint(FieldKindPtr);
                        dumpint(off);
                }
        } else if(stackmap->n > 0) {
                // Locals bitmap information, scan just the pointers in
                // locals.
-               dumpbv(&bv, s->varp - bv.n / BitsPerPointer * PtrSize - (byte*)s->sp);
+               dumpbv(&bv, s->varp - bv.n / BitsPerPointer * PtrSize - s->sp);
        }
        dumpint(FieldKindEol);
 
        // Record arg info for parent.
-       child->argoff = s->argp - (byte*)s->fp;
+       child->argoff = s->argp - s->fp;
        child->arglen = s->arglen;
        child->sp = (byte*)s->sp;
        child->depth++;

diff --git a/src/pkg/runtime/mgc0.c b/src/pkg/runtime/mgc0.c
index 09be02b71e7191e2dbb35c3b0aa7cc4d2bd63ea6..af5abee1924b119e0aeb3e79de1b476ebf6369f4 100644 (file)
--- a/src/pkg/runtime/mgc0.c
+++ b/src/pkg/runtime/mgc0.c
@@ -674,16 +674,16 @@ scanframe(Stkframe *frame, void *unused)
        stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
        if(stackmap == nil) {
                // No locals information, scan everything.
-               size = frame->varp - (byte*)frame->sp;
+               size = frame->varp - frame->sp;
                if(Debug > 2)
-                       runtime·printf("frame %s unsized locals %p+%p\n", runtime·funcname(f), frame->varp-size, size);
-               scanblock(frame->varp - size, size, ScanConservatively);
+                       runtime·printf("frame %s unsized locals %p+%p\n", runtime·funcname(f), (byte*)(frame->varp-size), size);
+               scanblock((byte*)(frame->varp - size), size, ScanConservatively);
        } else if(stackmap->n < 0) {
                // Locals size information, scan just the locals.
                size = -stackmap->n;
                if(Debug > 2)
-                       runtime·printf("frame %s conservative locals %p+%p\n", runtime·funcname(f), frame->varp-size, size);
-               scanblock(frame->varp - size, size, ScanConservatively);
+                       runtime·printf("frame %s conservative locals %p+%p\n", runtime·funcname(f), (byte*)(frame->varp-size), size);
+               scanblock((byte*)(frame->varp - size), size, ScanConservatively);
        } else if(stackmap->n > 0) {
                // Locals bitmap information, scan just the pointers in locals.
                if(pcdata < 0 || pcdata >= stackmap->n) {
@@ -694,7 +694,7 @@ scanframe(Stkframe *frame, void *unused)
                }
                bv = runtime·stackmapdata(stackmap, pcdata);
                size = (bv.n * PtrSize) / BitsPerPointer;
-               scanblock(frame->varp - size, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
+               scanblock((byte*)(frame->varp - size), bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
        }
 
        // Scan arguments.
@@ -702,11 +702,11 @@ scanframe(Stkframe *frame, void *unused)
        stackmap = runtime·funcdata(f, FUNCDATA_ArgsPointerMaps);
        if(stackmap != nil) {
                bv = runtime·stackmapdata(stackmap, pcdata);
-               scanblock(frame->argp, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
+               scanblock((byte*)frame->argp, bv.n/BitsPerPointer*PtrSize, (byte*)bv.data);
        } else {
                if(Debug > 2)
                        runtime·printf("frame %s conservative args %p+%p\n", runtime·funcname(f), frame->argp, (uintptr)frame->arglen);
-               scanblock(frame->argp, frame->arglen, ScanConservatively);
+               scanblock((byte*)frame->argp, frame->arglen, ScanConservatively);
        }
        return true;
 }
@@ -1798,7 +1798,7 @@ getgcmaskcb(Stkframe *frame, void *ctxt)
        Stkframe *frame0;
 
        frame0 = ctxt;
-       if(frame0->sp >= (uintptr)frame->varp - frame->sp && frame0->sp < (uintptr)frame->varp) {
+       if(frame0->sp >= frame->varp - frame->sp && frame0->sp < frame->varp) {
                *frame0 = *frame;
                return false;
        }
@@ -1883,7 +1883,7 @@ runtime·getgcmask(byte *p, Type *t, byte **mask, uintptr *len)
                *len = n/PtrSize;
                *mask = runtime·mallocgc(*len, nil, 0);
                for(i = 0; i < n; i += PtrSize) {
-                       off = (p+i-frame.varp+size)/PtrSize;
+                       off = (p+i-(byte*)frame.varp+size)/PtrSize;
                        bits = (bv.data[off*BitsPerPointer/32] >> ((off*BitsPerPointer)%32))&BitsMask;
                        (*mask)[i/PtrSize] = bits;
                }

diff --git a/src/pkg/runtime/panic.c b/src/pkg/runtime/panic.c
index 39027a77c2eae30da4f65e89c6a097c952f3465a..ecf411133763eb1b00c4e8e1f859553b073ddfca 100644 (file)
--- a/src/pkg/runtime/panic.c
+++ b/src/pkg/runtime/panic.c
@@ -85,12 +85,12 @@ runtime·deferproc(int32 siz, FuncVal *fn, ...)
 
        d = newdefer(siz);
        d->fn = fn;
-       d->pc = runtime·getcallerpc(&siz);
+       d->pc = (uintptr)runtime·getcallerpc(&siz);
        if(thechar == '5')
-               d->argp = (byte*)(&fn+2);  // skip caller's saved link register
+               d->argp = (uintptr)(&fn+2);  // skip caller's saved link register
        else
-               d->argp = (byte*)(&fn+1);
-       runtime·memmove(d->args, d->argp, d->siz);
+               d->argp = (uintptr)(&fn+1);
+       runtime·memmove(d->args, (byte*)d->argp, d->siz);
 
        // deferproc returns 0 normally.
        // a deferred func that stops a panic
@@ -119,13 +119,13 @@ void
 runtime·deferreturn(uintptr arg0)
 {
        Defer *d;
-       byte *argp;
+       uintptr argp;
        FuncVal *fn;
 
        d = g->defer;
        if(d == nil)
                return;
-       argp = (byte*)&arg0;
+       argp = (uintptr)&arg0;
        if(d->argp != argp)
                return;
 
@@ -134,7 +134,7 @@ runtime·deferreturn(uintptr arg0)
        // won't know the form of the arguments until the jmpdefer can
        // flip the PC over to fn.
        g->m->locks++;
-       runtime·memmove(argp, d->args, d->siz);
+       runtime·memmove((byte*)argp, d->args, d->siz);
        fn = d->fn;
        g->defer = d->link;
        freedefer(d);
@@ -213,7 +213,7 @@ runtime·panic(Eface e)
 {
        Defer *d, dabort;
        Panic p;
-       void *pc, *argp;
+       uintptr pc, argp;
 
        runtime·memclr((byte*)&p, sizeof p);
        p.arg = e;

diff --git a/src/pkg/runtime/runtime.h b/src/pkg/runtime/runtime.h
index 80366a549dce4b2fc6283aaf8c5bdb242d8f4054..bb0a87c38a242157fc771cf45c6c568cf0f74161 100644 (file)
--- a/src/pkg/runtime/runtime.h
+++ b/src/pkg/runtime/runtime.h
@@ -624,17 +624,15 @@ struct Defer
 {
        int32   siz;
        bool    special;        // not part of defer frame
-       byte*   argp;           // where args were copied from
-       byte*   pc;
+       uintptr argp;           // where args were copied from
+       uintptr pc;
        FuncVal*        fn;
        Defer*  link;
        void*   args[1];        // padded to actual size
 };
 
 // argp used in Defer structs when there is no argp.
-// TODO(rsc): Maybe we could use nil instead, but we've always used -1
-// and I don't want to change this days before the Go 1.3 release.
-#define NoArgs ((byte*)-1)
+#define NoArgs ((uintptr)-1)
 
 /*
  * panics
@@ -649,6 +647,8 @@ struct Panic
        bool    aborted;        // the panic was aborted
 };
 
+typedef struct XXX XXX;
+
 /*
  * stack traces
  */
@@ -661,8 +661,8 @@ struct Stkframe
        uintptr lr;     // program counter at caller aka link register
        uintptr sp;     // stack pointer at pc
        uintptr fp;     // stack pointer at caller aka frame pointer
-       byte*   varp;   // top of local variables
-       byte*   argp;   // pointer to function arguments
+       uintptr varp;   // top of local variables
+       uintptr argp;   // pointer to function arguments
        uintptr arglen; // number of bytes at argp
 };
 
@@ -775,7 +775,7 @@ int32       runtime·read(int32, void*, int32);
 int32  runtime·write(uintptr, void*, int32); // use uintptr to accommodate windows.
 int32  runtime·close(int32);
 int32  runtime·mincore(void*, uintptr, byte*);
-void   runtime·jmpdefer(FuncVal*, void*);
+void   runtime·jmpdefer(FuncVal*, uintptr);
 void   runtime·exit1(int32);
 void   runtime·ready(G*);
 byte*  runtime·getenv(int8*);

diff --git a/src/pkg/runtime/stack.c b/src/pkg/runtime/stack.c
index e499b1f8b6d05ad90fe40efe367b8087fb9a9dc7..e589d8d4432845bfe2465adf9d10a296056820d3 100644 (file)
--- a/src/pkg/runtime/stack.c
+++ b/src/pkg/runtime/stack.c
@@ -419,7 +419,7 @@ checkframecopy(Stkframe *frame, void *arg)
        if(StackDebug >= 2)
                runtime·printf("    checking %s frame=[%p,%p] stk=[%p,%p]\n", runtime·funcname(f), frame->sp, frame->fp, cinfo->stk, cinfo->base);
        // if we're not in the segment any more, return immediately.
-       if(frame->varp < cinfo->stk || frame->varp >= cinfo->base) {
+       if((byte*)frame->varp < cinfo->stk || (byte*)frame->varp >= cinfo->base) {
                if(StackDebug >= 2)
                        runtime·printf("    <next segment>\n");
                return false; // stop traceback
@@ -438,7 +438,7 @@ checkframecopy(Stkframe *frame, void *arg)
                cinfo->frames++;
                return true;
        }
-       if(frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
+       if((byte*)frame->varp != (byte*)frame->sp) { // not in prologue (and has at least one local or outarg)
                stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
                if(stackmap == nil) {
                        cinfo->frames = -1;
@@ -501,7 +501,7 @@ copyabletopsegment(G *gp)
                        // For now, this only happens with the Defer in runtime.main.
                        continue;
                }
-               if(d->argp < cinfo.stk || cinfo.base <= d->argp)
+               if((byte*)d->argp < cinfo.stk || cinfo.base <= (byte*)d->argp)
                        break; // a defer for the next segment
                fn = d->fn;
                if(fn == nil) // See issue 8047
@@ -666,7 +666,7 @@ adjustframe(Stkframe *frame, void *arg)
                pcdata = 0; // in prologue
 
        // adjust local pointers
-       if(frame->varp != (byte*)frame->sp) {
+       if((byte*)frame->varp != (byte*)frame->sp) {
                stackmap = runtime·funcdata(f, FUNCDATA_LocalsPointerMaps);
                if(stackmap == nil)
                        runtime·throw("no locals info");
@@ -715,7 +715,7 @@ adjustdefers(G *gp, AdjustInfo *adjinfo)
                        *dp = (Defer*)((byte*)d + adjinfo->delta);
                        continue;
                }
-               if(d->argp < adjinfo->oldstk || adjinfo->oldbase <= d->argp)
+               if((byte*)d->argp < adjinfo->oldstk || adjinfo->oldbase <= (byte*)d->argp)
                        break; // a defer for the next segment
                fn = d->fn;
                if(fn == nil) {

diff --git a/src/pkg/runtime/traceback_arm.c b/src/pkg/runtime/traceback_arm.c
index 5e937cbfb67414dab49f5682a8c87557c341aa63..18ca89150f31756d7e1262c9776250b1340de1d5 100644 (file)
--- a/src/pkg/runtime/traceback_arm.c
+++ b/src/pkg/runtime/traceback_arm.c
@@ -139,7 +139,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                        }
                }
 
-               frame.varp = (byte*)frame.fp;
+               frame.varp = frame.fp;
 
                // Derive size of arguments.
                // Most functions have a fixed-size argument block,
@@ -148,7 +148,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                // in package runtime and reflect, and for those we use call-specific
                // metadata recorded by f's caller.
                if(callback != nil || printing) {
-                       frame.argp = (byte*)frame.fp + sizeof(uintptr);
+                       frame.argp = frame.fp + sizeof(uintptr);
                        if(f->args != ArgsSizeUnknown)
                                frame.arglen = f->args;
                        else if(flr == nil)
@@ -193,18 +193,18 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                // returns; everything live at earlier deferprocs is still live at that one.
                frame.continpc = frame.pc;
                if(waspanic) {
-                       if(panic != nil && panic->defer->argp == (byte*)sparg)
+                       if(panic != nil && panic->defer->argp == sparg)
                                frame.continpc = (uintptr)panic->defer->pc;
-                       else if(defer != nil && defer->argp == (byte*)sparg)
+                       else if(defer != nil && defer->argp == sparg)
                                frame.continpc = (uintptr)defer->pc;
                        else
                                frame.continpc = 0;
                }
 
                // Unwind our local panic & defer stacks past this frame.
-               while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs))
+               while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
                        panic = panic->link;
-               while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs))
+               while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
                        defer = defer->link;    
 
                if(skip > 0) {

diff --git a/src/pkg/runtime/traceback_x86.c b/src/pkg/runtime/traceback_x86.c
index f3ba702b9b886f130db9227ad503fb08acd48c66..ac451240e21fc40bba85bc8b39081e9f2799ac3e 100644 (file)
--- a/src/pkg/runtime/traceback_x86.c
+++ b/src/pkg/runtime/traceback_x86.c
@@ -181,7 +181,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                        }
                }
                
-               frame.varp = (byte*)frame.fp - sizeof(uintreg);
+               frame.varp = frame.fp - sizeof(uintreg);
 
                // Derive size of arguments.
                // Most functions have a fixed-size argument block,
@@ -190,7 +190,7 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                // in package runtime and reflect, and for those we use call-specific
                // metadata recorded by f's caller.
                if(callback != nil || printing) {
-                       frame.argp = (byte*)frame.fp;
+                       frame.argp = frame.fp;
                        if(f->args != ArgsSizeUnknown)
                                frame.arglen = f->args;
                        else if(flr == nil)
@@ -228,18 +228,18 @@ runtime·gentraceback(uintptr pc0, uintptr sp0, uintptr lr0, G *gp, int32 skip,
                // returns; everything live at earlier deferprocs is still live at that one.
                frame.continpc = frame.pc;
                if(waspanic) {
-                       if(panic != nil && panic->defer->argp == (byte*)sparg)
-                               frame.continpc = (uintptr)panic->defer->pc;
-                       else if(defer != nil && defer->argp == (byte*)sparg)
-                               frame.continpc = (uintptr)defer->pc;
+                       if(panic != nil && panic->defer->argp == sparg)
+                               frame.continpc = panic->defer->pc;
+                       else if(defer != nil && defer->argp == sparg)
+                               frame.continpc = defer->pc;
                        else
                                frame.continpc = 0;
                }
 
                // Unwind our local panic & defer stacks past this frame.
-               while(panic != nil && (panic->defer == nil || panic->defer->argp == (byte*)sparg || panic->defer->argp == NoArgs))
+               while(panic != nil && (panic->defer == nil || panic->defer->argp == sparg || panic->defer->argp == NoArgs))
                        panic = panic->link;
-               while(defer != nil && (defer->argp == (byte*)sparg || defer->argp == NoArgs))
+               while(defer != nil && (defer->argp == sparg || defer->argp == NoArgs))
                        defer = defer->link;    
 
                if(skip > 0) {