code review 133980043: runtime: fix windows signal handlers

src/pkg/runtime/sys_windows_amd64.s

 // Copyright 2011 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 "../../cmd/ld/textflag.h"
 
 // maxargs should be divisible by 2, as Windows stack
 // must be kept 16-byte aligned on syscall entry.
 #define maxargs 16
@@ skipping 88 matching lines @@
 // Called by Windows as a Vectored Exception Handler (VEH).
 // First argument is pointer to struct containing
 // exception record and context pointers.
 // Return 0 for 'not handled', -1 for handled.
 TEXT runtime·sigtramp(SB),NOSPLIT,$0-0
         // CX: PEXCEPTION_POINTERS ExceptionInfo
 
         // DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved
         // as required by windows callback convention.
         PUSHFQ
-        SUBQ    $88, SP
+        SUBQ    $96, SP
         MOVQ    DI, 80(SP)
         MOVQ    SI, 72(SP)
         MOVQ    BP, 64(SP)
         MOVQ    BX, 56(SP)
         MOVQ    R12, 48(SP)
         MOVQ    R13, 40(SP)
         MOVQ    R14, 32(SP)
-        MOVQ    R15, 24(SP)
+        MOVQ    R15, 88(SP)
 
         MOVQ    0(CX), BX // ExceptionRecord*
         MOVQ    8(CX), CX // Context*
 
         // fetch g
         get_tls(DX)
         CMPQ    DX, $0
         JNE     3(PC)
         MOVQ    $0, AX // continue
         JMP     done
         MOVQ    g(DX), DX
         CMPQ    DX, $0
         JNE     2(PC)
         CALL    runtime·badsignal2(SB)
         // call sighandler(ExceptionRecord*, Context*, G*)
         MOVQ    BX, 0(SP)
         MOVQ    CX, 8(SP)
         MOVQ    DX, 16(SP)
         CALL    runtime·sighandler(SB)
         // AX is set to report result back to Windows
+        MOVL    24(SP), AX
 
 done:
         // restore registers as required for windows callback
-        MOVQ    24(SP), R15
+        MOVQ    88(SP), R15
         MOVQ    32(SP), R14
         MOVQ    40(SP), R13
         MOVQ    48(SP), R12
         MOVQ    56(SP), BX
         MOVQ    64(SP), BP
         MOVQ    72(SP), SI
         MOVQ    80(SP), DI
-        ADDQ    $88, SP
+        ADDQ    $96, SP
         POPFQ
 
         RET
 
 TEXT runtime·ctrlhandler(SB),NOSPLIT,$8
         MOVQ    CX, 16(SP)              // spill
         MOVQ    $runtime·ctrlhandler1(SB), CX
         MOVQ    CX, 0(SP)
         CALL    runtime·externalthreadhandler(SB)
         RET
@@ skipping 216 matching lines @@
         // Want negative 100ns units.
         NEGQ    BX
         MOVQ    SP, R8 // ptime
         MOVQ    BX, (R8)
         MOVQ    $-1, CX // handle
         MOVQ    $0, DX // alertable
         MOVQ    runtime·NtWaitForSingleObject(SB), AX
         CALL    AX
         MOVQ    8(SP), SP
         RET