blob: 52b0a89bcb6db5309d67fc09e29f32efe78afb80 [file] [log] [blame]
// 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 "amd64/asm.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)
// if there is an initcgo, call it.
MOVQ initcgo(SB), AX
TESTQ AX, AX
JZ 2(PC)
CALL AX
// set the per-goroutine and per-mach registers
LEAQ m0(SB), m
LEAQ g0(SB), g
MOVQ g, m_g0(m) // m has pointer to its g0
// create istack out of the given (operating system) stack
LEAQ (-8192+104)(SP), AX
MOVQ AX, g_stackguard(g)
MOVQ SP, g_stackbase(g)
CLD // convention is D is always left cleared
CALL check(SB)
MOVL 16(SP), AX // copy argc
MOVL AX, 0(SP)
MOVQ 24(SP), AX // copy argv
MOVQ AX, 8(SP)
CALL args(SB)
CALL osinit(SB)
CALL schedinit(SB)
// create a new goroutine to start program
PUSHQ $mainstart(SB) // entry
PUSHQ $0 // arg size
CALL ·newproc(SB)
POPQ AX
POPQ AX
// start this M
CALL mstart(SB)
CALL notok(SB) // never returns
RET
TEXT mainstart(SB),7,$0
CALL main·init(SB)
CALL initdone(SB)
CALL main·main(SB)
PUSHQ $0
CALL exit(SB)
POPQ AX
CALL notok(SB)
RET
TEXT breakpoint(SB),7,$0
BYTE $0xcc
RET
/*
* go-routine
*/
// uintptr gosave(Gobuf*)
// save state in Gobuf; setjmp
TEXT 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)
MOVQ g, gobuf_g(AX)
MOVL $0, AX // return 0
RET
// void gogo(Gobuf*, uintptr)
// restore state from Gobuf; longjmp
TEXT gogo(SB), 7, $0
MOVQ 16(SP), AX // return 2nd arg
MOVQ 8(SP), BX // gobuf
MOVQ gobuf_g(BX), g
MOVQ 0(g), CX // make sure g != nil
MOVQ gobuf_sp(BX), SP // restore SP
MOVQ gobuf_pc(BX), BX
JMP BX
// void gogocall(Gobuf*, void (*fn)(void))
// restore state from Gobuf but then call fn.
// (call fn, returning to state in Gobuf)
TEXT gogocall(SB), 7, $0
MOVQ 16(SP), AX // fn
MOVQ 8(SP), BX // gobuf
MOVQ gobuf_g(BX), g
MOVQ 0(g), 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
/*
* support for morestack
*/
// Called during function prolog when more stack is needed.
TEXT ·morestack(SB),7,$0
// 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)(m)
LEAQ 16(SP), AX // f's caller's SP
MOVQ AX, (m_morebuf+gobuf_sp)(m)
MOVQ AX, (m_morefp)(m)
MOVQ g, (m_morebuf+gobuf_g)(m)
// Set m->morepc to f's PC.
MOVQ 0(SP), AX
MOVQ AX, m_morepc(m)
// Call newstack on m's scheduling stack.
MOVQ m_g0(m), g
MOVQ (m_sched+gobuf_sp)(m), SP
CALL 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
// 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)(m)
LEAQ 8(SP), AX // our caller's SP
MOVQ AX, (m_morebuf+gobuf_sp)(m)
MOVQ g, (m_morebuf+gobuf_g)(m)
// 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), BX // arg frame
MOVL 24(SP), CX // arg size
MOVQ AX, m_morepc(m) // f's PC
MOVQ BX, m_morefp(m) // argument frame pointer
MOVL CX, m_moreargs(m) // f's argument size
MOVL $1, m_moreframe(m) // f's frame size
// Call newstack on m's scheduling stack.
MOVQ m_g0(m), g
MOVQ (m_sched+gobuf_sp)(m), SP
CALL newstack(SB)
MOVQ $0, 0x1103 // crash if newstack returns
RET
// Return point when leaving stack.
TEXT ·lessstack(SB), 7, $0
// Save return value in m->cret
MOVQ AX, m_cret(m)
// Call oldstack on m's scheduling stack.
MOVQ m_g0(m), g
MOVQ (m_sched+gobuf_sp)(m), SP
CALL oldstack(SB)
MOVQ $0, 0x1004 // crash if oldstack returns
RET
// morestack trampolines
TEXT ·morestack00+0(SB),7,$0
MOVQ $0, AX
MOVQ AX, m_moreframe(m)
MOVQ $·morestack+0(SB), AX
JMP AX
TEXT ·morestack01+0(SB),7,$0
SHLQ $32, AX
MOVQ AX, m_moreframe(m)
MOVQ $·morestack+0(SB), AX
JMP AX
TEXT ·morestack10+0(SB),7,$0
MOVLQZX AX, AX
MOVQ AX, m_moreframe(m)
MOVQ $·morestack+0(SB), AX
JMP AX
TEXT ·morestack11+0(SB),7,$0
MOVQ AX, m_moreframe(m)
MOVQ $·morestack+0(SB), AX
JMP AX
// subcases of morestack01
// with const of 8,16,...48
TEXT ·morestack8(SB),7,$0
PUSHQ $1
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestack16(SB),7,$0
PUSHQ $2
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestack24(SB),7,$0
PUSHQ $3
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestack32(SB),7,$0
PUSHQ $4
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestack40(SB),7,$0
PUSHQ $5
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestack48(SB),7,$0
PUSHQ $6
MOVQ $·morestackx(SB), AX
JMP AX
TEXT ·morestackx(SB),7,$0
POPQ AX
SHLQ $35, AX
MOVQ AX, m_moreframe(m)
MOVQ $·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 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
// 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 jmpdefer(SB), 7, $0
MOVQ 8(SP), AX // fn
MOVQ 16(SP), BX // caller sp
LEAQ -8(BX), SP // caller sp after CALL
SUBQ $5, (SP) // return to CALL again
JMP AX // but first run the deferred function
// runcgo(void(*fn)(void*), void *arg)
// Call fn(arg) on the scheduler stack,
// aligned appropriately for the gcc ABI.
// Save g and m across the call,
// since the foreign code might reuse them.
TEXT runcgo(SB),7,$32
MOVQ fn+0(FP), R12
MOVQ arg+8(FP), R13
MOVQ SP, CX
// Figure out if we need to switch to m->g0 stack.
MOVQ m_g0(m), SI
CMPQ SI, g
JEQ 2(PC)
MOVQ (m_sched+gobuf_sp)(m), SP
// Now on a scheduling stack (a pthread-created stack).
SUBQ $32, SP
ANDQ $~15, SP // alignment for gcc ABI
MOVQ g, 24(SP) // save old g, m, SP
MOVQ m, 16(SP)
MOVQ CX, 8(SP)
// Save g and m values for a potential callback. The callback
// will start running with on the g0 stack and as such should
// have g set to m->g0.
MOVQ m, DI // DI = first argument in AMD64 ABI
// SI, second argument, set above
MOVQ libcgo_set_scheduler(SB), BX
CALL BX
MOVQ R13, DI // DI = first argument in AMD64 ABI
CALL R12
// Restore registers, stack pointer.
MOVQ 16(SP), m
MOVQ 24(SP), g
MOVQ 8(SP), SP
RET
// runcgocallback(G *g1, void* sp, void (*fn)(void))
// Switch to g1 and sp, call fn, switch back. fn's arguments are on
// the new stack.
TEXT runcgocallback(SB),7,$48
MOVQ g1+0(FP), DX
MOVQ sp+8(FP), AX
MOVQ fp+16(FP), BX
MOVQ DX, g
// We are running on m's scheduler stack. Save current SP
// into m->sched.sp so that a recursive call to runcgo doesn't
// clobber our stack, and also so that we can restore
// the SP when the call finishes. Reusing m->sched.sp
// for this purpose depends on the fact that there is only
// one possible gosave of m->sched.
MOVQ SP, (m_sched+gobuf_sp)(m)
// Set new SP, call fn
MOVQ AX, SP
CALL BX
// Restore old SP, return
MOVQ (m_sched+gobuf_sp)(m), SP
RET
// check that SP is in range [g->stackbase, g->stackguard)
TEXT stackcheck(SB), 7, $0
CMPQ g_stackbase(g), SP
JHI 2(PC)
INT $3
CMPQ SP, g_stackguard(g)
JHI 2(PC)
INT $3
RET
TEXT ·memclr(SB),7,$0
MOVQ 8(SP), DI // arg 1 addr
MOVL 16(SP), CX // arg 2 count
ADDL $7, CX
SHRL $3, CX
MOVQ $0, AX
CLD
REP
STOSQ
RET
TEXT ·getcallerpc+0(SB),7,$0
MOVQ x+0(FP),AX // addr of first arg
MOVQ -8(AX),AX // get calling pc
RET
TEXT ·setcallerpc+0(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 getcallersp(SB),7,$0
MOVQ sp+0(FP), AX
RET
GLOBL initcgo(SB), $8
GLOBL libcgo_set_scheduler(SB), $8