mirror of
https://github.com/golang/go
synced 2024-10-04 14:31:21 -06:00
f8d49b509b
The naming in this package is a disaster. Make it all consistent. Remove some 'static' from functions that will be referred to from other files soon. This CL is purely renames using global search and replace. Submitting separately so that real changes will not be drowned out by these renames in future CLs. TBR=iant CC=golang-dev https://golang.org/cl/7416046
726 lines
16 KiB
ArmAsm
726 lines
16 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 "zasm_GOOS_GOARCH.h"
|
|
|
|
TEXT _rt0_amd64(SB),7,$-8
|
|
// copy arguments forward on an even stack
|
|
MOVQ 0(DI), AX // argc
|
|
LEAQ 8(DI), BX // argv
|
|
SUBQ $(4*8+7), SP // 2args 2auto
|
|
ANDQ $~15, SP
|
|
MOVQ AX, 16(SP)
|
|
MOVQ BX, 24(SP)
|
|
|
|
// create istack out of the given (operating system) stack.
|
|
// _cgo_init may update stackguard.
|
|
MOVQ $runtime·g0(SB), DI
|
|
LEAQ (-64*1024+104)(SP), BX
|
|
MOVQ BX, g_stackguard(DI)
|
|
MOVQ SP, g_stackbase(DI)
|
|
|
|
// if there is an _cgo_init, call it.
|
|
MOVQ _cgo_init(SB), AX
|
|
TESTQ AX, AX
|
|
JZ needtls
|
|
// g0 already in DI
|
|
MOVQ DI, CX // Win64 uses CX for first parameter
|
|
CALL AX
|
|
CMPL runtime·iswindows(SB), $0
|
|
JEQ ok
|
|
|
|
needtls:
|
|
// skip TLS setup on Plan 9
|
|
CMPL runtime·isplan9(SB), $1
|
|
JEQ ok
|
|
|
|
LEAQ runtime·tls0(SB), DI
|
|
CALL runtime·settls(SB)
|
|
|
|
// store through it, to make sure it works
|
|
get_tls(BX)
|
|
MOVQ $0x123, g(BX)
|
|
MOVQ runtime·tls0(SB), AX
|
|
CMPQ AX, $0x123
|
|
JEQ 2(PC)
|
|
MOVL AX, 0 // abort
|
|
ok:
|
|
// set the per-goroutine and per-mach "registers"
|
|
get_tls(BX)
|
|
LEAQ runtime·g0(SB), CX
|
|
MOVQ CX, g(BX)
|
|
LEAQ runtime·m0(SB), AX
|
|
MOVQ AX, m(BX)
|
|
|
|
// save m->g0 = g0
|
|
MOVQ CX, m_g0(AX)
|
|
|
|
CLD // convention is D is always left cleared
|
|
CALL runtime·check(SB)
|
|
|
|
MOVL 16(SP), AX // copy argc
|
|
MOVL AX, 0(SP)
|
|
MOVQ 24(SP), AX // copy argv
|
|
MOVQ AX, 8(SP)
|
|
CALL runtime·args(SB)
|
|
CALL runtime·osinit(SB)
|
|
CALL runtime·schedinit(SB)
|
|
|
|
// create a new goroutine to start program
|
|
PUSHQ $runtime·main·f(SB) // entry
|
|
PUSHQ $0 // arg size
|
|
CALL runtime·newproc(SB)
|
|
POPQ AX
|
|
POPQ AX
|
|
|
|
// start this M
|
|
CALL runtime·mstart(SB)
|
|
|
|
MOVL $0xf1, 0xf1 // crash
|
|
RET
|
|
|
|
DATA runtime·main·f+0(SB)/8,$runtime·main(SB)
|
|
GLOBL runtime·main·f(SB),8,$8
|
|
|
|
TEXT runtime·breakpoint(SB),7,$0
|
|
BYTE $0xcc
|
|
RET
|
|
|
|
TEXT runtime·asminit(SB),7,$0
|
|
// No per-thread init.
|
|
RET
|
|
|
|
/*
|
|
* go-routine
|
|
*/
|
|
|
|
// void gosave(Gobuf*)
|
|
// save state in Gobuf; setjmp
|
|
TEXT runtime·gosave(SB), 7, $0
|
|
MOVQ 8(SP), AX // gobuf
|
|
LEAQ 8(SP), BX // caller's SP
|
|
MOVQ BX, gobuf_sp(AX)
|
|
MOVQ 0(SP), BX // caller's PC
|
|
MOVQ BX, gobuf_pc(AX)
|
|
get_tls(CX)
|
|
MOVQ g(CX), BX
|
|
MOVQ BX, gobuf_g(AX)
|
|
RET
|
|
|
|
// void gogo(Gobuf*, uintptr)
|
|
// restore state from Gobuf; longjmp
|
|
TEXT runtime·gogo(SB), 7, $0
|
|
MOVQ 16(SP), AX // return 2nd arg
|
|
MOVQ 8(SP), BX // gobuf
|
|
MOVQ gobuf_g(BX), DX
|
|
MOVQ 0(DX), CX // make sure g != nil
|
|
get_tls(CX)
|
|
MOVQ DX, g(CX)
|
|
MOVQ gobuf_sp(BX), SP // restore SP
|
|
MOVQ gobuf_pc(BX), BX
|
|
JMP BX
|
|
|
|
// void gogocall(Gobuf*, void (*fn)(void), uintptr r0)
|
|
// restore state from Gobuf but then call fn.
|
|
// (call fn, returning to state in Gobuf)
|
|
TEXT runtime·gogocall(SB), 7, $0
|
|
MOVQ 24(SP), DX // context
|
|
MOVQ 16(SP), AX // fn
|
|
MOVQ 8(SP), BX // gobuf
|
|
MOVQ gobuf_g(BX), DI
|
|
get_tls(CX)
|
|
MOVQ DI, g(CX)
|
|
MOVQ 0(DI), CX // make sure g != nil
|
|
MOVQ gobuf_sp(BX), SP // restore SP
|
|
MOVQ gobuf_pc(BX), BX
|
|
PUSHQ BX
|
|
JMP AX
|
|
POPQ BX // not reached
|
|
|
|
// void gogocallfn(Gobuf*, FuncVal*)
|
|
// restore state from Gobuf but then call fn.
|
|
// (call fn, returning to state in Gobuf)
|
|
TEXT runtime·gogocallfn(SB), 7, $0
|
|
MOVQ 16(SP), DX // fn
|
|
MOVQ 8(SP), BX // gobuf
|
|
MOVQ gobuf_g(BX), AX
|
|
get_tls(CX)
|
|
MOVQ AX, g(CX)
|
|
MOVQ 0(AX), CX // make sure g != nil
|
|
MOVQ gobuf_sp(BX), SP // restore SP
|
|
MOVQ gobuf_pc(BX), BX
|
|
PUSHQ BX
|
|
MOVQ 0(DX), BX
|
|
JMP BX
|
|
POPQ BX // not reached
|
|
|
|
// void mcall(void (*fn)(G*))
|
|
// Switch to m->g0's stack, call fn(g).
|
|
// Fn must never return. It should gogo(&g->sched)
|
|
// to keep running g.
|
|
TEXT runtime·mcall(SB), 7, $0
|
|
MOVQ fn+0(FP), DI
|
|
|
|
get_tls(CX)
|
|
MOVQ g(CX), AX // save state in g->gobuf
|
|
MOVQ 0(SP), BX // caller's PC
|
|
MOVQ BX, (g_sched+gobuf_pc)(AX)
|
|
LEAQ 8(SP), BX // caller's SP
|
|
MOVQ BX, (g_sched+gobuf_sp)(AX)
|
|
MOVQ AX, (g_sched+gobuf_g)(AX)
|
|
|
|
// switch to m->g0 & its stack, call fn
|
|
MOVQ m(CX), BX
|
|
MOVQ m_g0(BX), SI
|
|
CMPQ SI, AX // if g == m->g0 call badmcall
|
|
JNE 2(PC)
|
|
CALL runtime·badmcall(SB)
|
|
MOVQ SI, g(CX) // g = m->g0
|
|
MOVQ (g_sched+gobuf_sp)(SI), SP // sp = m->g0->gobuf.sp
|
|
PUSHQ AX
|
|
CALL DI
|
|
POPQ AX
|
|
CALL runtime·badmcall2(SB)
|
|
RET
|
|
|
|
/*
|
|
* support for morestack
|
|
*/
|
|
|
|
// Called during function prolog when more stack is needed.
|
|
// Caller has already done get_tls(CX); MOVQ m(CX), BX.
|
|
TEXT runtime·morestack(SB),7,$0
|
|
// Cannot grow scheduler stack (m->g0).
|
|
MOVQ m_g0(BX), SI
|
|
CMPQ g(CX), SI
|
|
JNE 2(PC)
|
|
INT $3
|
|
|
|
MOVQ DX, m_cret(BX)
|
|
|
|
// Called from f.
|
|
// Set m->morebuf to f's caller.
|
|
MOVQ 8(SP), AX // f's caller's PC
|
|
MOVQ AX, (m_morebuf+gobuf_pc)(BX)
|
|
LEAQ 16(SP), AX // f's caller's SP
|
|
MOVQ AX, (m_morebuf+gobuf_sp)(BX)
|
|
MOVQ AX, m_moreargp(BX)
|
|
get_tls(CX)
|
|
MOVQ g(CX), SI
|
|
MOVQ SI, (m_morebuf+gobuf_g)(BX)
|
|
|
|
// Set m->morepc to f's PC.
|
|
MOVQ 0(SP), AX
|
|
MOVQ AX, m_morepc(BX)
|
|
|
|
// Call newstack on m->g0's stack.
|
|
MOVQ m_g0(BX), BP
|
|
MOVQ BP, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(BP), SP
|
|
CALL runtime·newstack(SB)
|
|
MOVQ $0, 0x1003 // crash if newstack returns
|
|
RET
|
|
|
|
// Called from reflection library. 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
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
|
|
// Save our caller's state as the PC and SP to
|
|
// restore when returning from f.
|
|
MOVQ 0(SP), AX // our caller's PC
|
|
MOVQ AX, (m_morebuf+gobuf_pc)(BX)
|
|
LEAQ 8(SP), AX // our caller's SP
|
|
MOVQ AX, (m_morebuf+gobuf_sp)(BX)
|
|
MOVQ g(CX), AX
|
|
MOVQ AX, (m_morebuf+gobuf_g)(BX)
|
|
|
|
// 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.
|
|
// 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).
|
|
MOVQ 8(SP), AX // fn
|
|
MOVQ 16(SP), DX // arg frame
|
|
MOVL 24(SP), CX // arg size
|
|
|
|
MOVQ AX, m_morepc(BX) // f's PC
|
|
MOVQ DX, m_moreargp(BX) // argument frame 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.
|
|
MOVQ m_g0(BX), BP
|
|
get_tls(CX)
|
|
MOVQ BP, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(BP), SP
|
|
CALL runtime·newstack(SB)
|
|
MOVQ $0, 0x1103 // crash if newstack returns
|
|
RET
|
|
|
|
// Return point when leaving stack.
|
|
TEXT runtime·lessstack(SB), 7, $0
|
|
// Save return value in m->cret
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
MOVQ AX, m_cret(BX)
|
|
|
|
// Call oldstack on m->g0's stack.
|
|
MOVQ m_g0(BX), BP
|
|
MOVQ BP, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(BP), SP
|
|
CALL runtime·oldstack(SB)
|
|
MOVQ $0, 0x1004 // crash if oldstack returns
|
|
RET
|
|
|
|
// morestack trampolines
|
|
TEXT runtime·morestack00(SB),7,$0
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
MOVQ $0, AX
|
|
MOVQ AX, m_moreframesize(BX)
|
|
MOVQ $runtime·morestack(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack01(SB),7,$0
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
SHLQ $32, AX
|
|
MOVQ AX, m_moreframesize(BX)
|
|
MOVQ $runtime·morestack(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack10(SB),7,$0
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
MOVLQZX AX, AX
|
|
MOVQ AX, m_moreframesize(BX)
|
|
MOVQ $runtime·morestack(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack11(SB),7,$0
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
MOVQ AX, m_moreframesize(BX)
|
|
MOVQ $runtime·morestack(SB), AX
|
|
JMP AX
|
|
|
|
// subcases of morestack01
|
|
// with const of 8,16,...48
|
|
TEXT runtime·morestack8(SB),7,$0
|
|
PUSHQ $1
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack16(SB),7,$0
|
|
PUSHQ $2
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack24(SB),7,$0
|
|
PUSHQ $3
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack32(SB),7,$0
|
|
PUSHQ $4
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack40(SB),7,$0
|
|
PUSHQ $5
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT runtime·morestack48(SB),7,$0
|
|
PUSHQ $6
|
|
MOVQ $morestack<>(SB), AX
|
|
JMP AX
|
|
|
|
TEXT morestack<>(SB),7,$0
|
|
get_tls(CX)
|
|
MOVQ m(CX), BX
|
|
POPQ AX
|
|
SHLQ $35, AX
|
|
MOVQ AX, m_moreframesize(BX)
|
|
MOVQ $runtime·morestack(SB), AX
|
|
JMP AX
|
|
|
|
// bool cas(int32 *val, int32 old, int32 new)
|
|
// Atomically:
|
|
// if(*val == old){
|
|
// *val = new;
|
|
// return 1;
|
|
// } else
|
|
// return 0;
|
|
TEXT runtime·cas(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVL 16(SP), AX
|
|
MOVL 20(SP), CX
|
|
LOCK
|
|
CMPXCHGL CX, 0(BX)
|
|
JZ 3(PC)
|
|
MOVL $0, AX
|
|
RET
|
|
MOVL $1, AX
|
|
RET
|
|
|
|
// bool runtime·cas64(uint64 *val, uint64 *old, uint64 new)
|
|
// Atomically:
|
|
// if(*val == *old){
|
|
// *val = new;
|
|
// return 1;
|
|
// } else {
|
|
// *old = *val
|
|
// return 0;
|
|
// }
|
|
TEXT runtime·cas64(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVQ 16(SP), BP
|
|
MOVQ 0(BP), AX
|
|
MOVQ 24(SP), CX
|
|
LOCK
|
|
CMPXCHGQ CX, 0(BX)
|
|
JNZ cas64_fail
|
|
MOVL $1, AX
|
|
RET
|
|
cas64_fail:
|
|
MOVQ AX, 0(BP)
|
|
MOVL $0, AX
|
|
RET
|
|
|
|
// bool casp(void **val, void *old, void *new)
|
|
// Atomically:
|
|
// if(*val == old){
|
|
// *val = new;
|
|
// return 1;
|
|
// } else
|
|
// return 0;
|
|
TEXT runtime·casp(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVQ 16(SP), AX
|
|
MOVQ 24(SP), CX
|
|
LOCK
|
|
CMPXCHGQ CX, 0(BX)
|
|
JZ 3(PC)
|
|
MOVL $0, AX
|
|
RET
|
|
MOVL $1, AX
|
|
RET
|
|
|
|
// uint32 xadd(uint32 volatile *val, int32 delta)
|
|
// Atomically:
|
|
// *val += delta;
|
|
// return *val;
|
|
TEXT runtime·xadd(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVL 16(SP), AX
|
|
MOVL AX, CX
|
|
LOCK
|
|
XADDL AX, 0(BX)
|
|
ADDL CX, AX
|
|
RET
|
|
|
|
TEXT runtime·xadd64(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVQ 16(SP), AX
|
|
MOVQ AX, CX
|
|
LOCK
|
|
XADDQ AX, 0(BX)
|
|
ADDQ CX, AX
|
|
RET
|
|
|
|
TEXT runtime·xchg(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVL 16(SP), AX
|
|
XCHGL AX, 0(BX)
|
|
RET
|
|
|
|
TEXT runtime·procyield(SB),7,$0
|
|
MOVL 8(SP), AX
|
|
again:
|
|
PAUSE
|
|
SUBL $1, AX
|
|
JNZ again
|
|
RET
|
|
|
|
TEXT runtime·atomicstorep(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVQ 16(SP), AX
|
|
XCHGQ AX, 0(BX)
|
|
RET
|
|
|
|
TEXT runtime·atomicstore(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVL 16(SP), AX
|
|
XCHGL AX, 0(BX)
|
|
RET
|
|
|
|
TEXT runtime·atomicstore64(SB), 7, $0
|
|
MOVQ 8(SP), BX
|
|
MOVQ 16(SP), AX
|
|
XCHGQ AX, 0(BX)
|
|
RET
|
|
|
|
// void jmpdefer(fn, sp);
|
|
// called from deferreturn.
|
|
// 1. pop the caller
|
|
// 2. sub 5 bytes from the callers return
|
|
// 3. jmp to the argument
|
|
TEXT runtime·jmpdefer(SB), 7, $0
|
|
MOVQ 8(SP), DX // fn
|
|
MOVQ 16(SP), BX // caller sp
|
|
LEAQ -8(BX), SP // caller sp after CALL
|
|
SUBQ $5, (SP) // return to CALL again
|
|
MOVQ 0(DX), BX
|
|
JMP BX // but first run the deferred function
|
|
|
|
// Dummy function to use in saved gobuf.PC,
|
|
// to match SP pointing at a return address.
|
|
// The gobuf.PC is unused by the contortions here
|
|
// but setting it to return will make the traceback code work.
|
|
TEXT return<>(SB),7,$0
|
|
RET
|
|
|
|
// asmcgocall(void(*fn)(void*), void *arg)
|
|
// Call fn(arg) on the scheduler stack,
|
|
// aligned appropriately for the gcc ABI.
|
|
// See cgocall.c for more details.
|
|
TEXT runtime·asmcgocall(SB),7,$0
|
|
MOVQ fn+0(FP), AX
|
|
MOVQ arg+8(FP), BX
|
|
MOVQ SP, DX
|
|
|
|
// Figure out if we need to switch to m->g0 stack.
|
|
// We get called to create new OS threads too, and those
|
|
// come in on the m->g0 stack already.
|
|
get_tls(CX)
|
|
MOVQ m(CX), BP
|
|
MOVQ m_g0(BP), SI
|
|
MOVQ g(CX), DI
|
|
CMPQ SI, DI
|
|
JEQ 6(PC)
|
|
MOVQ SP, (g_sched+gobuf_sp)(DI)
|
|
MOVQ $return<>(SB), (g_sched+gobuf_pc)(DI)
|
|
MOVQ DI, (g_sched+gobuf_g)(DI)
|
|
MOVQ SI, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(SI), SP
|
|
|
|
// Now on a scheduling stack (a pthread-created stack).
|
|
// Make sure we have enough room for 4 stack-backed fast-call
|
|
// registers as per windows amd64 calling convention.
|
|
SUBQ $64, SP
|
|
ANDQ $~15, SP // alignment for gcc ABI
|
|
MOVQ DI, 48(SP) // save g
|
|
MOVQ DX, 40(SP) // save SP
|
|
MOVQ BX, DI // DI = first argument in AMD64 ABI
|
|
MOVQ BX, CX // CX = first argument in Win64
|
|
CALL AX
|
|
|
|
// Restore registers, g, stack pointer.
|
|
get_tls(CX)
|
|
MOVQ 48(SP), DI
|
|
MOVQ DI, g(CX)
|
|
MOVQ 40(SP), SP
|
|
RET
|
|
|
|
// cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
|
|
// Turn the fn into a Go func (by taking its address) and call
|
|
// cgocallback_gofunc.
|
|
TEXT runtime·cgocallback(SB),7,$24
|
|
LEAQ fn+0(FP), AX
|
|
MOVQ AX, 0(SP)
|
|
MOVQ frame+8(FP), AX
|
|
MOVQ AX, 8(SP)
|
|
MOVQ framesize+16(FP), AX
|
|
MOVQ AX, 16(SP)
|
|
MOVQ $runtime·cgocallback_gofunc(SB), AX
|
|
CALL AX
|
|
RET
|
|
|
|
// cgocallback_gofunc(FuncVal*, void *frame, uintptr framesize)
|
|
// See cgocall.c for more details.
|
|
TEXT runtime·cgocallback_gofunc(SB),7,$24
|
|
// If m is nil, Go did not create the current thread.
|
|
// Call needm to obtain one for temporary use.
|
|
// In this case, we're running on the thread stack, so there's
|
|
// lots of space, but the linker doesn't know. Hide the call from
|
|
// the linker analysis by using an indirect call through AX.
|
|
get_tls(CX)
|
|
#ifdef GOOS_windows
|
|
CMPQ CX, $0
|
|
JNE 3(PC)
|
|
PUSHQ $0
|
|
JMP needm
|
|
#endif
|
|
MOVQ m(CX), BP
|
|
PUSHQ BP
|
|
CMPQ BP, $0
|
|
JNE havem
|
|
needm:
|
|
MOVQ $runtime·needm(SB), AX
|
|
CALL AX
|
|
get_tls(CX)
|
|
MOVQ m(CX), BP
|
|
|
|
havem:
|
|
// Now there's a valid m, and we're running on its m->g0.
|
|
// Save current m->g0->sched.sp on stack and then set it to SP.
|
|
// Save current sp in m->g0->sched.sp in preparation for
|
|
// switch back to m->curg stack.
|
|
MOVQ m_g0(BP), SI
|
|
PUSHQ (g_sched+gobuf_sp)(SI)
|
|
MOVQ SP, (g_sched+gobuf_sp)(SI)
|
|
|
|
// Switch to m->curg stack and call runtime.cgocallbackg
|
|
// with the three arguments. Because we are taking over
|
|
// the execution of m->curg but *not* resuming what had
|
|
// been running, we need to save that information (m->curg->gobuf)
|
|
// so that we can restore it when we're done.
|
|
// We can restore m->curg->gobuf.sp easily, because calling
|
|
// runtime.cgocallbackg leaves SP unchanged upon return.
|
|
// To save m->curg->gobuf.pc, we push it onto the stack.
|
|
// This has the added benefit that it looks to the traceback
|
|
// routine like cgocallbackg is going to return to that
|
|
// PC (because we defined cgocallbackg to have
|
|
// a frame size of 24, the same amount that we use below),
|
|
// so that the traceback will seamlessly trace back into
|
|
// the earlier calls.
|
|
MOVQ fn+0(FP), AX
|
|
MOVQ frame+8(FP), BX
|
|
MOVQ framesize+16(FP), DX
|
|
|
|
MOVQ m_curg(BP), SI
|
|
MOVQ SI, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(SI), DI // prepare stack as DI
|
|
|
|
// Push gobuf.pc
|
|
MOVQ (g_sched+gobuf_pc)(SI), BP
|
|
SUBQ $8, DI
|
|
MOVQ BP, 0(DI)
|
|
|
|
// Push arguments to cgocallbackg.
|
|
// Frame size here must match the frame size above
|
|
// to trick traceback routines into doing the right thing.
|
|
SUBQ $24, DI
|
|
MOVQ AX, 0(DI)
|
|
MOVQ BX, 8(DI)
|
|
MOVQ DX, 16(DI)
|
|
|
|
// Switch stack and make the call.
|
|
MOVQ DI, SP
|
|
CALL runtime·cgocallbackg(SB)
|
|
|
|
// Restore g->gobuf (== m->curg->gobuf) from saved values.
|
|
get_tls(CX)
|
|
MOVQ g(CX), SI
|
|
MOVQ 24(SP), BP
|
|
MOVQ BP, (g_sched+gobuf_pc)(SI)
|
|
LEAQ (24+8)(SP), DI
|
|
MOVQ DI, (g_sched+gobuf_sp)(SI)
|
|
|
|
// Switch back to m->g0's stack and restore m->g0->sched.sp.
|
|
// (Unlike m->curg, the g0 goroutine never uses sched.pc,
|
|
// so we do not have to restore it.)
|
|
MOVQ m(CX), BP
|
|
MOVQ m_g0(BP), SI
|
|
MOVQ SI, g(CX)
|
|
MOVQ (g_sched+gobuf_sp)(SI), SP
|
|
POPQ (g_sched+gobuf_sp)(SI)
|
|
|
|
// If the m on entry was nil, we called needm above to borrow an m
|
|
// for the duration of the call. Since the call is over, return it with dropm.
|
|
POPQ BP
|
|
CMPQ BP, $0
|
|
JNE 3(PC)
|
|
MOVQ $runtime·dropm(SB), AX
|
|
CALL AX
|
|
|
|
// Done!
|
|
RET
|
|
|
|
// void setmg(M*, G*); set m and g. for use by needm.
|
|
TEXT runtime·setmg(SB), 7, $0
|
|
MOVQ mm+0(FP), AX
|
|
#ifdef GOOS_windows
|
|
CMPQ AX, $0
|
|
JNE settls
|
|
MOVQ $0, 0x28(GS)
|
|
RET
|
|
settls:
|
|
LEAQ m_tls(AX), AX
|
|
MOVQ AX, 0x28(GS)
|
|
#endif
|
|
get_tls(CX)
|
|
MOVQ mm+0(FP), AX
|
|
MOVQ AX, m(CX)
|
|
MOVQ gg+8(FP), BX
|
|
MOVQ BX, g(CX)
|
|
RET
|
|
|
|
// check that SP is in range [g->stackbase, g->stackguard)
|
|
TEXT runtime·stackcheck(SB), 7, $0
|
|
get_tls(CX)
|
|
MOVQ g(CX), AX
|
|
CMPQ g_stackbase(AX), SP
|
|
JHI 2(PC)
|
|
INT $3
|
|
CMPQ SP, g_stackguard(AX)
|
|
JHI 2(PC)
|
|
INT $3
|
|
RET
|
|
|
|
TEXT runtime·memclr(SB),7,$0
|
|
MOVQ 8(SP), DI // arg 1 addr
|
|
MOVQ 16(SP), CX // arg 2 count
|
|
MOVQ CX, BX
|
|
ANDQ $7, BX
|
|
SHRQ $3, CX
|
|
MOVQ $0, AX
|
|
CLD
|
|
REP
|
|
STOSQ
|
|
MOVQ BX, CX
|
|
REP
|
|
STOSB
|
|
RET
|
|
|
|
TEXT runtime·getcallerpc(SB),7,$0
|
|
MOVQ x+0(FP),AX // addr of first arg
|
|
MOVQ -8(AX),AX // get calling pc
|
|
RET
|
|
|
|
TEXT runtime·setcallerpc(SB),7,$0
|
|
MOVQ x+0(FP),AX // addr of first arg
|
|
MOVQ x+8(FP), BX
|
|
MOVQ BX, -8(AX) // set calling pc
|
|
RET
|
|
|
|
TEXT runtime·getcallersp(SB),7,$0
|
|
MOVQ sp+0(FP), AX
|
|
RET
|
|
|
|
// int64 runtime·cputicks(void)
|
|
TEXT runtime·cputicks(SB),7,$0
|
|
RDTSC
|
|
SHLQ $32, DX
|
|
ADDQ DX, AX
|
|
RET
|
|
|
|
TEXT runtime·stackguard(SB),7,$0
|
|
MOVQ SP, DX
|
|
MOVQ DX, sp+0(FP)
|
|
get_tls(CX)
|
|
MOVQ g(CX), BX
|
|
MOVQ g_stackguard(BX), DX
|
|
MOVQ DX, guard+8(FP)
|
|
RET
|
|
|
|
GLOBL runtime·tls0(SB), $64
|