diff options
Diffstat (limited to 'src/runtime/sys_windows_amd64.s')
| -rw-r--r-- | src/runtime/sys_windows_amd64.s | 224 |
1 files changed, 41 insertions, 183 deletions
diff --git a/src/runtime/sys_windows_amd64.s b/src/runtime/sys_windows_amd64.s index aba2811e59..e7782846b2 100644 --- a/src/runtime/sys_windows_amd64.s +++ b/src/runtime/sys_windows_amd64.s @@ -5,13 +5,15 @@ #include "go_asm.h" #include "go_tls.h" #include "textflag.h" +#include "time_windows.h" +#include "cgo/abi_amd64.h" // maxargs should be divisible by 2, as Windows stack // must be kept 16-byte aligned on syscall entry. -#define maxargs 16 +#define maxargs 18 // void runtime·asmstdcall(void *c); -TEXT runtime·asmstdcall(SB),NOSPLIT|NOFRAME,$0 +TEXT runtime·asmstdcall<ABIInternal>(SB),NOSPLIT|NOFRAME,$0 // asmcgocall will put first argument into CX. PUSHQ CX // save for later MOVQ libcall_fn(CX), AX @@ -94,6 +96,8 @@ TEXT runtime·badsignal2(SB),NOSPLIT|NOFRAME,$48 MOVQ runtime·_WriteFile(SB), AX CALL AX + // Does not return. + CALL runtime·abort(SB) RET // faster get/set last error @@ -111,18 +115,10 @@ TEXT runtime·getlasterror(SB),NOSPLIT,$0 TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$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 $112, 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, 88(SP) + // Switch from the host ABI to the Go ABI. + PUSH_REGS_HOST_TO_ABI0() + // Make stack space for the rest of the function. + ADJSP $48 MOVQ AX, R15 // save handler address @@ -138,8 +134,8 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0 CALL runtime·badsignal2(SB) // save g and SP in case of stack switch - MOVQ DX, 96(SP) // g - MOVQ SP, 104(SP) + MOVQ DX, 32(SP) // g + MOVQ SP, 40(SP) // do we need to switch to the g0 stack? MOVQ g_m(DX), BX @@ -153,9 +149,11 @@ TEXT sigtramp<>(SB),NOSPLIT|NOFRAME,$0-0 MOVQ (g_sched+gobuf_sp)(BX), DI // make room for sighandler arguments // and re-save old SP for restoring later. - // (note that the 104(DI) here must match the 104(SP) above.) - SUBQ $120, DI - MOVQ SP, 104(DI) + // Adjust g0 stack by the space we're using and + // save SP at the same place on the g0 stack. + // The 40(DI) here must match the 40(SP) above. + SUBQ $(REGS_HOST_TO_ABI0_STACK + 48), DI + MOVQ SP, 40(DI) MOVQ DI, SP g0: @@ -170,102 +168,29 @@ g0: // switch back to original stack and g // no-op if we never left. - MOVQ 104(SP), SP - MOVQ 96(SP), DX + MOVQ 40(SP), SP + MOVQ 32(SP), DX get_tls(BP) MOVQ DX, g(BP) done: - // restore registers as required for windows callback - 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 $112, SP - POPFQ + ADJSP $-48 + POP_REGS_HOST_TO_ABI0() RET -TEXT runtime·exceptiontramp(SB),NOSPLIT|NOFRAME,$0 +TEXT runtime·exceptiontramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0 MOVQ $runtime·exceptionhandler(SB), AX JMP sigtramp<>(SB) -TEXT runtime·firstcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0 +TEXT runtime·firstcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0 MOVQ $runtime·firstcontinuehandler(SB), AX JMP sigtramp<>(SB) -TEXT runtime·lastcontinuetramp(SB),NOSPLIT|NOFRAME,$0-0 +TEXT runtime·lastcontinuetramp<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-0 MOVQ $runtime·lastcontinuehandler(SB), AX JMP sigtramp<>(SB) -TEXT runtime·ctrlhandler(SB),NOSPLIT|NOFRAME,$8 - MOVQ CX, 16(SP) // spill - MOVQ $runtime·ctrlhandler1(SB), CX - MOVQ CX, 0(SP) - CALL runtime·externalthreadhandler(SB) - RET - -TEXT runtime·profileloop(SB),NOSPLIT|NOFRAME,$8 - MOVQ $runtime·profileloop1(SB), CX - MOVQ CX, 0(SP) - CALL runtime·externalthreadhandler(SB) - RET - -TEXT runtime·externalthreadhandler(SB),NOSPLIT|NOFRAME|TOPFRAME,$0 - PUSHQ BP - MOVQ SP, BP - PUSHQ BX - PUSHQ SI - PUSHQ DI - PUSHQ 0x28(GS) - MOVQ SP, DX - - // setup dummy m, g - SUBQ $m__size, SP // space for M - MOVQ SP, 0(SP) - MOVQ $m__size, 8(SP) - CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX, maybe BP - - LEAQ m_tls(SP), CX - MOVQ CX, 0x28(GS) - MOVQ SP, BX - SUBQ $g__size, SP // space for G - MOVQ SP, g(CX) - MOVQ SP, m_g0(BX) - - MOVQ SP, 0(SP) - MOVQ $g__size, 8(SP) - CALL runtime·memclrNoHeapPointers(SB) // smashes AX,BX,CX, maybe BP - LEAQ g__size(SP), BX - MOVQ BX, g_m(SP) - - LEAQ -32768(SP), CX // must be less than SizeOfStackReserve set by linker - MOVQ CX, (g_stack+stack_lo)(SP) - ADDQ $const__StackGuard, CX - MOVQ CX, g_stackguard0(SP) - MOVQ CX, g_stackguard1(SP) - MOVQ DX, (g_stack+stack_hi)(SP) - - PUSHQ AX // room for return value - PUSHQ 32(BP) // arg for handler - CALL 16(BP) - POPQ CX - POPQ AX // pass return value to Windows in AX - - get_tls(CX) - MOVQ g(CX), CX - MOVQ (g_stack+stack_hi)(CX), SP - POPQ 0x28(GS) - POPQ DI - POPQ SI - POPQ BX - POPQ BP - RET - GLOBL runtime·cbctxts(SB), NOPTR, $8 TEXT runtime·callbackasm1(SB),NOSPLIT,$0 @@ -287,28 +212,15 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0 ADDQ $8, SP // determine index into runtime·cbs table - MOVQ $runtime·callbackasm(SB), DX + MOVQ $runtime·callbackasm<ABIInternal>(SB), DX SUBQ DX, AX MOVQ $0, DX MOVQ $5, CX // divide by 5 because each call instruction in runtime·callbacks is 5 bytes long DIVL CX SUBQ $1, AX // subtract 1 because return PC is to the next slot - // DI SI BP BX R12 R13 R14 R15 registers and DF flag are preserved - // as required by windows callback convention. - PUSHFQ - SUBQ $64, SP - MOVQ DI, 56(SP) - MOVQ SI, 48(SP) - MOVQ BP, 40(SP) - MOVQ BX, 32(SP) - MOVQ R12, 24(SP) - MOVQ R13, 16(SP) - MOVQ R14, 8(SP) - MOVQ R15, 0(SP) - - // Go ABI requires DF flag to be cleared. - CLD + // Switch from the host ABI to the Go ABI. + PUSH_REGS_HOST_TO_ABI0() // Create a struct callbackArgs on our stack to be passed as // the "frame" to cgocallback and on to callbackWrap. @@ -320,30 +232,23 @@ TEXT runtime·callbackasm1(SB),NOSPLIT,$0 // Call cgocallback, which will call callbackWrap(frame). MOVQ $0, 16(SP) // context MOVQ AX, 8(SP) // frame (address of callbackArgs) - LEAQ ·callbackWrap(SB), BX + LEAQ ·callbackWrap<ABIInternal>(SB), BX // cgocallback takes an ABIInternal entry-point MOVQ BX, 0(SP) // PC of function value to call (callbackWrap) CALL ·cgocallback(SB) // Get callback result. MOVQ (24+callbackArgs_result)(SP), AX ADDQ $(24+callbackArgs__size), SP - // restore registers as required for windows callback - MOVQ 0(SP), R15 - MOVQ 8(SP), R14 - MOVQ 16(SP), R13 - MOVQ 24(SP), R12 - MOVQ 32(SP), BX - MOVQ 40(SP), BP - MOVQ 48(SP), SI - MOVQ 56(SP), DI - ADDQ $64, SP - POPFQ + POP_REGS_HOST_TO_ABI0() // The return value was placed in AX above. RET // uint32 tstart_stdcall(M *newm); -TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0 +TEXT runtime·tstart_stdcall<ABIInternal>(SB),NOSPLIT,$0 + // Switch from the host ABI to the Go ABI. + PUSH_REGS_HOST_TO_ABI0() + // CX contains first arg newm MOVQ m_g0(CX), DX // g @@ -362,12 +267,11 @@ TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0 MOVQ CX, g_m(DX) MOVQ DX, g(SI) - // Someday the convention will be D is always cleared. - CLD - CALL runtime·stackcheck(SB) // clobbers AX,CX CALL runtime·mstart(SB) + POP_REGS_HOST_TO_ABI0() + XORL AX, AX // return 0 == success RET @@ -440,14 +344,6 @@ TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0 MOVQ 32(SP), SP RET -// See https://www.dcl.hpi.uni-potsdam.de/research/WRK/2007/08/getting-os-information-the-kuser_shared_data-structure/ -// Must read hi1, then lo, then hi2. The snapshot is valid if hi1 == hi2. -#define _INTERRUPT_TIME 0x7ffe0008 -#define _SYSTEM_TIME 0x7ffe0014 -#define time_lo 0 -#define time_hi1 4 -#define time_hi2 8 - TEXT runtime·nanotime1(SB),NOSPLIT,$0-8 CMPB runtime·useQPCTime(SB), $0 JNE useQPC @@ -467,48 +363,10 @@ useQPC: JMP runtime·nanotimeQPC(SB) RET -TEXT time·now(SB),NOSPLIT,$0-24 - CMPB runtime·useQPCTime(SB), $0 - JNE useQPC - MOVQ $_INTERRUPT_TIME, DI -loop: - MOVL time_hi1(DI), AX - MOVL time_lo(DI), BX - MOVL time_hi2(DI), CX - CMPL AX, CX - JNE loop - SHLQ $32, AX - ORQ BX, AX - IMULQ $100, AX - MOVQ AX, mono+16(FP) - - MOVQ $_SYSTEM_TIME, DI -wall: - MOVL time_hi1(DI), AX - MOVL time_lo(DI), BX - MOVL time_hi2(DI), CX - CMPL AX, CX - JNE wall - SHLQ $32, AX - ORQ BX, AX - MOVQ $116444736000000000, DI - SUBQ DI, AX - IMULQ $100, AX - - // generated code for - // func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 } - // adapted to reduce duplication - MOVQ AX, CX - MOVQ $1360296554856532783, AX - MULQ CX - ADDQ CX, DX - RCRQ $1, DX - SHRQ $29, DX - MOVQ DX, sec+0(FP) - IMULQ $1000000000, DX - SUBQ DX, CX - MOVL CX, nsec+8(FP) - RET -useQPC: - JMP runtime·nowQPC(SB) +// func osSetupTLS(mp *m) +// Setup TLS. for use by needm on Windows. +TEXT runtime·osSetupTLS(SB),NOSPLIT,$0-8 + MOVQ mp+0(FP), AX + LEAQ m_tls(AX), DI + CALL runtime·settls(SB) RET |