code review 10169045: runtime: adjust traceback / garbage collector boundary

src/pkg/runtime/stack.c

 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "runtime.h"
 #include "arch_GOARCH.h"
 #include "malloc.h"
 #include "stack.h"
 
 typedef struct StackCacheNode StackCacheNode;
@@ skipping 137 matching lines @@
                 dst = (uintptr*)top->argp;
                 dstend = dst + argsize/sizeof(*dst);
                 src = (uintptr*)sp;
                 while(dst < dstend)
                         *dst++ = *src++;
         }
         goid = top->gobuf.g->goid;      // fault if g is bad, before gogo
         USED(goid);
 
         label = top->gobuf;
-        gp->stackbase = (uintptr)top->stackbase;
-        gp->stackguard = (uintptr)top->stackguard;
+        gp->stackbase = top->stackbase;
+        gp->stackguard = top->stackguard;
         gp->stackguard0 = gp->stackguard;
         if(top->free != 0)
                 runtime·stackfree(old, top->free);
 
         cret = m->cret;
         m->cret = 0;  // drop reference
         runtime·gogo(&label, cret);
 }
 
 // Called from reflect·call or from runtime·morestack when a new
 // stack segment is needed.  Allocate a new stack big enough for
 // m->moreframesize bytes, copy m->moreargsize bytes to the new frame,
 // and then act as though runtime·lessstack called the function at
 // m->morepc.
 void
 runtime·newstack(void)
 {
         int32 framesize, minalloc, argsize;
         Stktop *top;
-        byte *stk, *sp;
+        byte *stk;
+        uintptr sp;
         uintptr *src, *dst, *dstend;
         G *gp;
         Gobuf label;
         bool reflectcall;
         uintptr free;
 
         framesize = m->moreframesize;
         argsize = m->moreargsize;
         gp = m->curg;
 
@@ skipping 37 matching lines @@
                 stk = runtime·stackalloc(framesize);
                 top = (Stktop*)(stk+framesize-sizeof(*top));
                 free = framesize;
         }
 
         if(0) {
                 runtime·printf("newstack framesize=%d argsize=%d morepc=%p moreargp=%p gobuf=%p, %p top=%p old=%p\n",
                         framesize, argsize, m->morepc, m->moreargp, m->morebuf.pc, m->morebuf.sp, top, gp->stackbase);
         }
 
-        top->stackbase = (byte*)gp->stackbase;
-        top->stackguard = (byte*)gp->stackguard;
+        top->stackbase = gp->stackbase;
+        top->stackguard = gp->stackguard;
         top->gobuf = m->morebuf;
         top->argp = m->moreargp;
         top->argsize = argsize;
         top->free = free;
         m->moreargp = nil;
-        m->morebuf.pc = nil;
+        m->morebuf.pc = (uintptr)nil;
         m->morebuf.sp = (uintptr)nil;
 
         // copy flag from panic
         top->panic = gp->ispanic;
         gp->ispanic = false;
 
         gp->stackbase = (uintptr)top;
         gp->stackguard = (uintptr)stk + StackGuard;
         gp->stackguard0 = gp->stackguard;
 
-        sp = (byte*)top;
+        sp = (uintptr)top;
         if(argsize > 0) {
                 sp -= argsize;
                 dst = (uintptr*)sp;
                 dstend = dst + argsize/sizeof(*dst);
                 src = (uintptr*)top->argp;
                 while(dst < dstend)
                         *dst++ = *src++;
         }
         if(thechar == '5') {
                 // caller would have saved its LR below args.
                 sp -= sizeof(void*);
                 *(void**)sp = nil;
         }
 
         // Continue as if lessstack had just called m->morepc
         // (the PC that decided to grow the stack).
-        label.sp = (uintptr)sp;
-        label.pc = (byte*)runtime·lessstack;
+        label.sp = sp;
+        label.pc = (uintptr)runtime·lessstack;
         label.g = m->curg;
         if(reflectcall)
                 runtime·gogocallfn(&label, (FuncVal*)m->morepc);
         else
                 runtime·gogocall(&label, m->morepc, m->cret);
 
         *(int32*)345 = 123;     // never return
 }