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

src/pkg/runtime/asm_386.s

 // Copyright 2009 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 "zasm_GOOS_GOARCH.h"
 #include "funcdata.h"
 
 TEXT _rt0_go(SB),7,$0
         // copy arguments forward on an even stack
         MOVL    argc+0(FP), AX
@@ skipping 226 matching lines @@
         // Call newstack on m->g0's stack.
         MOVL    m_g0(BX), BP
         MOVL    BP, g(CX)
         MOVL    (g_sched+gobuf_sp)(BP), AX
         MOVL    -4(AX), BX      // fault if CALL would, before smashing SP
         MOVL    AX, SP
         CALL    runtime·newstack(SB)
         MOVL    $0, 0x1003      // crash if newstack returns
         RET
 
-// Called from reflection library.  Mimics morestack,
+// Called from panic.  Mimics morestack,
 // reuses stack growth code to create a frame
 // with the desired args running the desired function.
 //
 // func call(fn *byte, arg *byte, argsize uint32).
-TEXT reflect·call(SB), 7, $0-12
+TEXT runtime·newstackcall(SB), 7, $0-12
         get_tls(CX)
         MOVL    m(CX), BX
 
         // Save our caller's state as the PC and SP to
         // restore when returning from f.
         MOVL    0(SP), AX       // our caller's PC
         MOVL    AX, (m_morebuf+gobuf_pc)(BX)
         LEAL    4(SP), AX       // our caller's SP
         MOVL    AX, (m_morebuf+gobuf_sp)(BX)
         MOVL    g(CX), AX
         MOVL    AX, (m_morebuf+gobuf_g)(BX)
 
         // Save our own state as the PC and SP to restore
         // if this goroutine needs to be restarted.
-        MOVL    $reflect·call(SB), (g_sched+gobuf_pc)(AX)
+        MOVL    $runtime·newstackcall(SB), (g_sched+gobuf_pc)(AX)
         MOVL    SP, (g_sched+gobuf_sp)(AX)
 
         // Set up morestack arguments to call f on a new stack.
         // We set f's frame size to 1, as a hint to newstack
-        // that this is a call from reflect·call.
+        // that this is a call from runtime·newstackcall.
         // If it turns out that f needs a larger frame than
         // the default stack, f's usual stack growth prolog will
         // allocate a new segment (and recopy the arguments).
         MOVL    4(SP), AX       // fn
         MOVL    8(SP), DX       // arg frame
         MOVL    12(SP), CX      // arg size
 
         MOVL    AX, m_cret(BX)  // f's PC
         MOVL    DX, m_moreargp(BX)      // f's argument pointer
         MOVL    CX, m_moreargsize(BX)   // f's argument size
         MOVL    $1, m_moreframesize(BX) // f's frame size
 
         // Call newstack on m->g0's stack.
         MOVL    m_g0(BX), BP
         get_tls(CX)
         MOVL    BP, g(CX)
         MOVL    (g_sched+gobuf_sp)(BP), SP
         CALL    runtime·newstack(SB)
         MOVL    $0, 0x1103      // crash if newstack returns
         RET
 
+// reflect·call: call a function with the given argument list
+// func call(f *FuncVal, arg *byte, argsize uint32).
+// we don't have variable-sized frames, so we use a small number
+// of constant-sized-frame functions to encode a few bits of size in the pc.
+// Caution: ugly multiline assembly macros in your future!
+
+#define DISPATCH(NAME,MAXSIZE)          \
+        CMPL    CX, $MAXSIZE;           \
+        JA      3(PC);                  \
+        MOVL    $runtime·NAME(SB), AX;  \
+        JMP     AX
+// Note: can't just "JMP runtime·NAME(SB)" - bad inlining results.
+
+TEXT reflect·call(SB), 7, $0-12
+        MOVL    argsize+8(FP), CX
+        DISPATCH(call16, 16)
+        DISPATCH(call32, 32)
+        DISPATCH(call64, 64)
+        DISPATCH(call128, 128)
+        DISPATCH(call256, 256)
+        DISPATCH(call512, 512)
+        DISPATCH(call1024, 1024)
+        DISPATCH(call2048, 2048)
+        DISPATCH(call4096, 4096)
+        DISPATCH(call8192, 8192)
+        DISPATCH(call16384, 16384)
+        DISPATCH(call32768, 32768)
+        DISPATCH(call65536, 65536)
+        DISPATCH(call131072, 131072)
+        DISPATCH(call262144, 262144)
+        DISPATCH(call524288, 524288)
+        DISPATCH(call1048576, 1048576)
+        DISPATCH(call2097152, 2097152)
+        DISPATCH(call4194304, 4194304)
+        DISPATCH(call8388608, 8388608)
+        DISPATCH(call16777216, 16777216)
+        DISPATCH(call33554432, 33554432)
+        DISPATCH(call67108864, 67108864)
+        DISPATCH(call134217728, 134217728)
+        DISPATCH(call268435456, 268435456)
+        DISPATCH(call536870912, 536870912)
+        DISPATCH(call1073741824, 1073741824)
+        MOVL    $runtime·badreflectcall(SB), AX
+        JMP     AX
+
+#define CALLFN(NAME,MAXSIZE,FLAGS)              \
+TEXT runtime·NAME(SB), FLAGS, $MAXSIZE-12;      \
+        /* copy arguments to stack */           \
+        MOVL    argptr+4(FP), SI;               \
+        MOVL    argsize+8(FP), CX;              \
+        MOVL    SP, DI;                         \
+        REP;MOVSB;                              \
+        /* call function */                     \
+        MOVL    f+0(FP), DX;                    \
+        CALL    (DX);                           \
+        /* copy return values back */           \
+        MOVL    argptr+4(FP), DI;               \
+        MOVL    argsize+8(FP), CX;              \
+        MOVL    SP, SI;                         \
+        REP;MOVSB;                              \
+        RET
+
+CALLFN(call16, 16, 7)
+CALLFN(call32, 32, 7)
+CALLFN(call64, 64, 7)
+CALLFN(call128, 128, 0)
+CALLFN(call256, 256, 0)
+CALLFN(call512, 512, 0)
+CALLFN(call1024, 1024, 0)
+CALLFN(call2048, 2048, 0)
+CALLFN(call4096, 4096, 0)
+CALLFN(call8192, 8192, 0)
+CALLFN(call16384, 16384, 0)
+CALLFN(call32768, 32768, 0)
+CALLFN(call65536, 65536, 0)
+CALLFN(call131072, 131072, 0)
+CALLFN(call262144, 262144, 0)
+CALLFN(call524288, 524288, 0)
+CALLFN(call1048576, 1048576, 0)
+CALLFN(call2097152, 2097152, 0)
+CALLFN(call4194304, 4194304, 0)
+CALLFN(call8388608, 8388608, 0)
+CALLFN(call16777216, 16777216, 0)
+CALLFN(call33554432, 33554432, 0)
+CALLFN(call67108864, 67108864, 0)
+CALLFN(call134217728, 134217728, 0)
+CALLFN(call268435456, 268435456, 0)
+CALLFN(call536870912, 536870912, 0)
+CALLFN(call1073741824, 1073741824, 0)
 
 // Return point when leaving stack.
 //
 // Lessstack can appear in stack traces for the same reason
 // as morestack; in that context, it has 0 arguments.
 TEXT runtime·lessstack(SB), 7, $0-0
         // Save return value in m->cret
         get_tls(CX)
         MOVL    m(CX), BX
         MOVL    AX, m_cret(BX)
@@ skipping 936 matching lines @@
         // all the bytes in common are the same, so we just need
         // to compare the lengths.
 cmp_allsame:
         XORL    AX, AX
         XORL    CX, CX
         CMPL    BX, DX
         SETGT   AX      // 1 if alen > blen
         SETEQ   CX      // 1 if alen == blen
         LEAL    -1(CX)(AX*2), AX        // 1,0,-1 result
         RET