code review 12053043: runtime: reimplement reflect.call to not use stack spli...

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"
 
 enum
@@ skipping 165 matching lines @@
         gp->stackguard = top->stackguard;
         gp->stackguard0 = gp->stackguard;
 
         if(top->free != 0)
                 runtime·stackfree(old, top->free);
 
         gp->status = oldstatus;
         runtime·gogo(&gp->sched);
 }
 
-// Called from reflect·call or from runtime·morestack when a new
+// Called from runtime·newstackcall 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, argsize, oldstatus;
         Stktop *top;
         byte *stk;
         uintptr sp;
         uintptr *src, *dst, *dstend;
         G *gp;
         Gobuf label;
-        bool reflectcall;
+        bool newstackcall;
         uintptr free;
 
         if(m->morebuf.g != m->curg) {
                 runtime·printf("runtime: newstack called from g=%p\n"
                         "\tm=%p m->curg=%p m->g0=%p m->gsignal=%p\n",
                         m->morebuf.g, m, m->curg, m->g0, m->gsignal);
                 runtime·throw("runtime: wrong goroutine in newstack");
         }
 
         // gp->status is usually Grunning, but it could be Gsyscall if a stack split
         // happens during a function call inside entersyscall.
         gp = m->curg;
         oldstatus = gp->status;
 
         framesize = m->moreframesize;
         argsize = m->moreargsize;
         gp->status = Gwaiting;
         gp->waitreason = "stack split";
-        reflectcall = framesize==1;
-        if(reflectcall)
+        newstackcall = framesize==1;
+        if(newstackcall)
                 framesize = 0;
 
-        // For reflectcall the context already points to beginning of reflect·call.
-        if(!reflectcall)
+        // For newstackcall the context already points to beginning of runtime·newstackcall.
+        if(!newstackcall)
                 runtime·rewindmorestack(&gp->sched);
 
         sp = gp->sched.sp;
         if(thechar == '6' || thechar == '8') {
                 // The call to morestack cost a word.
                 sp -= sizeof(uintptr);
         }
         if(StackDebug || sp < gp->stackguard - StackGuard) {
                 runtime·printf("runtime: newstack framesize=%p argsize=%p sp=%p stack=[%p, %p]\n"
                         "\tmorebuf={pc:%p sp:%p lr:%p}\n"
@@ skipping 26 matching lines @@
                         // gp->preempt is set, so it will be preempted next time.
                         gp->stackguard0 = gp->stackguard;
                         gp->status = oldstatus;
                         runtime·gogo(&gp->sched);       // never return
                 }
                 // Act like goroutine called runtime.Gosched.
                 gp->status = oldstatus;
                 runtime·gosched0(gp);   // never return
         }
 
-        if(reflectcall && m->morebuf.sp - sizeof(Stktop) - argsize - 32 > gp->stackguard) {
-                // special case: called from reflect.call (framesize==1)
+        if(newstackcall && m->morebuf.sp - sizeof(Stktop) - argsize - 32 > gp->stackguard) {
+                // special case: called from runtime.newstackcall (framesize==1)
                 // to call code with an arbitrary argument size,
                 // and we have enough space on the current stack.
                 // the new Stktop* is necessary to unwind, but
                 // we don't need to create a new segment.
                 top = (Stktop*)(m->morebuf.sp - sizeof(*top));
                 stk = (byte*)gp->stackguard - StackGuard;
                 free = 0;
         } else {
                 // allocate new segment.
                 framesize += argsize;
@@ skipping 43 matching lines @@
                 sp -= sizeof(void*);
                 *(void**)sp = nil;
         }
 
         // Continue as if lessstack had just called m->morepc
         // (the PC that decided to grow the stack).
         runtime·memclr((byte*)&label, sizeof label);
         label.sp = sp;
         label.pc = (uintptr)runtime·lessstack;
         label.g = m->curg;
-        if(reflectcall)
+        if(newstackcall)
                 runtime·gostartcallfn(&label, (FuncVal*)m->cret);
         else {
                 runtime·gostartcall(&label, (void(*)(void))gp->sched.pc, gp->sched.ctxt);
                 gp->sched.ctxt = nil;
         }
         gp->status = oldstatus;
         runtime·gogo(&label);
 
         *(int32*)345 = 123;     // never return
 }
 
 // adjust Gobuf as if it executed a call to fn
 // and then did an immediate gosave.
 void
 runtime·gostartcallfn(Gobuf *gobuf, FuncVal *fv)
 {
         runtime·gostartcall(gobuf, fv->fn, fv);
 }