mirror of https://go.googlesource.com/go
283 lines
6.5 KiB
ArmAsm
283 lines
6.5 KiB
ArmAsm
// 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
|