mirror of
https://github.com/golang/go
synced 2024-11-20 07:44:41 -07:00
e6d3511264
This reverts commit ab0535ae3f.
I think it will remain useful to distinguish code that must
run on a system stack from code that can run on either stack,
even if that distinction is no
longer based on the implementation language.
That is, I expect to add a //go:systemstack comment that,
in terms of the old implementation, tells the compiler,
to pretend this function was written in C.
Change-Id: I33d2ebb2f99ae12496484c6ec8ed07233d693275
Reviewed-on: https://go-review.googlesource.com/2275
Reviewed-by: Russ Cox <rsc@golang.org>
256 lines
4.5 KiB
ArmAsm
256 lines
4.5 KiB
ArmAsm
// Copyright 2010 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"
|
|
|
|
// setldt(int entry, int address, int limit)
|
|
TEXT runtime·setldt(SB),NOSPLIT,$0
|
|
RET
|
|
|
|
TEXT runtime·open(SB),NOSPLIT,$0
|
|
MOVQ $14, BP
|
|
SYSCALL
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·pread(SB),NOSPLIT,$0
|
|
MOVQ $50, BP
|
|
SYSCALL
|
|
MOVL AX, ret+32(FP)
|
|
RET
|
|
|
|
TEXT runtime·pwrite(SB),NOSPLIT,$0
|
|
MOVQ $51, BP
|
|
SYSCALL
|
|
MOVL AX, ret+32(FP)
|
|
RET
|
|
|
|
// int32 _seek(int64*, int32, int64, int32)
|
|
TEXT _seek<>(SB),NOSPLIT,$0
|
|
MOVQ $39, BP
|
|
SYSCALL
|
|
RET
|
|
|
|
// int64 seek(int32, int64, int32)
|
|
// Convenience wrapper around _seek, the actual system call.
|
|
TEXT runtime·seek(SB),NOSPLIT,$32
|
|
LEAQ ret+24(FP), AX
|
|
MOVL fd+0(FP), BX
|
|
MOVQ offset+8(FP), CX
|
|
MOVL whence+16(FP), DX
|
|
MOVQ AX, 0(SP)
|
|
MOVL BX, 8(SP)
|
|
MOVQ CX, 16(SP)
|
|
MOVL DX, 24(SP)
|
|
CALL _seek<>(SB)
|
|
CMPL AX, $0
|
|
JGE 2(PC)
|
|
MOVQ $-1, ret+24(FP)
|
|
RET
|
|
|
|
TEXT runtime·close(SB),NOSPLIT,$0
|
|
MOVQ $4, BP
|
|
SYSCALL
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·exits(SB),NOSPLIT,$0
|
|
MOVQ $8, BP
|
|
SYSCALL
|
|
RET
|
|
|
|
TEXT runtime·brk_(SB),NOSPLIT,$0
|
|
MOVQ $24, BP
|
|
SYSCALL
|
|
MOVQ AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·sleep(SB),NOSPLIT,$0
|
|
MOVQ $17, BP
|
|
SYSCALL
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
|
|
MOVQ $37, BP
|
|
SYSCALL
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
|
|
MOVQ $52, BP
|
|
SYSCALL
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·nsec(SB),NOSPLIT,$0
|
|
MOVQ $53, BP
|
|
SYSCALL
|
|
MOVQ AX, ret+8(FP)
|
|
RET
|
|
|
|
// func now() (sec int64, nsec int32)
|
|
TEXT time·now(SB),NOSPLIT,$8-12
|
|
CALL runtime·nanotime(SB)
|
|
MOVQ 0(SP), AX
|
|
|
|
// generated code for
|
|
// func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
|
|
// adapted to reduce duplication
|
|
MOVQ AX, CX
|
|
MOVQ $1360296554856532783, AX
|
|
MULQ CX
|
|
ADDQ CX, DX
|
|
RCRQ $1, DX
|
|
SHRQ $29, DX
|
|
MOVQ DX, sec+0(FP)
|
|
IMULQ $1000000000, DX
|
|
SUBQ DX, CX
|
|
MOVL CX, nsec+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·notify(SB),NOSPLIT,$0
|
|
MOVQ $28, BP
|
|
SYSCALL
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·noted(SB),NOSPLIT,$0
|
|
MOVQ $29, BP
|
|
SYSCALL
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
|
|
MOVQ $38, BP
|
|
SYSCALL
|
|
MOVL AX, ret+16(FP)
|
|
RET
|
|
|
|
TEXT runtime·rfork(SB),NOSPLIT,$0
|
|
MOVQ $19, BP
|
|
SYSCALL
|
|
MOVL AX, ret+8(FP)
|
|
RET
|
|
|
|
TEXT runtime·tstart_plan9(SB),NOSPLIT,$0
|
|
MOVQ newm+0(FP), CX
|
|
MOVQ m_g0(CX), DX
|
|
|
|
// Layout new m scheduler stack on os stack.
|
|
MOVQ SP, AX
|
|
MOVQ AX, (g_stack+stack_hi)(DX)
|
|
SUBQ $(64*1024), AX // stack size
|
|
MOVQ AX, (g_stack+stack_lo)(DX)
|
|
MOVQ AX, g_stackguard0(DX)
|
|
MOVQ AX, g_stackguard1(DX)
|
|
|
|
// Initialize procid from TOS struct.
|
|
MOVQ _tos(SB), AX
|
|
MOVL 64(AX), AX
|
|
MOVQ AX, m_procid(CX) // save pid as m->procid
|
|
|
|
// Finally, initialize g.
|
|
get_tls(BX)
|
|
MOVQ DX, g(BX)
|
|
|
|
CALL runtime·stackcheck(SB) // smashes AX, CX
|
|
CALL runtime·mstart(SB)
|
|
|
|
MOVQ $0x1234, 0x1234 // not reached
|
|
RET
|
|
|
|
// This is needed by asm_amd64.s
|
|
TEXT runtime·settls(SB),NOSPLIT,$0
|
|
RET
|
|
|
|
// void sigtramp(void *ureg, int8 *note)
|
|
TEXT runtime·sigtramp(SB),NOSPLIT,$0
|
|
get_tls(AX)
|
|
|
|
// check that g exists
|
|
MOVQ g(AX), BX
|
|
CMPQ BX, $0
|
|
JNE 3(PC)
|
|
CALL runtime·badsignal2(SB) // will exit
|
|
RET
|
|
|
|
// save args
|
|
MOVQ ureg+8(SP), CX
|
|
MOVQ note+16(SP), DX
|
|
|
|
// change stack
|
|
MOVQ g_m(BX), BX
|
|
MOVQ m_gsignal(BX), R10
|
|
MOVQ (g_stack+stack_hi)(R10), BP
|
|
MOVQ BP, SP
|
|
|
|
// make room for args and g
|
|
SUBQ $128, SP
|
|
|
|
// save g
|
|
MOVQ g(AX), BP
|
|
MOVQ BP, 32(SP)
|
|
|
|
// g = m->gsignal
|
|
MOVQ R10, g(AX)
|
|
|
|
// load args and call sighandler
|
|
MOVQ CX, 0(SP)
|
|
MOVQ DX, 8(SP)
|
|
MOVQ BP, 16(SP)
|
|
|
|
CALL runtime·sighandler(SB)
|
|
MOVL 24(SP), AX
|
|
|
|
// restore g
|
|
get_tls(BX)
|
|
MOVQ 32(SP), R10
|
|
MOVQ R10, g(BX)
|
|
|
|
// call noted(AX)
|
|
MOVQ AX, 0(SP)
|
|
CALL runtime·noted(SB)
|
|
RET
|
|
|
|
TEXT runtime·setfpmasks(SB),NOSPLIT,$8
|
|
STMXCSR 0(SP)
|
|
MOVL 0(SP), AX
|
|
ANDL $~0x3F, AX
|
|
ORL $(0x3F<<7), AX
|
|
MOVL AX, 0(SP)
|
|
LDMXCSR 0(SP)
|
|
RET
|
|
|
|
#define ERRMAX 128 /* from os_plan9.h */
|
|
|
|
// void errstr(int8 *buf, int32 len)
|
|
TEXT errstr<>(SB),NOSPLIT,$0
|
|
MOVQ $41, BP
|
|
SYSCALL
|
|
RET
|
|
|
|
// func errstr() string
|
|
// Only used by package syscall.
|
|
// Grab error string due to a syscall made
|
|
// in entersyscall mode, without going
|
|
// through the allocator (issue 4994).
|
|
// See ../syscall/asm_plan9_amd64.s:/·Syscall/
|
|
TEXT runtime·errstr(SB),NOSPLIT,$16-16
|
|
get_tls(AX)
|
|
MOVQ g(AX), BX
|
|
MOVQ g_m(BX), BX
|
|
MOVQ m_errstr(BX), CX
|
|
MOVQ CX, 0(SP)
|
|
MOVQ $ERRMAX, 8(SP)
|
|
CALL errstr<>(SB)
|
|
CALL runtime·findnull(SB)
|
|
MOVQ 8(SP), AX
|
|
MOVQ AX, ret_len+8(FP)
|
|
MOVQ 0(SP), AX
|
|
MOVQ AX, ret_base+0(FP)
|
|
RET
|