src/runtime/sys_windows_386.s - go - Git at Google

 // 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 "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
 #include "time_windows.h"

 // Offsets into Thread Environment Block (pointer in FS)
 #define TEB_TlsSlots 0xE10
 #define TEB_ArbitraryPtr 0x14

 TEXT runtime·asmstdcall_trampoline<ABIInternal>(SB),NOSPLIT,$0
 	JMP	runtime·asmstdcall(SB)

 // void runtime·asmstdcall(void *c);
 TEXT runtime·asmstdcall(SB),NOSPLIT,$0
 	MOVL	fn+0(FP), BX
 	MOVL	SP, BP	// save stack pointer

 	// SetLastError(0).
 	MOVL	$0, 0x34(FS)

 	MOVL	libcall_n(BX), CX

 	// Fast version, do not store args on the stack.
 	CMPL	CX, $0
 	JE	docall

 	// Copy args to the stack.
 	MOVL	CX, AX
 	SALL	$2, AX
 	SUBL	AX, SP			// room for args
 	MOVL	SP, DI
 	MOVL	libcall_args(BX), SI
 	CLD
 	REP; MOVSL

 docall:
 	// Call stdcall or cdecl function.
 	// DI SI BP BX are preserved, SP is not
 	CALL	libcall_fn(BX)
 	MOVL	BP, SP

 	// Return result.
 	MOVL	fn+0(FP), BX
 	MOVL	AX, libcall_r1(BX)
 	MOVL	DX, libcall_r2(BX)

 	// GetLastError().
 	MOVL	0x34(FS), AX
 	MOVL	AX, libcall_err(BX)

 	RET

 // faster get/set last error
 TEXT runtime·getlasterror(SB),NOSPLIT,$0
 	MOVL	0x34(FS), AX
 	MOVL	AX, ret+0(FP)
 	RET

 TEXT runtime·sigFetchGSafe<ABIInternal>(SB),NOSPLIT,$0
 	get_tls(AX)
 	CMPL	AX, $0
 	JE	2(PC)
 	MOVL	g(AX), AX
 	MOVL	AX, ret+0(FP)
 	RET

 // Called by Windows as a Vectored Exception Handler (VEH).
 // AX is pointer to struct containing
 // exception record and context pointers.
 // CX is the kind of sigtramp function.
 // Return value of sigtrampgo is stored in AX.
 TEXT sigtramp<>(SB),NOSPLIT,$0-0
 	SUBL	$40, SP

 	// save callee-saved registers
 	MOVL	BX, 28(SP)
 	MOVL	BP, 16(SP)
 	MOVL	SI, 20(SP)
 	MOVL	DI, 24(SP)

 	MOVL	AX, 0(SP)
 	MOVL	CX, 4(SP)
 	CALL	runtime·sigtrampgo(SB)
 	MOVL	8(SP), AX

 	// restore callee-saved registers
 	MOVL	24(SP), DI
 	MOVL	20(SP), SI
 	MOVL	16(SP), BP
 	MOVL	28(SP), BX

 	ADDL	$40, SP
 	// RET 4 (return and pop 4 bytes parameters)
 	BYTE $0xC2; WORD $4
 	RET // unreached; make assembler happy

 // Trampoline to resume execution from exception handler.
 // This is part of the control flow guard workaround.
 // It switches stacks and jumps to the continuation address.
 // DX and CX are set above at the end of sigtrampgo
 // in the context that starts executing at sigresume.
 TEXT runtime·sigresume(SB),NOSPLIT,$0
 	MOVL	DX, SP
 	JMP	CX

 TEXT runtime·exceptiontramp(SB),NOSPLIT,$0
 	MOVL	argframe+0(FP), AX
 	MOVL	$const_callbackVEH, CX
 	JMP	sigtramp<>(SB)

 TEXT runtime·firstcontinuetramp(SB),NOSPLIT,$0-0
 	// is never called
 	INT	$3

 TEXT runtime·lastcontinuetramp(SB),NOSPLIT,$0-0
 	MOVL	argframe+0(FP), AX
 	MOVL	$const_callbackLastVCH, CX
 	JMP	sigtramp<>(SB)

 TEXT runtime·callbackasm1(SB),NOSPLIT,$0
 	MOVL	0(SP), AX	// will use to find our callback context

 	// remove return address from stack, we are not returning to callbackasm, but to its caller.
 	ADDL	$4, SP

 	// address to callback parameters into CX
 	LEAL	4(SP), CX

 	// save registers as required for windows callback
 	PUSHL	DI
 	PUSHL	SI
 	PUSHL	BP
 	PUSHL	BX

 	// Go ABI requires DF flag to be cleared.
 	CLD

 	// determine index into runtime·cbs table
 	SUBL	$runtime·callbackasm(SB), AX
 	MOVL	$0, DX
 	MOVL	$5, BX	// divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
 	DIVL	BX
 	SUBL	$1, AX	// subtract 1 because return PC is to the next slot

 	// Create a struct callbackArgs on our stack.
 	SUBL	$(12+callbackArgs__size), SP
 	MOVL	AX, (12+callbackArgs_index)(SP)		// callback index
 	MOVL	CX, (12+callbackArgs_args)(SP)		// address of args vector
 	MOVL	$0, (12+callbackArgs_result)(SP)	// result
 	LEAL	12(SP), AX	// AX = &callbackArgs{...}

 	// Call cgocallback, which will call callbackWrap(frame).
 	MOVL	$0, 8(SP)	// context
 	MOVL	AX, 4(SP)	// frame (address of callbackArgs)
 	LEAL	·callbackWrap(SB), AX
 	MOVL	AX, 0(SP)	// PC of function to call
 	CALL	runtime·cgocallback(SB)

 	// Get callback result.
 	MOVL	(12+callbackArgs_result)(SP), AX
 	// Get popRet.
 	MOVL	(12+callbackArgs_retPop)(SP), CX	// Can't use a callee-save register
 	ADDL	$(12+callbackArgs__size), SP

 	// restore registers as required for windows callback
 	POPL	BX
 	POPL	BP
 	POPL	SI
 	POPL	DI

 	// remove callback parameters before return (as per Windows spec)
 	POPL	DX
 	ADDL	CX, SP
 	PUSHL	DX

 	CLD

 	RET

 // void tstart(M *newm);
 TEXT tstart<>(SB),NOSPLIT,$8-4
 	MOVL	newm+0(FP), CX		// m
 	MOVL	m_g0(CX), DX		// g

 	// Layout new m scheduler stack on os stack.
 	MOVL	SP, AX
 	MOVL	AX, (g_stack+stack_hi)(DX)
 	SUBL	$(64*1024), AX		// initial stack size (adjusted later)
 	MOVL	AX, (g_stack+stack_lo)(DX)
 	ADDL	$const_stackGuard, AX
 	MOVL	AX, g_stackguard0(DX)
 	MOVL	AX, g_stackguard1(DX)

 	// Set up tls.
 	LEAL	m_tls(CX), DI
 	MOVL	CX, g_m(DX)
 	MOVL	DX, g(DI)
 	MOVL	DI, 4(SP)
 	CALL	runtime·setldt(SB) // clobbers CX and DX

 	// Someday the convention will be D is always cleared.
 	CLD

 	CALL	runtime·stackcheck(SB)	// clobbers AX,CX
 	CALL	runtime·mstart(SB)

 	RET

 // uint32 tstart_stdcall(M *newm);
 TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
 	MOVL	newm+0(FP), BX

 	PUSHL	BX
 	CALL	tstart<>(SB)
 	POPL	BX

 	// Adjust stack for stdcall to return properly.
 	MOVL	(SP), AX		// save return address
 	ADDL	$4, SP			// remove single parameter
 	MOVL	AX, (SP)		// restore return address

 	XORL	AX, AX			// return 0 == success

 	RET

 // setldt(int slot, int base, int size)
 TEXT runtime·setldt(SB),NOSPLIT,$0-12
 	MOVL	base+4(FP), DX
 	MOVL	runtime·tls_g(SB), CX
 	MOVL	DX, 0(CX)(FS)
 	RET

 TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
 loop:
 	MOVL	(_INTERRUPT_TIME+time_hi1), AX
 	MOVL	(_INTERRUPT_TIME+time_lo), CX
 	MOVL	(_INTERRUPT_TIME+time_hi2), DI
 	CMPL	AX, DI
 	JNE	loop

 	// wintime = DI:CX, multiply by 100
 	MOVL	$100, AX
 	MULL	CX
 	IMULL	$100, DI
 	ADDL	DI, DX
 	// wintime*100 = DX:AX
 	MOVL	AX, ret_lo+0(FP)
 	MOVL	DX, ret_hi+4(FP)
 	RET

 // This is called from rt0_go, which runs on the system stack
 // using the initial stack allocated by the OS.
 TEXT runtime·wintls(SB),NOSPLIT,$0
 	// Allocate a TLS slot to hold g across calls to external code
 	MOVL	SP, BP
 	MOVL	runtime·_TlsAlloc(SB), AX
 	CALL	AX
 	MOVL	BP, SP

 	MOVL	AX, CX	// TLS index

 	// Assert that slot is less than 64 so we can use _TEB->TlsSlots
 	CMPL	CX, $64
 	JB	ok
 	// Fallback to the TEB arbitrary pointer.
 	// TODO: don't use the arbitrary pointer (see go.dev/issue/59824)
 	MOVL	$TEB_ArbitraryPtr, CX
 	JMP	settls
 ok:
 	// Convert the TLS index at CX into
 	// an offset from TEB_TlsSlots.
 	SHLL	$2, CX

 	// Save offset from TLS into tls_g.
 	ADDL	$TEB_TlsSlots, CX
 settls:
 	MOVL	CX, runtime·tls_g(SB)
 	RET
	// 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 "go_asm.h"
	#include "go_tls.h"
	#include "textflag.h"
	#include "time_windows.h"

	// Offsets into Thread Environment Block (pointer in FS)
	#define TEB_TlsSlots 0xE10
	#define TEB_ArbitraryPtr 0x14

	TEXT runtime·asmstdcall_trampoline<ABIInternal>(SB),NOSPLIT,$0
	JMP runtime·asmstdcall(SB)

	// void runtime·asmstdcall(void *c);
	TEXT runtime·asmstdcall(SB),NOSPLIT,$0
	MOVL fn+0(FP), BX
	MOVL SP, BP // save stack pointer

	// SetLastError(0).
	MOVL $0, 0x34(FS)

	MOVL libcall_n(BX), CX

	// Fast version, do not store args on the stack.
	CMPL CX, $0
	JE docall

	// Copy args to the stack.
	MOVL CX, AX
	SALL $2, AX
	SUBL AX, SP // room for args
	MOVL SP, DI
	MOVL libcall_args(BX), SI
	CLD
	REP; MOVSL

	docall:
	// Call stdcall or cdecl function.
	// DI SI BP BX are preserved, SP is not
	CALL libcall_fn(BX)
	MOVL BP, SP

	// Return result.
	MOVL fn+0(FP), BX
	MOVL AX, libcall_r1(BX)
	MOVL DX, libcall_r2(BX)

	// GetLastError().
	MOVL 0x34(FS), AX
	MOVL AX, libcall_err(BX)

	RET

	// faster get/set last error
	TEXT runtime·getlasterror(SB),NOSPLIT,$0
	MOVL 0x34(FS), AX
	MOVL AX, ret+0(FP)
	RET

	TEXT runtime·sigFetchGSafe<ABIInternal>(SB),NOSPLIT,$0
	get_tls(AX)
	CMPL AX, $0
	JE 2(PC)
	MOVL g(AX), AX
	MOVL AX, ret+0(FP)
	RET

	// Called by Windows as a Vectored Exception Handler (VEH).
	// AX is pointer to struct containing
	// exception record and context pointers.
	// CX is the kind of sigtramp function.
	// Return value of sigtrampgo is stored in AX.
	TEXT sigtramp<>(SB),NOSPLIT,$0-0
	SUBL $40, SP

	// save callee-saved registers
	MOVL BX, 28(SP)
	MOVL BP, 16(SP)
	MOVL SI, 20(SP)
	MOVL DI, 24(SP)

	MOVL AX, 0(SP)
	MOVL CX, 4(SP)
	CALL runtime·sigtrampgo(SB)
	MOVL 8(SP), AX

	// restore callee-saved registers
	MOVL 24(SP), DI
	MOVL 20(SP), SI
	MOVL 16(SP), BP
	MOVL 28(SP), BX

	ADDL $40, SP
	// RET 4 (return and pop 4 bytes parameters)
	BYTE $0xC2; WORD $4
	RET // unreached; make assembler happy

	// Trampoline to resume execution from exception handler.
	// This is part of the control flow guard workaround.
	// It switches stacks and jumps to the continuation address.
	// DX and CX are set above at the end of sigtrampgo
	// in the context that starts executing at sigresume.
	TEXT runtime·sigresume(SB),NOSPLIT,$0
	MOVL DX, SP
	JMP CX

	TEXT runtime·exceptiontramp(SB),NOSPLIT,$0
	MOVL argframe+0(FP), AX
	MOVL $const_callbackVEH, CX
	JMP sigtramp<>(SB)

	TEXT runtime·firstcontinuetramp(SB),NOSPLIT,$0-0
	// is never called
	INT $3

	TEXT runtime·lastcontinuetramp(SB),NOSPLIT,$0-0
	MOVL argframe+0(FP), AX
	MOVL $const_callbackLastVCH, CX
	JMP sigtramp<>(SB)

	TEXT runtime·callbackasm1(SB),NOSPLIT,$0
	MOVL 0(SP), AX // will use to find our callback context

	// remove return address from stack, we are not returning to callbackasm, but to its caller.
	ADDL $4, SP

	// address to callback parameters into CX
	LEAL 4(SP), CX

	// save registers as required for windows callback
	PUSHL DI
	PUSHL SI
	PUSHL BP
	PUSHL BX

	// Go ABI requires DF flag to be cleared.
	CLD

	// determine index into runtime·cbs table
	SUBL $runtime·callbackasm(SB), AX
	MOVL $0, DX
	MOVL $5, BX // divide by 5 because each call instruction in runtime·callbacks is 5 bytes long
	DIVL BX
	SUBL $1, AX // subtract 1 because return PC is to the next slot

	// Create a struct callbackArgs on our stack.
	SUBL $(12+callbackArgs__size), SP
	MOVL AX, (12+callbackArgs_index)(SP) // callback index
	MOVL CX, (12+callbackArgs_args)(SP) // address of args vector
	MOVL $0, (12+callbackArgs_result)(SP) // result
	LEAL 12(SP), AX // AX = &callbackArgs{...}

	// Call cgocallback, which will call callbackWrap(frame).
	MOVL $0, 8(SP) // context
	MOVL AX, 4(SP) // frame (address of callbackArgs)
	LEAL ·callbackWrap(SB), AX
	MOVL AX, 0(SP) // PC of function to call
	CALL runtime·cgocallback(SB)

	// Get callback result.
	MOVL (12+callbackArgs_result)(SP), AX
	// Get popRet.
	MOVL (12+callbackArgs_retPop)(SP), CX // Can't use a callee-save register
	ADDL $(12+callbackArgs__size), SP

	// restore registers as required for windows callback
	POPL BX
	POPL BP
	POPL SI
	POPL DI

	// remove callback parameters before return (as per Windows spec)
	POPL DX
	ADDL CX, SP
	PUSHL DX

	CLD

	RET

	// void tstart(M *newm);
	TEXT tstart<>(SB),NOSPLIT,$8-4
	MOVL newm+0(FP), CX // m
	MOVL m_g0(CX), DX // g

	// Layout new m scheduler stack on os stack.
	MOVL SP, AX
	MOVL AX, (g_stack+stack_hi)(DX)
	SUBL $(64*1024), AX // initial stack size (adjusted later)
	MOVL AX, (g_stack+stack_lo)(DX)
	ADDL $const_stackGuard, AX
	MOVL AX, g_stackguard0(DX)
	MOVL AX, g_stackguard1(DX)

	// Set up tls.
	LEAL m_tls(CX), DI
	MOVL CX, g_m(DX)
	MOVL DX, g(DI)
	MOVL DI, 4(SP)
	CALL runtime·setldt(SB) // clobbers CX and DX

	// Someday the convention will be D is always cleared.
	CLD

	CALL runtime·stackcheck(SB) // clobbers AX,CX
	CALL runtime·mstart(SB)

	RET

	// uint32 tstart_stdcall(M *newm);
	TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
	MOVL newm+0(FP), BX

	PUSHL BX
	CALL tstart<>(SB)
	POPL BX

	// Adjust stack for stdcall to return properly.
	MOVL (SP), AX // save return address
	ADDL $4, SP // remove single parameter
	MOVL AX, (SP) // restore return address

	XORL AX, AX // return 0 == success

	RET

	// setldt(int slot, int base, int size)
	TEXT runtime·setldt(SB),NOSPLIT,$0-12
	MOVL base+4(FP), DX
	MOVL runtime·tls_g(SB), CX
	MOVL DX, 0(CX)(FS)
	RET

	TEXT runtime·nanotime1(SB),NOSPLIT,$0-8
	loop:
	MOVL (_INTERRUPT_TIME+time_hi1), AX
	MOVL (_INTERRUPT_TIME+time_lo), CX
	MOVL (_INTERRUPT_TIME+time_hi2), DI
	CMPL AX, DI
	JNE loop

	// wintime = DI:CX, multiply by 100
	MOVL $100, AX
	MULL CX
	IMULL $100, DI
	ADDL DI, DX
	// wintime*100 = DX:AX
	MOVL AX, ret_lo+0(FP)
	MOVL DX, ret_hi+4(FP)
	RET

	// This is called from rt0_go, which runs on the system stack
	// using the initial stack allocated by the OS.
	TEXT runtime·wintls(SB),NOSPLIT,$0
	// Allocate a TLS slot to hold g across calls to external code
	MOVL SP, BP
	MOVL runtime·_TlsAlloc(SB), AX
	CALL AX
	MOVL BP, SP

	MOVL AX, CX // TLS index

	// Assert that slot is less than 64 so we can use _TEB->TlsSlots
	CMPL CX, $64
	JB ok
	// Fallback to the TEB arbitrary pointer.
	// TODO: don't use the arbitrary pointer (see go.dev/issue/59824)
	MOVL $TEB_ArbitraryPtr, CX
	JMP settls
	ok:
	// Convert the TLS index at CX into
	// an offset from TEB_TlsSlots.
	SHLL $2, CX

	// Save offset from TLS into tls_g.
	ADDL $TEB_TlsSlots, CX
	settls:
	MOVL CX, runtime·tls_g(SB)
	RET