| // 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. |
| |
| |
| TEXT _rt0_amd64(SB),7,$-8 |
| |
| // copy arguments forward on an even stack |
| |
| MOVQ 0(SP), AX // argc |
| LEAQ 8(SP), BX // argv |
| SUBQ $(4*8+7), SP // 2args 2auto |
| ANDQ $~7, SP |
| MOVQ AX, 16(SP) |
| MOVQ BX, 24(SP) |
| |
| // allocate the per-user block |
| |
| LEAQ peruser<>(SB), R15 // dedicated u. register |
| |
| LEAQ (-4096+104+4*8)(SP), AX |
| MOVQ AX, 0(R15) // 0(R15) is stack limit (w 104b guard) |
| |
| MOVL $1024, AX |
| MOVL AX, 0(SP) |
| CALL mal(SB) |
| |
| LEAQ 104(AX), BX |
| MOVQ BX, 16(R15) // 16(R15) is limit of istack (w 104b guard) |
| |
| ADDQ 0(SP), AX |
| LEAQ (-4*8)(AX), BX |
| MOVQ BX, 24(R15) // 24(R15) is base of istack (w auto*4) |
| |
| CALL check(SB) |
| |
| // process the arguments |
| |
| MOVL 16(SP), AX // copy argc |
| MOVL AX, 0(SP) |
| MOVQ 24(SP), AX // copy argv |
| MOVQ AX, 8(SP) |
| CALL args(SB) |
| |
| CALL main·main(SB) |
| |
| MOVQ $0, AX |
| MOVQ AX, 0(SP) // exit status |
| CALL sys·exit(SB) |
| |
| CALL notok(SB) // fault |
| RET |
| |
| // |
| // the calling sequence for a routine that |
| // needs N bytes stack, A args. |
| // |
| // N1 = (N+160 > 4096)? N+160: 0 |
| // A1 = A |
| // |
| // if N <= 75 |
| // CMPQ SP, 0(R15) |
| // JHI 3(PC) |
| // MOVQ $(N1<<0) | (A1<<32)), AX |
| // CALL _morestack |
| // |
| // if N > 75 |
| // LEAQ (-N-75)(SP), AX |
| // CMPQ AX, 0(R15) |
| // JHI 3(PC) |
| // MOVQ $(N1<<0) | (A1<<32)), AX |
| // CALL _morestack |
| // |
| |
| TEXT _morestack(SB), 7, $0 |
| // save stuff on interrupt stack |
| |
| MOVQ 24(R15), BX // istack |
| MOVQ SP, 8(BX) // old SP |
| MOVQ AX, 16(BX) // magic number |
| MOVQ 0(R15), AX // old limit |
| MOVQ AX, 24(BX) |
| |
| // switch and set up new limit |
| |
| MOVQ BX, SP |
| MOVQ 16(R15), AX // istack limit |
| MOVQ AX, 0(R15) |
| |
| // allocate a new stack max of request and 4k |
| |
| MOVL 16(SP), AX // magic number |
| CMPL AX, $4096 |
| JHI 2(PC) |
| MOVL $4096, AX |
| MOVL AX, 0(SP) |
| CALL mal(SB) |
| |
| // switch to new stack |
| |
| MOVQ SP, BX // istack |
| ADDQ $104, AX // new stack limit |
| MOVQ AX, 0(R15) |
| ADDQ 0(SP), AX |
| LEAQ (-104-4*8)(AX), SP // new SP |
| MOVQ 8(R15), AX |
| MOVQ AX, 0(SP) // old base |
| MOVQ SP, 8(R15) // new base |
| |
| // copy needed stuff from istack to new stack |
| |
| MOVQ 16(BX), AX // magic number |
| MOVQ AX, 16(SP) |
| MOVQ 24(BX), AX // old limit |
| MOVQ AX, 24(SP) |
| MOVQ 8(BX), AX // old SP |
| MOVQ AX, 8(SP) |
| |
| // are there parameters |
| |
| MOVL 20(SP), CX // copy count |
| CMPL CX, $0 |
| JEQ easy |
| |
| // copy in |
| |
| LEAQ 16(AX), SI |
| SUBQ CX, SP |
| MOVQ SP, DI |
| SHRL $3, CX |
| CLD |
| REP |
| MOVSQ |
| |
| // call the intended |
| CALL 0(AX) |
| |
| // copy out |
| |
| MOVQ SP, SI |
| MOVQ 8(R15), BX // new base |
| MOVQ 8(BX), AX // old SP |
| LEAQ 16(AX), DI |
| MOVL 20(BX), CX // copy count |
| SHRL $3, CX |
| CLD |
| REP |
| MOVSQ |
| |
| // restore old SP and limit |
| MOVQ 8(R15), SP // new base |
| MOVQ 24(SP), AX // old limit |
| MOVQ AX, 0(R15) |
| MOVQ 0(SP), AX |
| MOVQ AX, 8(R15) // old base |
| MOVQ 8(SP), AX // old SP |
| MOVQ AX, SP |
| |
| // and return to the call behind mine |
| ADDQ $8, SP |
| RET |
| |
| easy: |
| CALL 0(AX) |
| |
| // restore old SP and limit |
| MOVQ 24(SP), AX // old limit |
| MOVQ AX, 0(R15) |
| MOVQ 0(SP), AX |
| MOVQ AX, 8(R15) // old base |
| MOVQ 8(SP), AX // old SP |
| MOVQ AX, SP |
| |
| // and return to the call behind mine |
| ADDQ $8, SP |
| RET |
| |
| // marker. must be here; used by traceback() to discover calls to _morestack |
| TEXT _endmorestack(SB), 7, $-8 |
| RET |
| |
| // call a subroutine in a new coroutine |
| // argument list is on the stack addr of fn is in AX |
| TEXT sys·_newproc(SB), 7, $0 |
| JMP AX |
| RET |
| |
| TEXT FLUSH(SB),7,$-8 |
| RET |
| |
| TEXT getu(SB),7,$-8 |
| MOVQ R15, AX |
| RET |
| |
| GLOBL peruser<>(SB),$64 |
