-TEXT linefrompc(SB),7,$0 // Each byte stores its line delta
+TEXT linefrompc(SB),4,$0 // Each byte stores its line delta
BYTE $2;
BYTE $1;
BYTE $1; BYTE $0;
BYTE $2;
BYTE $255;
-TEXT pcfromline(SB),7,$0 // Each record stores its line delta, then n, then n more bytes
+TEXT pcfromline(SB),4,$0 // Each record stores its line delta, then n, then n more bytes
BYTE $32; BYTE $0;
BYTE $1; BYTE $1; BYTE $0;
BYTE $1; BYTE $0;
BYTE $4; BYTE $3; BYTE $0; BYTE $0; BYTE $0;
BYTE $255;
-TEXT main(SB),7,$0
- // Prevent GC of our test symbols
- CALL linefrompc(SB)
- CALL pcfromline(SB)
-
// Keep the linker happy
-TEXT main·main(SB),7,$0
+TEXT main·main(SB),4,$0
RET
-TEXT main·init(SB),7,$0
+TEXT main·init(SB),4,$0
+ // Prevent GC of our test symbols
+ CALL linefrompc(SB)
+ CALL pcfromline(SB)
RET
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
+#include "../../cmd/ld/textflag.h"
+
TO = 8
TOE = 11
N = 12
TMP = 12 /* N and TMP don't overlap */
-TEXT runtime·memclr(SB),7,$0-8
+TEXT runtime·memclr(SB),NOSPLIT,$0-8
MOVW ptr+0(FP), R(TO)
MOVW n+4(FP), R(N)
MOVW $0, R(0)
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
-TEXT runtime·memmove(SB), 7, $0-12
+#include "../../cmd/ld/textflag.h"
+
+TEXT runtime·memmove(SB), NOSPLIT, $0-12
MOVL to+0(FP), DI
MOVL fr+4(FP), SI
MOVL n+8(FP), BX
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
+#include "../../cmd/ld/textflag.h"
+
// void runtime·memmove(void*, void*, uintptr)
-TEXT runtime·memmove(SB), 7, $0-24
+TEXT runtime·memmove(SB), NOSPLIT, $0-24
MOVQ to+0(FP), DI
MOVQ fr+8(FP), SI
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
+#include "../../cmd/ld/textflag.h"
+
// TE or TS are spilled to the stack during bulk register moves.
TS = 0
TE = 8
FW3 = 4
FR3 = 8 /* shared with TE */
-TEXT runtime·memmove(SB), 7, $4-12
+TEXT runtime·memmove(SB), NOSPLIT, $4-12
_memmove:
MOVW to+0(FP), R(TS)
MOVW from+4(FP), R(FROM)
// +build race
+#include "../../cmd/ld/textflag.h"
+
// func runtime·racefuncenter(pc uintptr)
-TEXT runtime·racefuncenter(SB), 7, $16-8
+TEXT runtime·racefuncenter(SB), NOSPLIT, $16-8
MOVQ DX, saved-8(SP) // save function entry context (for closures)
MOVQ pc+0(FP), DX
MOVQ DX, arg-16(SP)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_darwin(SB),7,$8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_darwin(SB),NOSPLIT,$8
MOVL 8(SP), AX
LEAL 12(SP), BX
MOVL AX, 0(SP)
CALL main(SB)
INT $3
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_darwin(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_darwin(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_freebsd(SB),7,$8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_freebsd(SB),NOSPLIT,$8
MOVL 8(SP), AX
LEAL 12(SP), BX
MOVL AX, 0(SP)
CALL main(SB)
INT $3
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_freebsd(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_freebsd(SB),NOSPLIT,$-8
LEAQ 8(DI), SI // argv
MOVQ 0(DI), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+#include "../../cmd/ld/textflag.h"
+
// FreeBSD and Linux use the same linkage to main
-TEXT _rt0_arm_freebsd(SB),7,$-4
+TEXT _rt0_arm_freebsd(SB),NOSPLIT,$-4
B _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_linux(SB),7,$8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_linux(SB),NOSPLIT,$8
MOVL 8(SP), AX
LEAL 12(SP), BX
MOVL AX, 0(SP)
CALL main(SB)
INT $3
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
-TEXT _fallback_vdso(SB),7,$0
+TEXT _fallback_vdso(SB),NOSPLIT,$0
INT $0x80
RET
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_linux(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_arm_linux(SB),7,$-4
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_arm_linux(SB),NOSPLIT,$-4
// We first need to detect the kernel ABI, and warn the user
// if the system only supports OABI
// The strategy here is to call some EABI syscall to see if
ADD $4, R13
B _rt0_go(SB)
-TEXT bad_abi<>(SB),7,$-4
+TEXT bad_abi<>(SB),NOSPLIT,$-4
// give diagnosis and exit
MOVW $2, R0 // stderr
MOVW $bad_abi_msg(SB), R1 // data
DATA bad_abi_msg+0x2c(SB)/1, $0xa
GLOBL bad_abi_msg(SB), $45
-TEXT oabi_syscall<>(SB),7,$-4
+TEXT oabi_syscall<>(SB),NOSPLIT,$-4
ADD $1, PC, R4
WORD $0xe12fff14 //BX (R4) // enter thumb mode
// TODO(minux): only supports little-endian CPUs
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_netbsd(SB),7,$8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_netbsd(SB),NOSPLIT,$8
MOVL 8(SP), AX
LEAL 12(SP), BX
MOVL AX, 0(SP)
CALL main(SB)
INT $3
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_netbsd(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_netbsd(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+#include "../../cmd/ld/textflag.h"
+
// FreeBSD/NetBSD and Linux use the same linkage to main
-TEXT _rt0_arm_netbsd(SB),7,$-4
+TEXT _rt0_arm_netbsd(SB),NOSPLIT,$-4
B _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_openbsd(SB),7,$8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_openbsd(SB),NOSPLIT,$8
MOVL 8(SP), AX
LEAL 12(SP), BX
MOVL AX, 0(SP)
CALL main(SB)
INT $3
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_openbsd(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_openbsd(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_plan9(SB),7, $0
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_plan9(SB),NOSPLIT, $0
MOVL AX, _tos(SB)
// move arguments down to make room for
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_amd64_plan9(SB),7,$-8
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_amd64_plan9(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $_rt0_go(SB), AX
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-TEXT _rt0_386_windows(SB),7,$12
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_386_windows(SB),NOSPLIT,$12
MOVL 12(SP), AX
LEAL 16(SP), BX
MOVL AX, 4(SP)
MOVL $-1, 0(SP) // return PC for main
JMP main(SB)
-TEXT main(SB),7,$0
+TEXT main(SB),NOSPLIT,$0
JMP _rt0_go(SB)
// license that can be found in the LICENSE file.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT _rt0_amd64_windows(SB),7,$-8
+TEXT _rt0_amd64_windows(SB),NOSPLIT,$-8
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
-TEXT main(SB),7,$-8
+TEXT main(SB),NOSPLIT,$-8
MOVQ $_rt0_go(SB), AX
JMP AX
// or /usr/include/sys/syscall.h (on a Mac) for system call numbers.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$0
+TEXT runtime·exit(SB),NOSPLIT,$0
MOVL $1, AX
INT $0x80
MOVL $0xf1, 0xf1 // crash
// Exit this OS thread (like pthread_exit, which eventually
// calls __bsdthread_terminate).
-TEXT runtime·exit1(SB),7,$0
+TEXT runtime·exit1(SB),NOSPLIT,$0
MOVL $361, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVL $5, AX
INT $0x80
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVL $6, AX
INT $0x80
RET
-TEXT runtime·read(SB),7,$0
+TEXT runtime·read(SB),NOSPLIT,$0
MOVL $3, AX
INT $0x80
RET
-TEXT runtime·write(SB),7,$0
+TEXT runtime·write(SB),NOSPLIT,$0
MOVL $4, AX
INT $0x80
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
MOVL $20, AX // getpid
INT $0x80
MOVL AX, 4(SP) // pid
INT $0x80
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVL $197, AX
INT $0x80
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVL $75, AX
INT $0x80
// ignore failure - maybe pages are locked
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVL $73, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·setitimer(SB),7,$0
+TEXT runtime·setitimer(SB),NOSPLIT,$0
MOVL $83, AX
INT $0x80
RET
// 64-bit unix nanoseconds returned in DX:AX.
// I'd much rather write this in C but we need
// assembly for the 96-bit multiply and RDTSC.
-TEXT runtime·now(SB),7,$40
+TEXT runtime·now(SB),NOSPLIT,$40
MOVL $0xffff0000, BP /* comm page base */
// Test for slow CPU. If so, the math is completely
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB),7,$0
+TEXT time·now(SB),NOSPLIT,$0
CALL runtime·now(SB)
MOVL $1000000000, CX
DIVL CX
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB),7,$0
+TEXT runtime·nanotime(SB),NOSPLIT,$0
CALL runtime·now(SB)
MOVL ret+0(FP), DI
MOVL AX, 0(DI)
MOVL DX, 4(DI)
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL $329, AX // pthread_sigmask (on OS X, sigprocmask==entire process)
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigaction(SB),7,$0
+TEXT runtime·sigaction(SB),NOSPLIT,$0
MOVL $46, AX
INT $0x80
JAE 2(PC)
// 12(FP) siginfo style
// 16(FP) siginfo
// 20(FP) context
-TEXT runtime·sigtramp(SB),7,$40
+TEXT runtime·sigtramp(SB),NOSPLIT,$40
get_tls(CX)
// check that m exists
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),NOSPLIT,$0
MOVL $53, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·usleep(SB),7,$32
+TEXT runtime·usleep(SB),NOSPLIT,$32
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
// void bsdthread_create(void *stk, M *mp, G *gp, void (*fn)(void))
// System call args are: func arg stack pthread flags.
-TEXT runtime·bsdthread_create(SB),7,$32
+TEXT runtime·bsdthread_create(SB),NOSPLIT,$32
MOVL $360, AX
// 0(SP) is where the caller PC would be; kernel skips it
MOVL func+12(FP), BX
// DI = stack top
// SI = flags (= 0x1000000)
// SP = stack - C_32_STK_ALIGN
-TEXT runtime·bsdthread_start(SB),7,$0
+TEXT runtime·bsdthread_start(SB),NOSPLIT,$0
// set up ldt 7+id to point at m->tls.
// m->tls is at m+40. newosproc left
// the m->id in tls[0].
// void bsdthread_register(void)
// registers callbacks for threadstart (see bsdthread_create above
// and wqthread and pthsize (not used). returns 0 on success.
-TEXT runtime·bsdthread_register(SB),7,$40
+TEXT runtime·bsdthread_register(SB),NOSPLIT,$40
MOVL $366, AX
// 0(SP) is where kernel expects caller PC; ignored
MOVL $runtime·bsdthread_start(SB), 4(SP) // threadstart
// in the high 16 bits that seems to be the
// argument count in bytes but is not always.
// INT $0x80 works fine for those.
-TEXT runtime·sysenter(SB),7,$0
+TEXT runtime·sysenter(SB),NOSPLIT,$0
POPL DX
MOVL SP, CX
BYTE $0x0F; BYTE $0x34; // SYSENTER
// returns to DX with SP set to CX
-TEXT runtime·mach_msg_trap(SB),7,$0
+TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
MOVL $-31, AX
CALL runtime·sysenter(SB)
RET
-TEXT runtime·mach_reply_port(SB),7,$0
+TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
MOVL $-26, AX
CALL runtime·sysenter(SB)
RET
-TEXT runtime·mach_task_self(SB),7,$0
+TEXT runtime·mach_task_self(SB),NOSPLIT,$0
MOVL $-28, AX
CALL runtime·sysenter(SB)
RET
// instead of requiring the use of RPC.
// uint32 mach_semaphore_wait(uint32)
-TEXT runtime·mach_semaphore_wait(SB),7,$0
+TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
MOVL $-36, AX
CALL runtime·sysenter(SB)
RET
// uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
-TEXT runtime·mach_semaphore_timedwait(SB),7,$0
+TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
MOVL $-38, AX
CALL runtime·sysenter(SB)
RET
// uint32 mach_semaphore_signal(uint32)
-TEXT runtime·mach_semaphore_signal(SB),7,$0
+TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
MOVL $-33, AX
CALL runtime·sysenter(SB)
RET
// uint32 mach_semaphore_signal_all(uint32)
-TEXT runtime·mach_semaphore_signal_all(SB),7,$0
+TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
MOVL $-34, AX
CALL runtime·sysenter(SB)
RET
// setldt(int entry, int address, int limit)
// entry and limit are ignored.
-TEXT runtime·setldt(SB),7,$32
+TEXT runtime·setldt(SB),NOSPLIT,$32
MOVL address+4(FP), BX // aka base
/*
MOVW GS, AX
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVL $202, AX
INT $0x80
JAE 3(PC)
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVL $362, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL $363, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$32
+TEXT runtime·closeonexec(SB),NOSPLIT,$32
MOVL $92, AX // fcntl
// 0(SP) is where the caller PC would be; kernel skips it
MOVL fd+0(FP), BX
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$0
+TEXT runtime·exit(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 exit status
MOVL $(0x2000000+1), AX // syscall entry
SYSCALL
// Exit this OS thread (like pthread_exit, which eventually
// calls __bsdthread_terminate).
-TEXT runtime·exit1(SB),7,$0
+TEXT runtime·exit1(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 exit status
MOVL $(0x2000000+361), AX // syscall entry
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 pathname
MOVL 16(SP), SI // arg 2 flags
MOVL 20(SP), DX // arg 3 mode
SYSCALL
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 fd
MOVL $(0x2000000+6), AX // syscall entry
SYSCALL
RET
-TEXT runtime·read(SB),7,$0
+TEXT runtime·read(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·write(SB),7,$0
+TEXT runtime·write(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·raise(SB),7,$24
+TEXT runtime·raise(SB),NOSPLIT,$24
MOVL $(0x2000000+20), AX // getpid
SYSCALL
MOVQ AX, DI // arg 1 - pid
SYSCALL
RET
-TEXT runtime·setitimer(SB), 7, $0
+TEXT runtime·setitimer(SB), NOSPLIT, $0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
SYSCALL
RET
-TEXT runtime·madvise(SB), 7, $0
+TEXT runtime·madvise(SB), NOSPLIT, $0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL 24(SP), DX // arg 3 advice
#define gtod_sec_base 0x78
// int64 nanotime(void)
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVQ $0x7fffffe00000, BP /* comm page base */
// Loop trying to take a consistent snapshot
// of the time parameters.
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB),7,$0
+TEXT time·now(SB),NOSPLIT,$0
CALL runtime·nanotime(SB)
// generated code for
MOVL CX, nsec+8(FP)
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigaction(SB),7,$0
+TEXT runtime·sigaction(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 sig
MOVQ 16(SP), SI // arg 2 act
MOVQ 24(SP), DX // arg 3 oact
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
get_tls(BX)
MOVQ R8, 32(SP) // save ucontext
SYSCALL
INT $3 // not reached
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL 24(SP), DX // arg 3 prot
SYSCALL
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL $(0x2000000+73), AX // syscall entry
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),NOSPLIT,$0
MOVQ new+8(SP), DI
MOVQ old+16(SP), SI
MOVQ $(0x2000000+53), AX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
RET
// void bsdthread_create(void *stk, M *mp, G *gp, void (*fn)(void))
-TEXT runtime·bsdthread_create(SB),7,$0
+TEXT runtime·bsdthread_create(SB),NOSPLIT,$0
// Set up arguments to bsdthread_create system call.
// The ones in quotes pass through to the thread callback
// uninterpreted, so we can put whatever we want there.
// R8 = stack
// R9 = flags (= 0)
// SP = stack - C_64_REDZONE_LEN (= stack - 128)
-TEXT runtime·bsdthread_start(SB),7,$0
+TEXT runtime·bsdthread_start(SB),NOSPLIT,$0
MOVQ R8, SP // empirically, SP is very wrong but R8 is right
PUSHQ DX
// void bsdthread_register(void)
// registers callbacks for threadstart (see bsdthread_create above
// and wqthread and pthsize (not used). returns 0 on success.
-TEXT runtime·bsdthread_register(SB),7,$0
+TEXT runtime·bsdthread_register(SB),NOSPLIT,$0
MOVQ $runtime·bsdthread_start(SB), DI // threadstart
MOVQ $0, SI // wqthread, not used by us
MOVQ $0, DX // pthsize, not used by us
// Mach system calls use 0x1000000 instead of the BSD's 0x2000000.
// uint32 mach_msg_trap(void*, uint32, uint32, uint32, uint32, uint32, uint32)
-TEXT runtime·mach_msg_trap(SB),7,$0
+TEXT runtime·mach_msg_trap(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), DX
POPQ R11
RET
-TEXT runtime·mach_task_self(SB),7,$0
+TEXT runtime·mach_task_self(SB),NOSPLIT,$0
MOVL $(0x1000000+28), AX // task_self_trap
SYSCALL
RET
-TEXT runtime·mach_thread_self(SB),7,$0
+TEXT runtime·mach_thread_self(SB),NOSPLIT,$0
MOVL $(0x1000000+27), AX // thread_self_trap
SYSCALL
RET
-TEXT runtime·mach_reply_port(SB),7,$0
+TEXT runtime·mach_reply_port(SB),NOSPLIT,$0
MOVL $(0x1000000+26), AX // mach_reply_port
SYSCALL
RET
// instead of requiring the use of RPC.
// uint32 mach_semaphore_wait(uint32)
-TEXT runtime·mach_semaphore_wait(SB),7,$0
+TEXT runtime·mach_semaphore_wait(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL $(0x1000000+36), AX // semaphore_wait_trap
SYSCALL
RET
// uint32 mach_semaphore_timedwait(uint32, uint32, uint32)
-TEXT runtime·mach_semaphore_timedwait(SB),7,$0
+TEXT runtime·mach_semaphore_timedwait(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL 12(SP), SI
MOVL 16(SP), DX
RET
// uint32 mach_semaphore_signal(uint32)
-TEXT runtime·mach_semaphore_signal(SB),7,$0
+TEXT runtime·mach_semaphore_signal(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL $(0x1000000+33), AX // semaphore_signal_trap
SYSCALL
RET
// uint32 mach_semaphore_signal_all(uint32)
-TEXT runtime·mach_semaphore_signal_all(SB),7,$0
+TEXT runtime·mach_semaphore_signal_all(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL $(0x1000000+34), AX // semaphore_signal_all_trap
SYSCALL
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$32
+TEXT runtime·settls(SB),NOSPLIT,$32
/*
* Same as in sys_darwin_386.s:/ugliness, different constant.
* See cgo/gcc_darwin_amd64.c for the derivation
SYSCALL
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVQ 24(SP), DX
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVQ $0, DI
MOVQ $0, SI
MOVQ $0, DX
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
RET
// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVL 8(SP), DI // fd
MOVQ $2, SI // F_SETFD
MOVQ $1, DX // FD_CLOEXEC
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT runtime·sys_umtx_op(SB),7,$-4
+TEXT runtime·sys_umtx_op(SB),NOSPLIT,$-4
MOVL $454, AX
INT $0x80
RET
-TEXT runtime·thr_new(SB),7,$-4
+TEXT runtime·thr_new(SB),NOSPLIT,$-4
MOVL $455, AX
INT $0x80
RET
-TEXT runtime·thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),NOSPLIT,$0
MOVL mm+0(FP), AX
MOVL m_g0(AX), BX
LEAL m_tls(AX), BP
MOVL 0, AX // crash (not reached)
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-4
+TEXT runtime·exit(SB),NOSPLIT,$-4
MOVL $1, AX
INT $0x80
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$-4
+TEXT runtime·exit1(SB),NOSPLIT,$-4
MOVL $431, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-4
+TEXT runtime·open(SB),NOSPLIT,$-4
MOVL $5, AX
INT $0x80
RET
-TEXT runtime·close(SB),7,$-4
+TEXT runtime·close(SB),NOSPLIT,$-4
MOVL $6, AX
INT $0x80
RET
-TEXT runtime·read(SB),7,$-4
+TEXT runtime·read(SB),NOSPLIT,$-4
MOVL $3, AX
INT $0x80
RET
-TEXT runtime·write(SB),7,$-4
+TEXT runtime·write(SB),NOSPLIT,$-4
MOVL $4, AX
INT $0x80
RET
-TEXT runtime·getrlimit(SB),7,$-4
+TEXT runtime·getrlimit(SB),NOSPLIT,$-4
MOVL $194, AX
INT $0x80
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
// thr_self(&8(SP))
LEAL 8(SP), AX
MOVL AX, 4(SP)
INT $0x80
RET
-TEXT runtime·mmap(SB),7,$32
+TEXT runtime·mmap(SB),NOSPLIT,$32
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
INT $0x80
RET
-TEXT runtime·munmap(SB),7,$-4
+TEXT runtime·munmap(SB),NOSPLIT,$-4
MOVL $73, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$-4
+TEXT runtime·madvise(SB),NOSPLIT,$-4
MOVL $75, AX // madvise
INT $0x80
// ignore failure - maybe pages are locked
RET
-TEXT runtime·setitimer(SB), 7, $-4
+TEXT runtime·setitimer(SB), NOSPLIT, $-4
MOVL $83, AX
INT $0x80
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVL $232, AX
LEAL 12(SP), BX
MOVL $0, 4(SP)
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVL $232, AX
LEAL 12(SP), BX
MOVL $0, 4(SP)
RET
-TEXT runtime·sigaction(SB),7,$-4
+TEXT runtime·sigaction(SB),NOSPLIT,$-4
MOVL $416, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigtramp(SB),7,$44
+TEXT runtime·sigtramp(SB),NOSPLIT,$44
get_tls(CX)
// check that m exists
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),NOSPLIT,$0
MOVL $53, AX
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·usleep(SB),7,$20
+TEXT runtime·usleep(SB),NOSPLIT,$20
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
*/
// setldt(int entry, int address, int limit)
-TEXT runtime·setldt(SB),7,$32
+TEXT runtime·setldt(SB),NOSPLIT,$32
MOVL address+4(FP), BX // aka base
// see comment in sys_linux_386.s; freebsd is similar
ADDL $0x8, BX
MOVW AX, GS
RET
-TEXT runtime·i386_set_ldt(SB),7,$16
+TEXT runtime·i386_set_ldt(SB),NOSPLIT,$16
LEAL args+0(FP), AX // 0(FP) == 4(SP) before SP got moved
MOVL $0, 0(SP) // syscall gap
MOVL $1, 4(SP)
INT $3
RET
-TEXT runtime·sysctl(SB),7,$28
+TEXT runtime·sysctl(SB),NOSPLIT,$28
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
MOVL $0, AX
RET
-TEXT runtime·osyield(SB),7,$-4
+TEXT runtime·osyield(SB),NOSPLIT,$-4
MOVL $331, AX // sys_sched_yield
INT $0x80
RET
-TEXT runtime·sigprocmask(SB),7,$16
+TEXT runtime·sigprocmask(SB),NOSPLIT,$16
MOVL $0, 0(SP) // syscall gap
MOVL $3, 4(SP) // arg 1 - how (SIG_SETMASK)
MOVL args+0(FP), AX
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVL $269, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL $270, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$32
+TEXT runtime·closeonexec(SB),NOSPLIT,$32
MOVL $92, AX // fcntl
// 0(SP) is where the caller PC would be; kernel skips it
MOVL fd+0(FP), BX
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT runtime·sys_umtx_op(SB),7,$0
+TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), DX
SYSCALL
RET
-TEXT runtime·thr_new(SB),7,$0
+TEXT runtime·thr_new(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVL $455, AX
SYSCALL
RET
-TEXT runtime·thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),NOSPLIT,$0
MOVQ DI, R13 // m
// set up FS to point at m->tls
MOVQ 0, AX // crash (not reached)
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-8
+TEXT runtime·exit(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 exit status
MOVL $1, AX
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$-8
+TEXT runtime·exit1(SB),NOSPLIT,$-8
MOVQ 8(SP), DI // arg 1 exit status
MOVL $431, AX
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-8
+TEXT runtime·open(SB),NOSPLIT,$-8
MOVQ 8(SP), DI // arg 1 pathname
MOVL 16(SP), SI // arg 2 flags
MOVL 20(SP), DX // arg 3 mode
SYSCALL
RET
-TEXT runtime·close(SB),7,$-8
+TEXT runtime·close(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVL $6, AX
SYSCALL
RET
-TEXT runtime·read(SB),7,$-8
+TEXT runtime·read(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·write(SB),7,$-8
+TEXT runtime·write(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·getrlimit(SB),7,$-8
+TEXT runtime·getrlimit(SB),NOSPLIT,$-8
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL $194, AX
SYSCALL
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
// thr_self(&8(SP))
LEAQ 8(SP), DI // arg 1 &8(SP)
MOVL $432, AX
SYSCALL
RET
-TEXT runtime·setitimer(SB), 7, $-8
+TEXT runtime·setitimer(SB), NOSPLIT, $-8
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVL $232, AX
MOVQ $0, DI
LEAQ 8(SP), SI
MOVL DX, nsec+8(FP)
RET
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVL $232, AX
MOVQ $0, DI
LEAQ 8(SP), SI
ADDQ DX, AX
RET
-TEXT runtime·sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 sig
MOVQ 16(SP), SI // arg 2 act
MOVQ 24(SP), DX // arg 3 oact
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
get_tls(BX)
// check that m exists
MOVQ R10, g(BX)
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL 24(SP), DX // arg 3 prot
SYSCALL
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 addr
MOVQ 16(SP), SI // arg 2 len
MOVL $73, AX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
// ignore failure - maybe pages are locked
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVQ new+8(SP), DI
MOVQ old+16(SP), SI
MOVQ $53, AX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$8
+TEXT runtime·settls(SB),NOSPLIT,$8
ADDQ $16, DI // adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
MOVQ DI, 0(SP)
MOVQ SP, SI
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - name
MOVL 16(SP), SI // arg 2 - namelen
MOVQ 24(SP), DX // arg 3 - oldp
MOVL $0, AX
RET
-TEXT runtime·osyield(SB),7,$-4
+TEXT runtime·osyield(SB),NOSPLIT,$-4
MOVL $331, AX // sys_sched_yield
SYSCALL
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL $3, DI // arg 1 - how (SIG_SETMASK)
MOVQ 8(SP), SI // arg 2 - set
MOVQ 16(SP), DX // arg 3 - oset
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVQ $0, DI
MOVQ $0, SI
MOVQ $0, DX
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
RET
// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVL 8(SP), DI // fd
MOVQ $2, SI // F_SETFD
MOVQ $1, DX // FD_CLOEXEC
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT runtime·sys_umtx_op(SB),7,$0
+TEXT runtime·sys_umtx_op(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
// BCS error
RET
-TEXT runtime·thr_new(SB),7,$0
+TEXT runtime·thr_new(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
SWI $455
RET
-TEXT runtime·thr_start(SB),7,$0
+TEXT runtime·thr_start(SB),NOSPLIT,$0
MOVW R0, m
// set up g
RET
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-8
+TEXT runtime·exit(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 exit status
SWI $1
MOVW.CS $0, R8 // crash on syscall failure
MOVW.CS R8, (R8)
RET
-TEXT runtime·exit1(SB),7,$-8
+TEXT runtime·exit1(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 exit status
SWI $431
MOVW.CS $0, R8 // crash on syscall failure
MOVW.CS R8, (R8)
RET
-TEXT runtime·open(SB),7,$-8
+TEXT runtime·open(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 name
MOVW 4(FP), R1 // arg 2 mode
MOVW 8(FP), R2 // arg 3 perm
SWI $5
RET
-TEXT runtime·read(SB),7,$-8
+TEXT runtime·read(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 fd
MOVW 4(FP), R1 // arg 2 buf
MOVW 8(FP), R2 // arg 3 count
SWI $3
RET
-TEXT runtime·write(SB),7,$-8
+TEXT runtime·write(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 fd
MOVW 4(FP), R1 // arg 2 buf
MOVW 8(FP), R2 // arg 3 count
SWI $4
RET
-TEXT runtime·close(SB),7,$-8
+TEXT runtime·close(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 fd
SWI $6
RET
-TEXT runtime·getrlimit(SB),7,$-8
+TEXT runtime·getrlimit(SB),NOSPLIT,$-8
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $194
RET
-TEXT runtime·raise(SB),7,$8
+TEXT runtime·raise(SB),NOSPLIT,$8
// thr_self(&4(R13))
MOVW $4(R13), R0 // arg 1 &4(R13)
SWI $432
SWI $433
RET
-TEXT runtime·setitimer(SB), 7, $-8
+TEXT runtime·setitimer(SB), NOSPLIT, $-8
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1
SWI $232 // clock_gettime
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1
SWI $232 // clock_gettime
MOVW R1, 4(R3)
RET
-TEXT runtime·sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),NOSPLIT,$-8
MOVW 0(FP), R0 // arg 1 sig
MOVW 4(FP), R1 // arg 2 act
MOVW 8(FP), R2 // arg 3 oact
MOVW.CS R8, (R8)
RET
-TEXT runtime·sigtramp(SB),7,$24
+TEXT runtime·sigtramp(SB),NOSPLIT,$24
// this might be called in external code context,
// where g and m are not set.
// first save R0, because _cgo_load_gm will clobber it
MOVW 20(R13), g
RET
-TEXT runtime·mmap(SB),7,$12
+TEXT runtime·mmap(SB),NOSPLIT,$12
MOVW 0(FP), R0 // arg 1 addr
MOVW 4(FP), R1 // arg 2 len
MOVW 8(FP), R2 // arg 3 prot
SUB $4, R13
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 addr
MOVW 4(FP), R1 // arg 2 len
SWI $73
MOVW.CS R8, (R8)
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 addr
MOVW 4(FP), R1 // arg 2 len
MOVW 8(FP), R2 // arg 3 flags
// ignore failure - maybe pages are locked
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVW new+0(FP), R0
MOVW old+4(FP), R1
SWI $53
MOVW.CS R8, (R8)
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVW usec+0(FP), R0
MOVW R0, R2
MOVW $1000000, R1
SWI $240 // sys_nanosleep
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - name
MOVW 4(FP), R1 // arg 2 - namelen
MOVW 8(FP), R2 // arg 3 - oldp
SUB $20, R13
RET
-TEXT runtime·osyield(SB),7,$-4
+TEXT runtime·osyield(SB),NOSPLIT,$-4
SWI $331 // sys_sched_yield
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVW $3, R0 // arg 1 - how (SIG_SETMASK)
MOVW 0(FP), R1 // arg 2 - set
MOVW 4(FP), R2 // arg 3 - oset
MOVW.CS R8, (R8)
RET
-TEXT runtime·casp(SB),7,$0
+TEXT runtime·casp(SB),NOSPLIT,$0
B runtime·cas(SB)
// TODO(minux): this is only valid for ARMv6+
// return 1;
// }else
// return 0;
-TEXT runtime·cas(SB),7,$0
+TEXT runtime·cas(SB),NOSPLIT,$0
B runtime·armcas(SB)
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT runtime·exit(SB),7,$0
+TEXT runtime·exit(SB),NOSPLIT,$0
MOVL $252, AX // syscall number
MOVL 4(SP), BX
CALL *runtime·_vdso(SB)
INT $3 // not reached
RET
-TEXT runtime·exit1(SB),7,$0
+TEXT runtime·exit1(SB),NOSPLIT,$0
MOVL $1, AX // exit - exit the current os thread
MOVL 4(SP), BX
CALL *runtime·_vdso(SB)
INT $3 // not reached
RET
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVL $5, AX // syscall - open
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVL $6, AX // syscall - close
MOVL 4(SP), BX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·write(SB),7,$0
+TEXT runtime·write(SB),NOSPLIT,$0
MOVL $4, AX // syscall - write
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·read(SB),7,$0
+TEXT runtime·read(SB),NOSPLIT,$0
MOVL $3, AX // syscall - read
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·getrlimit(SB),7,$0
+TEXT runtime·getrlimit(SB),NOSPLIT,$0
MOVL $191, AX // syscall - ugetrlimit
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·usleep(SB),7,$8
+TEXT runtime·usleep(SB),NOSPLIT,$8
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·raise(SB),7,$12
+TEXT runtime·raise(SB),NOSPLIT,$12
MOVL $224, AX // syscall - gettid
CALL *runtime·_vdso(SB)
MOVL AX, BX // arg 1 tid
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·setitimer(SB),7,$0-24
+TEXT runtime·setitimer(SB),NOSPLIT,$0-24
MOVL $104, AX // syscall - setitimer
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·mincore(SB),7,$0-24
+TEXT runtime·mincore(SB),NOSPLIT,$0-24
MOVL $218, AX // syscall - mincore
MOVL 4(SP), BX
MOVL 8(SP), CX
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVL $265, AX // syscall - clock_gettime
MOVL $0, BX
LEAL 8(SP), CX
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVL $265, AX // syscall - clock_gettime
MOVL $0, BX
LEAL 8(SP), CX
MOVL DX, 4(DI)
RET
-TEXT runtime·rtsigprocmask(SB),7,$0
+TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
MOVL $175, AX // syscall entry
MOVL 4(SP), BX
MOVL 8(SP), CX
INT $3
RET
-TEXT runtime·rt_sigaction(SB),7,$0
+TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
MOVL $174, AX // syscall - rt_sigaction
MOVL 4(SP), BX
MOVL 8(SP), CX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·sigtramp(SB),7,$44
+TEXT runtime·sigtramp(SB),NOSPLIT,$44
get_tls(CX)
// check that m exists
RET
-TEXT runtime·sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),NOSPLIT,$0
MOVL $173, AX // rt_sigreturn
// Sigreturn expects same SP as signal handler,
// so cannot CALL *runtime._vsdo(SB) here.
INT $3 // not reached
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVL $192, AX // mmap2
MOVL 4(SP), BX
MOVL 8(SP), CX
INCL AX
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVL $91, AX // munmap
MOVL 4(SP), BX
MOVL 8(SP), CX
INT $3
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVL $219, AX // madvise
MOVL 4(SP), BX
MOVL 8(SP), CX
// int32 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT runtime·futex(SB),7,$0
+TEXT runtime·futex(SB),NOSPLIT,$0
MOVL $240, AX // futex
MOVL 4(SP), BX
MOVL 8(SP), CX
RET
// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·clone(SB),7,$0
+TEXT runtime·clone(SB),NOSPLIT,$0
MOVL $120, AX // clone
MOVL flags+4(SP), BX
MOVL stack+8(SP), CX
MOVL $0x1234, 0x1005
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVL $186, AX // sigaltstack
MOVL new+4(SP), BX
MOVL old+8(SP), CX
#define USEABLE 0x40
// setldt(int entry, int address, int limit)
-TEXT runtime·setldt(SB),7,$32
+TEXT runtime·setldt(SB),NOSPLIT,$32
MOVL entry+0(FP), BX // entry
MOVL address+4(FP), CX // base address
RET
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
MOVL $158, AX
CALL *runtime·_vdso(SB)
RET
-TEXT runtime·sched_getaffinity(SB),7,$0
+TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
MOVL $242, AX // syscall - sched_getaffinity
MOVL 4(SP), BX
MOVL 8(SP), CX
RET
// int32 runtime·epollcreate(int32 size);
-TEXT runtime·epollcreate(SB),7,$0
+TEXT runtime·epollcreate(SB),NOSPLIT,$0
MOVL $254, AX
MOVL 4(SP), BX
CALL *runtime·_vdso(SB)
RET
// int32 runtime·epollcreate1(int32 flags);
-TEXT runtime·epollcreate1(SB),7,$0
+TEXT runtime·epollcreate1(SB),NOSPLIT,$0
MOVL $329, AX
MOVL 4(SP), BX
CALL *runtime·_vdso(SB)
RET
// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
-TEXT runtime·epollctl(SB),7,$0
+TEXT runtime·epollctl(SB),NOSPLIT,$0
MOVL $255, AX
MOVL 4(SP), BX
MOVL 8(SP), CX
RET
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
-TEXT runtime·epollwait(SB),7,$0
+TEXT runtime·epollwait(SB),NOSPLIT,$0
MOVL $256, AX
MOVL 4(SP), BX
MOVL 8(SP), CX
RET
// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVL $55, AX // fcntl
MOVL 4(SP), BX // fd
MOVL $2, CX // F_SETFD
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
-TEXT runtime·exit(SB),7,$0-8
+TEXT runtime·exit(SB),NOSPLIT,$0-8
MOVL 8(SP), DI
MOVL $231, AX // exitgroup - force all os threads to exit
SYSCALL
RET
-TEXT runtime·exit1(SB),7,$0-8
+TEXT runtime·exit1(SB),NOSPLIT,$0-8
MOVL 8(SP), DI
MOVL $60, AX // exit - exit the current os thread
SYSCALL
RET
-TEXT runtime·open(SB),7,$0-16
+TEXT runtime·open(SB),NOSPLIT,$0-16
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), DX
SYSCALL
RET
-TEXT runtime·close(SB),7,$0-16
+TEXT runtime·close(SB),NOSPLIT,$0-16
MOVL 8(SP), DI
MOVL $3, AX // syscall entry
SYSCALL
RET
-TEXT runtime·write(SB),7,$0-24
+TEXT runtime·write(SB),NOSPLIT,$0-24
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
SYSCALL
RET
-TEXT runtime·read(SB),7,$0-24
+TEXT runtime·read(SB),NOSPLIT,$0-24
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
SYSCALL
RET
-TEXT runtime·getrlimit(SB),7,$0-24
+TEXT runtime·getrlimit(SB),NOSPLIT,$0-24
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL $97, AX // syscall entry
SYSCALL
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
SYSCALL
RET
-TEXT runtime·raise(SB),7,$12
+TEXT runtime·raise(SB),NOSPLIT,$12
MOVL $186, AX // syscall - gettid
SYSCALL
MOVL AX, DI // arg 1 tid
SYSCALL
RET
-TEXT runtime·setitimer(SB),7,$0-24
+TEXT runtime·setitimer(SB),NOSPLIT,$0-24
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
SYSCALL
RET
-TEXT runtime·mincore(SB),7,$0-24
+TEXT runtime·mincore(SB),NOSPLIT,$0-24
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB),7,$16
+TEXT time·now(SB),NOSPLIT,$16
// Be careful. We're calling a function with gcc calling convention here.
// We're guaranteed 128 bytes on entry, and we've taken 16, and the
// call uses another 8.
MOVL DX, nsec+8(FP)
RET
-TEXT runtime·nanotime(SB),7,$16
+TEXT runtime·nanotime(SB),NOSPLIT,$16
// Duplicate time.now here to avoid using up precious stack space.
// See comment above in time.now.
MOVQ runtime·__vdso_clock_gettime_sym(SB), AX
ADDQ DX, AX
RET
-TEXT runtime·rtsigprocmask(SB),7,$0-32
+TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0-32
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·rt_sigaction(SB),7,$0-32
+TEXT runtime·rt_sigaction(SB),NOSPLIT,$0-32
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
SYSCALL
RET
-TEXT runtime·sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
get_tls(BX)
// check that m exists
MOVQ R10, g(BX)
RET
-TEXT runtime·sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),NOSPLIT,$0
MOVL $15, AX // rt_sigreturn
SYSCALL
INT $3 // not reached
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVQ $0, SI
MOVQ 16(SP), SI
INCQ AX
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVQ $11, AX // munmap
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVQ 16(SP), SI
MOVQ 24(SP), DX
// int64 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT runtime·futex(SB),7,$0
+TEXT runtime·futex(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVL 20(SP), DX
RET
// int64 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·clone(SB),7,$0
+TEXT runtime·clone(SB),NOSPLIT,$0
MOVL flags+8(SP), DI
MOVQ stack+16(SP), SI
SYSCALL
JMP -3(PC) // keep exiting
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVQ new+8(SP), DI
MOVQ old+16(SP), SI
MOVQ $131, AX
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$32
+TEXT runtime·settls(SB),NOSPLIT,$32
ADDQ $16, DI // ELF wants to use -16(FS), -8(FS)
MOVQ DI, SI
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
MOVL $24, AX
SYSCALL
RET
-TEXT runtime·sched_getaffinity(SB),7,$0
+TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
MOVQ 8(SP), DI
MOVL 16(SP), SI
MOVQ 24(SP), DX
RET
// int32 runtime·epollcreate(int32 size);
-TEXT runtime·epollcreate(SB),7,$0
+TEXT runtime·epollcreate(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL $213, AX // syscall entry
SYSCALL
RET
// int32 runtime·epollcreate1(int32 flags);
-TEXT runtime·epollcreate1(SB),7,$0
+TEXT runtime·epollcreate1(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL $291, AX // syscall entry
SYSCALL
RET
// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev);
-TEXT runtime·epollctl(SB),7,$0
+TEXT runtime·epollctl(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVL 12(SP), SI
MOVL 16(SP), DX
RET
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
-TEXT runtime·epollwait(SB),7,$0
+TEXT runtime·epollwait(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
RET
// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVL 8(SP), DI // fd
MOVQ $2, SI // F_SETFD
MOVQ $1, DX // FD_CLOEXEC
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// for EABI, as we don't support OABI
#define SYS_BASE 0x0
#define ARM_BASE (SYS_BASE + 0x0f0000)
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW $SYS_close, R7
SWI $0
RET
-TEXT runtime·write(SB),7,$0
+TEXT runtime·write(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·read(SB),7,$0
+TEXT runtime·read(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·getrlimit(SB),7,$0
+TEXT runtime·getrlimit(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW $SYS_ugetrlimit, R7
SWI $0
RET
-TEXT runtime·exit(SB),7,$-4
+TEXT runtime·exit(SB),NOSPLIT,$-4
MOVW 0(FP), R0
MOVW $SYS_exit_group, R7
SWI $0
MOVW $1002, R1
MOVW R0, (R1) // fail hard
-TEXT runtime·exit1(SB),7,$-4
+TEXT runtime·exit1(SB),NOSPLIT,$-4
MOVW 0(FP), R0
MOVW $SYS_exit, R7
SWI $0
MOVW $1003, R1
MOVW R0, (R1) // fail hard
-TEXT runtime·raise(SB),7,$-4
+TEXT runtime·raise(SB),NOSPLIT,$-4
MOVW $SYS_gettid, R7
SWI $0
// arg 1 tid already in R0 from gettid
SWI $0
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
RSB.HI $0, R0
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW $SYS_munmap, R7
MOVW.HI R8, (R8)
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
// ignore failure - maybe pages are locked
RET
-TEXT runtime·setitimer(SB),7,$0
+TEXT runtime·setitimer(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·mincore(SB),7,$0
+TEXT runtime·mincore(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1 // timespec
MOVW $SYS_clock_gettime, R7
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB),7,$32
+TEXT runtime·nanotime(SB),NOSPLIT,$32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1 // timespec
MOVW $SYS_clock_gettime, R7
// int32 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2);
-TEXT runtime·futex(SB),7,$0
+TEXT runtime·futex(SB),NOSPLIT,$0
MOVW 4(SP), R0
MOVW 8(SP), R1
MOVW 12(SP), R2
// int32 clone(int32 flags, void *stack, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·clone(SB),7,$0
+TEXT runtime·clone(SB),NOSPLIT,$0
MOVW flags+0(FP), R0
MOVW stack+4(FP), R1
MOVW $0, R2 // parent tid ptr
MOVW $1005, R1
MOVW R0, (R1)
-TEXT runtime·sigaltstack(SB),7,$0
+TEXT runtime·sigaltstack(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW $SYS_sigaltstack, R7
MOVW.HI R8, (R8)
RET
-TEXT runtime·sigtramp(SB),7,$24
+TEXT runtime·sigtramp(SB),NOSPLIT,$24
// this might be called in external code context,
// where g and m are not set.
// first save R0, because _cgo_load_gm will clobber it
RET
-TEXT runtime·rtsigprocmask(SB),7,$0
+TEXT runtime·rtsigprocmask(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·rt_sigaction(SB),7,$0
+TEXT runtime·rt_sigaction(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0
RET
-TEXT runtime·sigreturn(SB),7,$0
+TEXT runtime·sigreturn(SB),NOSPLIT,$0
MOVW $SYS_rt_sigreturn, R7
SWI $0
RET
-TEXT runtime·usleep(SB),7,$12
+TEXT runtime·usleep(SB),NOSPLIT,$12
MOVW usec+0(FP), R0
MOVW R0, R1
MOVW $1000000, R2
// Use kernel version instead of native armcas in asm_arm.s.
// See ../sync/atomic/asm_linux_arm.s for details.
-TEXT cas<>(SB),7,$0
+TEXT cas<>(SB),NOSPLIT,$0
MOVW $0xffff0fc0, PC
-TEXT runtime·cas(SB),7,$0
+TEXT runtime·cas(SB),NOSPLIT,$0
MOVW valptr+0(FP), R2
MOVW old+4(FP), R0
casagain:
MOVW $0, R0
RET
-TEXT runtime·casp(SB),7,$0
+TEXT runtime·casp(SB),NOSPLIT,$0
B runtime·cas(SB)
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
MOVW $SYS_sched_yield, R7
SWI $0
RET
-TEXT runtime·sched_getaffinity(SB),7,$0
+TEXT runtime·sched_getaffinity(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
RET
// int32 runtime·epollcreate(int32 size)
-TEXT runtime·epollcreate(SB),7,$0
+TEXT runtime·epollcreate(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW $SYS_epoll_create, R7
SWI $0
RET
// int32 runtime·epollcreate1(int32 flags)
-TEXT runtime·epollcreate1(SB),7,$0
+TEXT runtime·epollcreate1(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW $SYS_epoll_create1, R7
SWI $0
RET
// int32 runtime·epollctl(int32 epfd, int32 op, int32 fd, EpollEvent *ev)
-TEXT runtime·epollctl(SB),7,$0
+TEXT runtime·epollctl(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
RET
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout)
-TEXT runtime·epollwait(SB),7,$0
+TEXT runtime·epollwait(SB),NOSPLIT,$0
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
RET
// void runtime·closeonexec(int32 fd)
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVW 0(FP), R0 // fd
MOVW $2, R1 // F_SETFD
MOVW $1, R2 // FD_CLOEXEC
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-4
+TEXT runtime·exit(SB),NOSPLIT,$-4
MOVL $1, AX
INT $0x80
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$-4
+TEXT runtime·exit1(SB),NOSPLIT,$-4
MOVL $310, AX // sys__lwp_exit
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-4
+TEXT runtime·open(SB),NOSPLIT,$-4
MOVL $5, AX
INT $0x80
RET
-TEXT runtime·close(SB),7,$-4
+TEXT runtime·close(SB),NOSPLIT,$-4
MOVL $6, AX
INT $0x80
RET
-TEXT runtime·read(SB),7,$-4
+TEXT runtime·read(SB),NOSPLIT,$-4
MOVL $3, AX
INT $0x80
RET
-TEXT runtime·write(SB),7,$-4
+TEXT runtime·write(SB),NOSPLIT,$-4
MOVL $4, AX // sys_write
INT $0x80
RET
-TEXT runtime·usleep(SB),7,$24
+TEXT runtime·usleep(SB),NOSPLIT,$24
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
INT $0x80
RET
-TEXT runtime·raise(SB),7,$12
+TEXT runtime·raise(SB),NOSPLIT,$12
MOVL $311, AX // sys__lwp_self
INT $0x80
MOVL $0, 0(SP)
INT $0x80
RET
-TEXT runtime·mmap(SB),7,$36
+TEXT runtime·mmap(SB),NOSPLIT,$36
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
INT $0x80
RET
-TEXT runtime·munmap(SB),7,$-4
+TEXT runtime·munmap(SB),NOSPLIT,$-4
MOVL $73, AX // sys_munmap
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$-4
+TEXT runtime·madvise(SB),NOSPLIT,$-4
MOVL $75, AX // sys_madvise
INT $0x80
// ignore failure - maybe pages are locked
RET
-TEXT runtime·setitimer(SB),7,$-4
+TEXT runtime·setitimer(SB),NOSPLIT,$-4
MOVL $425, AX // sys_setitimer
INT $0x80
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
LEAL 12(SP), BX
MOVL $0, 4(SP) // arg 1 - clock_id
MOVL BX, 8(SP) // arg 2 - tp
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB),7,$32
+TEXT runtime·nanotime(SB),NOSPLIT,$32
LEAL 12(SP), BX
MOVL $0, 4(SP) // arg 1 - clock_id
MOVL BX, 8(SP) // arg 2 - tp
MOVL DX, 4(DI)
RET
-TEXT runtime·getcontext(SB),7,$-4
+TEXT runtime·getcontext(SB),NOSPLIT,$-4
MOVL $307, AX // sys_getcontext
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigprocmask(SB),7,$-4
+TEXT runtime·sigprocmask(SB),NOSPLIT,$-4
MOVL $293, AX // sys_sigprocmask
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigreturn_tramp(SB),7,$0
+TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$0
LEAL 140(SP), AX // Load address of ucontext
MOVL AX, 4(SP)
MOVL $308, AX // sys_setcontext
MOVL $1, AX // sys_exit
INT $0x80
-TEXT runtime·sigaction(SB),7,$24
+TEXT runtime·sigaction(SB),NOSPLIT,$24
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigtramp(SB),7,$44
+TEXT runtime·sigtramp(SB),NOSPLIT,$44
get_tls(CX)
// check that m exists
RET
// int32 lwp_create(void *context, uintptr flags, void *lwpid);
-TEXT runtime·lwp_create(SB),7,$16
+TEXT runtime·lwp_create(SB),NOSPLIT,$16
MOVL $0, 0(SP)
MOVL context+0(FP), AX
MOVL AX, 4(SP) // arg 1 - context
NEGL AX
RET
-TEXT runtime·lwp_tramp(SB),7,$0
+TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
// Set FS to point at m->tls
LEAL m_tls(BX), BP
MOVL $0x1234, 0x1005
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVL $281, AX // sys___sigaltstack14
MOVL new+4(SP), BX
MOVL old+8(SP), CX
INT $3
RET
-TEXT runtime·setldt(SB),7,$8
+TEXT runtime·setldt(SB),NOSPLIT,$8
// Under NetBSD we set the GS base instead of messing with the LDT.
MOVL 16(SP), AX // tls0
MOVL AX, 0(SP)
CALL runtime·settls(SB)
RET
-TEXT runtime·settls(SB),7,$16
+TEXT runtime·settls(SB),NOSPLIT,$16
// adjust for ELF: wants to use -8(GS) and -4(GS) for g and m
MOVL base+0(FP), CX
ADDL $8, CX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·osyield(SB),7,$-4
+TEXT runtime·osyield(SB),NOSPLIT,$-4
MOVL $350, AX // sys_sched_yield
INT $0x80
RET
-TEXT runtime·lwp_park(SB),7,$-4
+TEXT runtime·lwp_park(SB),NOSPLIT,$-4
MOVL $434, AX // sys__lwp_park
INT $0x80
RET
-TEXT runtime·lwp_unpark(SB),7,$-4
+TEXT runtime·lwp_unpark(SB),NOSPLIT,$-4
MOVL $321, AX // sys__lwp_unpark
INT $0x80
RET
-TEXT runtime·lwp_self(SB),7,$-4
+TEXT runtime·lwp_self(SB),NOSPLIT,$-4
MOVL $311, AX // sys__lwp_self
INT $0x80
RET
-TEXT runtime·sysctl(SB),7,$28
+TEXT runtime·sysctl(SB),NOSPLIT,$28
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// int32 lwp_create(void *context, uintptr flags, void *lwpid)
-TEXT runtime·lwp_create(SB),7,$0
+TEXT runtime·lwp_create(SB),NOSPLIT,$0
MOVQ context+0(FP), DI
MOVQ flags+8(FP), SI
MOVQ lwpid+16(FP), DX
NEGQ AX
RET
-TEXT runtime·lwp_tramp(SB),7,$0
+TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
// Set FS to point at m->tls.
LEAQ m_tls(R8), DI
SYSCALL
JMP -3(PC) // keep exiting
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
MOVL $350, AX // sys_sched_yield
SYSCALL
RET
-TEXT runtime·lwp_park(SB),7,$0
+TEXT runtime·lwp_park(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - abstime
MOVL 16(SP), SI // arg 2 - unpark
MOVQ 24(SP), DX // arg 3 - hint
SYSCALL
RET
-TEXT runtime·lwp_unpark(SB),7,$0
+TEXT runtime·lwp_unpark(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - lwp
MOVL 16(SP), SI // arg 2 - hint
MOVL $321, AX // sys__lwp_unpark
SYSCALL
RET
-TEXT runtime·lwp_self(SB),7,$0
+TEXT runtime·lwp_self(SB),NOSPLIT,$0
MOVL $311, AX // sys__lwp_self
SYSCALL
RET
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-8
+TEXT runtime·exit(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - exit status
MOVL $1, AX // sys_exit
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$-8
+TEXT runtime·exit1(SB),NOSPLIT,$-8
MOVL $310, AX // sys__lwp_exit
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-8
+TEXT runtime·open(SB),NOSPLIT,$-8
MOVQ 8(SP), DI // arg 1 pathname
MOVL 16(SP), SI // arg 2 flags
MOVL 20(SP), DX // arg 3 mode
SYSCALL
RET
-TEXT runtime·close(SB),7,$-8
+TEXT runtime·close(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVL $6, AX
SYSCALL
RET
-TEXT runtime·read(SB),7,$-8
+TEXT runtime·read(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·write(SB),7,$-8
+TEXT runtime·write(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - fd
MOVQ 16(SP), SI // arg 2 - buf
MOVL 24(SP), DX // arg 3 - nbyte
SYSCALL
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
SYSCALL
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
MOVL $311, AX // sys__lwp_self
SYSCALL
MOVQ AX, DI // arg 1 - target
SYSCALL
RET
-TEXT runtime·setitimer(SB),7,$-8
+TEXT runtime·setitimer(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - which
MOVQ 16(SP), SI // arg 2 - itv
MOVQ 24(SP), DX // arg 3 - oitv
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVQ $0, DI // arg 1 - clock_id
LEAQ 8(SP), SI // arg 2 - tp
MOVL $427, AX // sys_clock_gettime
MOVL DX, nsec+8(FP)
RET
-TEXT runtime·nanotime(SB),7,$32
+TEXT runtime·nanotime(SB),NOSPLIT,$32
MOVQ $0, DI // arg 1 - clock_id
LEAQ 8(SP), SI // arg 2 - tp
MOVL $427, AX // sys_clock_gettime
ADDQ DX, AX
RET
-TEXT runtime·getcontext(SB),7,$-8
+TEXT runtime·getcontext(SB),NOSPLIT,$-8
MOVQ 8(SP), DI // arg 1 - context
MOVL $307, AX // sys_getcontext
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 - how
MOVQ 16(SP), SI // arg 2 - set
MOVQ 24(SP), DX // arg 3 - oset
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigreturn_tramp(SB),7,$-8
+TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$-8
MOVQ R15, DI // Load address of ucontext
MOVQ $308, AX // sys_setcontext
SYSCALL
MOVL $1, AX // sys_exit
SYSCALL
-TEXT runtime·sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - signum
MOVQ 16(SP), SI // arg 2 - nsa
MOVQ 24(SP), DX // arg 3 - osa
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
get_tls(BX)
// check that m exists
MOVQ R10, g(BX)
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - addr
MOVQ 16(SP), SI // arg 2 - len
MOVL 24(SP), DX // arg 3 - prot
ADDQ $16, SP
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - addr
MOVQ 16(SP), SI // arg 2 - len
MOVL $73, AX // sys_munmap
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVQ addr+0(FP), DI // arg 1 - addr
MOVQ len+8(FP), SI // arg 2 - len
MOVQ behav+16(FP), DX // arg 3 - behav
// ignore failure - maybe pages are locked
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVQ new+8(SP), DI // arg 1 - nss
MOVQ old+16(SP), SI // arg 2 - oss
MOVQ $281, AX // sys___sigaltstack14
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$8
+TEXT runtime·settls(SB),NOSPLIT,$8
// adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
ADDQ $16, DI // arg 1 - ptr
MOVQ $317, AX // sys__lwp_setprivate
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - name
MOVL 16(SP), SI // arg 2 - namelen
MOVQ 24(SP), DX // arg 3 - oldp
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-4
+TEXT runtime·exit(SB),NOSPLIT,$-4
MOVW 0(FP), R0 // arg 1 exit status
SWI $0xa00001
MOVW.CS $0, R8 // crash on syscall failure
MOVW.CS R8, (R8)
RET
-TEXT runtime·exit1(SB),7,$-4
+TEXT runtime·exit1(SB),NOSPLIT,$-4
SWI $0xa00136 // sys__lwp_exit
MOVW $1, R8 // crash
MOVW R8, (R8)
RET
-TEXT runtime·open(SB),7,$-8
+TEXT runtime·open(SB),NOSPLIT,$-8
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0xa00005
RET
-TEXT runtime·close(SB),7,$-8
+TEXT runtime·close(SB),NOSPLIT,$-8
MOVW 0(FP), R0
SWI $0xa00006
RET
-TEXT runtime·read(SB),7,$-8
+TEXT runtime·read(SB),NOSPLIT,$-8
MOVW 0(FP), R0
MOVW 4(FP), R1
MOVW 8(FP), R2
SWI $0xa00003
RET
-TEXT runtime·write(SB),7,$-4
+TEXT runtime·write(SB),NOSPLIT,$-4
MOVW 0(FP), R0 // arg 1 - fd
MOVW 4(FP), R1 // arg 2 - buf
MOVW 8(FP), R2 // arg 3 - nbyte
RET
// int32 lwp_create(void *context, uintptr flags, void *lwpid)
-TEXT runtime·lwp_create(SB),7,$0
+TEXT runtime·lwp_create(SB),NOSPLIT,$0
MOVW context+0(FP), R0
MOVW flags+4(FP), R1
MOVW lwpid+8(FP), R2
SWI $0xa00135 // sys__lwp_create
RET
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
SWI $0xa0015e // sys_sched_yield
RET
-TEXT runtime·lwp_park(SB),7,$0
+TEXT runtime·lwp_park(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - abstime
MOVW 4(FP), R1 // arg 2 - unpark
MOVW 8(FP), R2 // arg 3 - hint
SWI $0xa001b2 // sys__lwp_park
RET
-TEXT runtime·lwp_unpark(SB),7,$0
+TEXT runtime·lwp_unpark(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - lwp
MOVW 4(FP), R1 // arg 2 - hint
SWI $0xa00141 // sys__lwp_unpark
RET
-TEXT runtime·lwp_self(SB),7,$0
+TEXT runtime·lwp_self(SB),NOSPLIT,$0
SWI $0xa00137 // sys__lwp_self
RET
-TEXT runtime·lwp_tramp(SB),7,$0
+TEXT runtime·lwp_tramp(SB),NOSPLIT,$0
MOVW R0, m
MOVW R1, g
MOVW R8, (R8)
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVW usec+0(FP), R0
MOVW R0, R2
MOVW $1000000, R1
SWI $0xa001ae // sys_nanosleep
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
SWI $0xa00137 // sys__lwp_self, the returned R0 is arg 1
MOVW sig+0(FP), R1 // arg 2 - signal
SWI $0xa0013e // sys__lwp_kill
RET
-TEXT runtime·setitimer(SB),7,$-4
+TEXT runtime·setitimer(SB),NOSPLIT,$-4
MOVW 0(FP), R0 // arg 1 - which
MOVW 4(FP), R1 // arg 2 - itv
MOVW 8(FP), R2 // arg 3 - oitv
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1
SWI $0xa001ab // clock_gettime
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB), 7, $32
+TEXT runtime·nanotime(SB), NOSPLIT, $32
MOVW $0, R0 // CLOCK_REALTIME
MOVW $8(R13), R1
SWI $0xa001ab // clock_gettime
MOVW R1, 4(R3)
RET
-TEXT runtime·getcontext(SB),7,$-4
+TEXT runtime·getcontext(SB),NOSPLIT,$-4
MOVW 0(FP), R0 // arg 1 - context
SWI $0xa00133 // sys_getcontext
MOVW.CS $0, R8 // crash on syscall failure
MOVW.CS R8, (R8)
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - how
MOVW 4(FP), R1 // arg 2 - set
MOVW 8(FP), R2 // arg 3 - oset
MOVW.CS R8, (R8)
RET
-TEXT runtime·sigreturn_tramp(SB),7,$-4
+TEXT runtime·sigreturn_tramp(SB),NOSPLIT,$-4
// on entry, SP points to siginfo, we add sizeof(ucontext)
// to SP to get a pointer to ucontext.
ADD $0x80, R13, R0 // 0x80 == sizeof(UcontextT)
SWI $0xa00001 // sys_exit
B -2(PC) // continue exit
-TEXT runtime·sigaction(SB),7,$4
+TEXT runtime·sigaction(SB),NOSPLIT,$4
MOVW 0(FP), R0 // arg 1 - signum
MOVW 4(FP), R1 // arg 2 - nsa
MOVW 8(FP), R2 // arg 3 - osa
MOVW.CS R8, (R8)
RET
-TEXT runtime·sigtramp(SB),7,$24
+TEXT runtime·sigtramp(SB),NOSPLIT,$24
// this might be called in external code context,
// where g and m are not set.
// first save R0, because _cgo_load_gm will clobber it
MOVW 20(R13), g
RET
-TEXT runtime·mmap(SB),7,$12
+TEXT runtime·mmap(SB),NOSPLIT,$12
MOVW 0(FP), R0 // arg 1 - addr
MOVW 4(FP), R1 // arg 2 - len
MOVW 8(FP), R2 // arg 3 - prot
SUB $4, R13
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - addr
MOVW 4(FP), R1 // arg 2 - len
SWI $0xa00049 // sys_munmap
MOVW.CS R8, (R8)
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVW 0(FP), R0 // arg 1 - addr
MOVW 4(FP), R1 // arg 2 - len
MOVW 8(FP), R2 // arg 3 - behav
// ignore failure - maybe pages are locked
RET
-TEXT runtime·sigaltstack(SB),7,$-4
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-4
MOVW 0(FP), R0 // arg 1 - nss
MOVW 4(FP), R1 // arg 2 - oss
SWI $0xa00119 // sys___sigaltstack14
MOVW.CS R8, (R8)
RET
-TEXT runtime·sysctl(SB),7,$8
+TEXT runtime·sysctl(SB),NOSPLIT,$8
MOVW 0(FP), R0 // arg 1 - name
MOVW 4(FP), R1 // arg 2 - namelen
MOVW 8(FP), R2 // arg 3 - oldp
SUB $4, R13
RET
-TEXT runtime·casp(SB),7,$0
+TEXT runtime·casp(SB),NOSPLIT,$0
B runtime·cas(SB)
// TODO(minux): this is only valid for ARMv6+
// return 1;
// }else
// return 0;
-TEXT runtime·cas(SB),7,$0
+TEXT runtime·cas(SB),NOSPLIT,$0
B runtime·armcas(SB)
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-4
+TEXT runtime·exit(SB),NOSPLIT,$-4
MOVL $1, AX
INT $0x80
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$8
+TEXT runtime·exit1(SB),NOSPLIT,$8
MOVL $0, 0(SP)
MOVL $0, 4(SP) // arg 1 - notdead
MOVL $302, AX // sys___threxit
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-4
+TEXT runtime·open(SB),NOSPLIT,$-4
MOVL $5, AX
INT $0x80
RET
-TEXT runtime·close(SB),7,$-4
+TEXT runtime·close(SB),NOSPLIT,$-4
MOVL $6, AX
INT $0x80
RET
-TEXT runtime·read(SB),7,$-4
+TEXT runtime·read(SB),NOSPLIT,$-4
MOVL $3, AX
INT $0x80
RET
-TEXT runtime·write(SB),7,$-4
+TEXT runtime·write(SB),NOSPLIT,$-4
MOVL $4, AX // sys_write
INT $0x80
RET
-TEXT runtime·usleep(SB),7,$20
+TEXT runtime·usleep(SB),NOSPLIT,$20
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
INT $0x80
RET
-TEXT runtime·raise(SB),7,$12
+TEXT runtime·raise(SB),NOSPLIT,$12
MOVL $299, AX // sys_getthrid
INT $0x80
MOVL $0, 0(SP)
INT $0x80
RET
-TEXT runtime·mmap(SB),7,$36
+TEXT runtime·mmap(SB),NOSPLIT,$36
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
INT $0x80
RET
-TEXT runtime·munmap(SB),7,$-4
+TEXT runtime·munmap(SB),NOSPLIT,$-4
MOVL $73, AX // sys_munmap
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$-4
+TEXT runtime·madvise(SB),NOSPLIT,$-4
MOVL $75, AX // sys_madvise
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·setitimer(SB),7,$-4
+TEXT runtime·setitimer(SB),NOSPLIT,$-4
MOVL $83, AX
INT $0x80
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVL $232, AX
LEAL 12(SP), BX
MOVL $0, 4(SP)
// int64 nanotime(void) so really
// void nanotime(int64 *nsec)
-TEXT runtime·nanotime(SB),7,$32
+TEXT runtime·nanotime(SB),NOSPLIT,$32
MOVL $232, AX
LEAL 12(SP), BX
MOVL $0, 4(SP)
MOVL DX, 4(DI)
RET
-TEXT runtime·sigaction(SB),7,$-4
+TEXT runtime·sigaction(SB),NOSPLIT,$-4
MOVL $46, AX // sys_sigaction
INT $0x80
JAE 2(PC)
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigprocmask(SB),7,$-4
+TEXT runtime·sigprocmask(SB),NOSPLIT,$-4
MOVL $48, AX // sys_sigprocmask
INT $0x80
JAE 2(PC)
MOVL AX, oset+0(FP)
RET
-TEXT runtime·sigtramp(SB),7,$44
+TEXT runtime·sigtramp(SB),NOSPLIT,$44
get_tls(CX)
// check that m exists
RET
// int32 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),7,$12
+TEXT runtime·tfork(SB),NOSPLIT,$12
// Copy mp, gp and fn from the parent stack onto the child stack.
MOVL params+4(FP), AX
MOVL $0x1234, 0x1005
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVL $288, AX // sys_sigaltstack
MOVL new+4(SP), BX
MOVL old+8(SP), CX
INT $3
RET
-TEXT runtime·setldt(SB),7,$4
+TEXT runtime·setldt(SB),NOSPLIT,$4
// Under OpenBSD we set the GS base instead of messing with the LDT.
MOVL tls0+4(FP), AX
MOVL AX, 0(SP)
CALL runtime·settls(SB)
RET
-TEXT runtime·settls(SB),7,$8
+TEXT runtime·settls(SB),NOSPLIT,$8
// adjust for ELF: wants to use -8(GS) and -4(GS) for g and m
MOVL tlsbase+0(FP), CX
ADDL $8, CX
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·osyield(SB),7,$-4
+TEXT runtime·osyield(SB),NOSPLIT,$-4
MOVL $298, AX // sys_sched_yield
INT $0x80
RET
-TEXT runtime·thrsleep(SB),7,$-4
+TEXT runtime·thrsleep(SB),NOSPLIT,$-4
MOVL $300, AX // sys___thrsleep
INT $0x80
RET
-TEXT runtime·thrwakeup(SB),7,$-4
+TEXT runtime·thrwakeup(SB),NOSPLIT,$-4
MOVL $301, AX // sys___thrwakeup
INT $0x80
RET
-TEXT runtime·sysctl(SB),7,$28
+TEXT runtime·sysctl(SB),NOSPLIT,$28
LEAL arg0+0(FP), SI
LEAL 4(SP), DI
CLD
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVL $362, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL $363, AX
INT $0x80
JAE 2(PC)
RET
// int32 runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$32
+TEXT runtime·closeonexec(SB),NOSPLIT,$32
MOVL $92, AX // fcntl
// 0(SP) is where the caller PC would be; kernel skips it
MOVL fd+0(FP), BX
//
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// int64 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
-TEXT runtime·tfork(SB),7,$32
+TEXT runtime·tfork(SB),NOSPLIT,$32
// Copy mp, gp and fn off parent stack for use by child.
MOVQ mm+16(FP), R8
SYSCALL
JMP -3(PC) // keep exiting
-TEXT runtime·osyield(SB),7,$0
+TEXT runtime·osyield(SB),NOSPLIT,$0
MOVL $298, AX // sys_sched_yield
SYSCALL
RET
-TEXT runtime·thrsleep(SB),7,$0
+TEXT runtime·thrsleep(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - ident
MOVL 16(SP), SI // arg 2 - clock_id
MOVQ 24(SP), DX // arg 3 - tp
SYSCALL
RET
-TEXT runtime·thrwakeup(SB),7,$0
+TEXT runtime·thrwakeup(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - ident
MOVL 16(SP), SI // arg 2 - n
MOVL $301, AX // sys___thrwakeup
RET
// Exit the entire program (like C exit)
-TEXT runtime·exit(SB),7,$-8
+TEXT runtime·exit(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - exit status
MOVL $1, AX // sys_exit
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·exit1(SB),7,$-8
+TEXT runtime·exit1(SB),NOSPLIT,$-8
MOVQ $0, DI // arg 1 - notdead
MOVL $302, AX // sys___threxit
SYSCALL
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·open(SB),7,$-8
+TEXT runtime·open(SB),NOSPLIT,$-8
MOVQ 8(SP), DI // arg 1 pathname
MOVL 16(SP), SI // arg 2 flags
MOVL 20(SP), DX // arg 3 mode
SYSCALL
RET
-TEXT runtime·close(SB),7,$-8
+TEXT runtime·close(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVL $6, AX
SYSCALL
RET
-TEXT runtime·read(SB),7,$-8
+TEXT runtime·read(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 fd
MOVQ 16(SP), SI // arg 2 buf
MOVL 24(SP), DX // arg 3 count
SYSCALL
RET
-TEXT runtime·write(SB),7,$-8
+TEXT runtime·write(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - fd
MOVQ 16(SP), SI // arg 2 - buf
MOVL 24(SP), DX // arg 3 - nbyte
SYSCALL
RET
-TEXT runtime·usleep(SB),7,$16
+TEXT runtime·usleep(SB),NOSPLIT,$16
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
SYSCALL
RET
-TEXT runtime·raise(SB),7,$16
+TEXT runtime·raise(SB),NOSPLIT,$16
MOVL $299, AX // sys_getthrid
SYSCALL
MOVQ AX, DI // arg 1 - pid
SYSCALL
RET
-TEXT runtime·setitimer(SB),7,$-8
+TEXT runtime·setitimer(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - which
MOVQ 16(SP), SI // arg 2 - itv
MOVQ 24(SP), DX // arg 3 - oitv
RET
// func now() (sec int64, nsec int32)
-TEXT time·now(SB), 7, $32
+TEXT time·now(SB), NOSPLIT, $32
MOVQ $0, DI // arg 1 - clock_id
LEAQ 8(SP), SI // arg 2 - tp
MOVL $232, AX // sys_clock_gettime
MOVL DX, nsec+8(FP)
RET
-TEXT runtime·nanotime(SB),7,$24
+TEXT runtime·nanotime(SB),NOSPLIT,$24
MOVQ $0, DI // arg 1 - clock_id
LEAQ 8(SP), SI // arg 2 - tp
MOVL $232, AX // sys_clock_gettime
ADDQ DX, AX
RET
-TEXT runtime·sigaction(SB),7,$-8
+TEXT runtime·sigaction(SB),NOSPLIT,$-8
MOVL 8(SP), DI // arg 1 - signum
MOVQ 16(SP), SI // arg 2 - nsa
MOVQ 24(SP), DX // arg 3 - osa
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sigprocmask(SB),7,$0
+TEXT runtime·sigprocmask(SB),NOSPLIT,$0
MOVL 8(SP), DI // arg 1 - how
MOVL 12(SP), SI // arg 2 - set
MOVL $48, AX // sys_sigprocmask
MOVL AX, oset+0(FP) // Return oset
RET
-TEXT runtime·sigtramp(SB),7,$64
+TEXT runtime·sigtramp(SB),NOSPLIT,$64
get_tls(BX)
// check that m exists
MOVQ R10, g(BX)
RET
-TEXT runtime·mmap(SB),7,$0
+TEXT runtime·mmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - addr
MOVQ 16(SP), SI // arg 2 - len
MOVL 24(SP), DX // arg 3 - prot
ADDQ $16, SP
RET
-TEXT runtime·munmap(SB),7,$0
+TEXT runtime·munmap(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - addr
MOVQ 16(SP), SI // arg 2 - len
MOVL $73, AX // sys_munmap
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·madvise(SB),7,$0
+TEXT runtime·madvise(SB),NOSPLIT,$0
MOVQ addr+0(FP), DI // arg 1 - addr
MOVQ len+8(FP), SI // arg 2 - len
MOVQ behav+16(FP), DX // arg 3 - behav
// ignore failure - maybe pages are locked
RET
-TEXT runtime·sigaltstack(SB),7,$-8
+TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVQ new+8(SP), DI // arg 1 - nss
MOVQ old+16(SP), SI // arg 2 - oss
MOVQ $288, AX // sys_sigaltstack
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$0
+TEXT runtime·settls(SB),NOSPLIT,$0
// adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
ADDQ $16, DI
MOVQ $329, AX // sys___settcb
MOVL $0xf1, 0xf1 // crash
RET
-TEXT runtime·sysctl(SB),7,$0
+TEXT runtime·sysctl(SB),NOSPLIT,$0
MOVQ 8(SP), DI // arg 1 - name
MOVL 16(SP), SI // arg 2 - namelen
MOVQ 24(SP), DX // arg 3 - oldp
RET
// int32 runtime·kqueue(void);
-TEXT runtime·kqueue(SB),7,$0
+TEXT runtime·kqueue(SB),NOSPLIT,$0
MOVQ $0, DI
MOVQ $0, SI
MOVQ $0, DX
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
-TEXT runtime·kevent(SB),7,$0
+TEXT runtime·kevent(SB),NOSPLIT,$0
MOVL 8(SP), DI
MOVQ 16(SP), SI
MOVL 24(SP), DX
RET
// void runtime·closeonexec(int32 fd);
-TEXT runtime·closeonexec(SB),7,$0
+TEXT runtime·closeonexec(SB),NOSPLIT,$0
MOVL 8(SP), DI // fd
MOVQ $2, SI // F_SETFD
MOVQ $1, DX // FD_CLOEXEC
// license that can be found in the LICENSE file.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// setldt(int entry, int address, int limit)
-TEXT runtime·setldt(SB),7,$0
+TEXT runtime·setldt(SB),NOSPLIT,$0
RET
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVL $14, AX
INT $64
RET
-TEXT runtime·pread(SB),7,$0
+TEXT runtime·pread(SB),NOSPLIT,$0
MOVL $50, AX
INT $64
RET
-TEXT runtime·pwrite(SB),7,$0
+TEXT runtime·pwrite(SB),NOSPLIT,$0
MOVL $51, AX
INT $64
RET
-TEXT runtime·seek(SB),7,$0
+TEXT runtime·seek(SB),NOSPLIT,$0
MOVL $39, AX
INT $64
CMPL AX, $-1
MOVL AX, 4(CX)
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVL $4, AX
INT $64
RET
-TEXT runtime·exits(SB),7,$0
+TEXT runtime·exits(SB),NOSPLIT,$0
MOVL $8, AX
INT $64
RET
-TEXT runtime·brk_(SB),7,$0
+TEXT runtime·brk_(SB),NOSPLIT,$0
MOVL $24, AX
INT $64
RET
-TEXT runtime·sleep(SB),7,$0
+TEXT runtime·sleep(SB),NOSPLIT,$0
MOVL $17, AX
INT $64
RET
-TEXT runtime·plan9_semacquire(SB),7,$0
+TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
MOVL $37, AX
INT $64
RET
-TEXT runtime·plan9_tsemacquire(SB),7,$0
+TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
MOVL $52, AX
INT $64
RET
-TEXT runtime·notify(SB),7,$0
+TEXT runtime·notify(SB),NOSPLIT,$0
MOVL $28, AX
INT $64
RET
-TEXT runtime·noted(SB),7,$0
+TEXT runtime·noted(SB),NOSPLIT,$0
MOVL $29, AX
INT $64
RET
-TEXT runtime·plan9_semrelease(SB),7,$0
+TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
MOVL $38, AX
INT $64
RET
-TEXT runtime·rfork(SB),7,$0
+TEXT runtime·rfork(SB),NOSPLIT,$0
MOVL $19, AX // rfork
INT $64
RET
// void sigtramp(void *ureg, int8 *note)
-TEXT runtime·sigtramp(SB),7,$0
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
get_tls(AX)
// check that m exists
RET
// Only used by the 64-bit runtime.
-TEXT runtime·setfpmasks(SB),7,$0
+TEXT runtime·setfpmasks(SB),NOSPLIT,$0
RET
#define ERRMAX 128 /* from os_plan9.h */
// in entersyscall mode, without going
// through the allocator (issue 4994).
// See ../syscall/asm_plan9_386.s:/·Syscall/
-TEXT runtime·errstr(SB),7,$0
+TEXT runtime·errstr(SB),NOSPLIT,$0
get_tls(AX)
MOVL m(AX), BX
MOVL m_errstr(BX), CX
// license that can be found in the LICENSE file.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// setldt(int entry, int address, int limit)
-TEXT runtime·setldt(SB),7,$0
+TEXT runtime·setldt(SB),NOSPLIT,$0
RET
-TEXT runtime·open(SB),7,$0
+TEXT runtime·open(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $14, BP
SYSCALL
RET
-TEXT runtime·pread(SB),7,$0
+TEXT runtime·pread(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $50, BP
SYSCALL
RET
-TEXT runtime·pwrite(SB),7,$0
+TEXT runtime·pwrite(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $51, BP
SYSCALL
RET
// int32 _seek(int64*, int32, int64, int32)
-TEXT _seek<>(SB),7,$0
+TEXT _seek<>(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $39, BP
SYSCALL
RET
// int64 seek(int32, int64, int32)
-TEXT runtime·seek(SB),7,$56
+TEXT runtime·seek(SB),NOSPLIT,$56
LEAQ new+48(SP), CX
MOVQ CX, 0(SP)
MOVQ fd+0(FP), CX
MOVQ new+48(SP), AX
RET
-TEXT runtime·close(SB),7,$0
+TEXT runtime·close(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $4, BP
SYSCALL
RET
-TEXT runtime·exits(SB),7,$0
+TEXT runtime·exits(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $8, BP
SYSCALL
RET
-TEXT runtime·brk_(SB),7,$0
+TEXT runtime·brk_(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $24, BP
SYSCALL
RET
-TEXT runtime·sleep(SB),7,$0
+TEXT runtime·sleep(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $17, BP
SYSCALL
RET
-TEXT runtime·plan9_semacquire(SB),7,$0
+TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $37, BP
SYSCALL
RET
-TEXT runtime·plan9_tsemacquire(SB),7,$0
+TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $52, BP
SYSCALL
RET
-TEXT runtime·notify(SB),7,$0
+TEXT runtime·notify(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $28, BP
SYSCALL
RET
-TEXT runtime·noted(SB),7,$0
+TEXT runtime·noted(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $29, BP
SYSCALL
RET
-TEXT runtime·plan9_semrelease(SB),7,$0
+TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $38, BP
SYSCALL
RET
-TEXT runtime·nanotime(SB),7,$0
+TEXT runtime·nanotime(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $60, BP
SYSCALL
RET
-TEXT runtime·rfork(SB),7,$0
+TEXT runtime·rfork(SB),NOSPLIT,$0
MOVQ $0x8000, AX
MOVQ $19, BP // rfork
SYSCALL
RET
// This is needed by asm_amd64.s
-TEXT runtime·settls(SB),7,$0
+TEXT runtime·settls(SB),NOSPLIT,$0
RET
// void sigtramp(void *ureg, int8 *note)
-TEXT runtime·sigtramp(SB),7,$0
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
get_tls(AX)
// check that m exists
CALL runtime·noted(SB)
RET
-TEXT runtime·setfpmasks(SB),7,$8
+TEXT runtime·setfpmasks(SB),NOSPLIT,$8
STMXCSR 0(SP)
MOVL 0(SP), AX
ANDL $~0x3F, AX
// in entersyscall mode, without going
// through the allocator (issue 4994).
// See ../syscall/asm_plan9_386.s:/·Syscall/
-TEXT runtime·errstr(SB),7,$0
+TEXT runtime·errstr(SB),NOSPLIT,$0
get_tls(AX)
MOVQ m(AX), BX
MOVQ m_errstr(BX), CX
// license that can be found in the LICENSE file.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),7,$0
+TEXT runtime·asmstdcall(SB),NOSPLIT,$0
MOVL c+0(FP), BX
// SetLastError(0).
RET
-TEXT runtime·badsignal2(SB),7,$24
+TEXT runtime·badsignal2(SB),NOSPLIT,$24
// stderr
MOVL $-12, 0(SP)
MOVL SP, BP
RET
// faster get/set last error
-TEXT runtime·getlasterror(SB),7,$0
+TEXT runtime·getlasterror(SB),NOSPLIT,$0
MOVL 0x34(FS), AX
RET
-TEXT runtime·setlasterror(SB),7,$0
+TEXT runtime·setlasterror(SB),NOSPLIT,$0
MOVL err+0(FP), AX
MOVL AX, 0x34(FS)
RET
-TEXT runtime·sigtramp(SB),7,$28
+TEXT runtime·sigtramp(SB),NOSPLIT,$28
// unwinding?
MOVL info+0(FP), CX
TESTL $6, 4(CX) // exception flags
sigdone:
RET
-TEXT runtime·ctrlhandler(SB),7,$0
+TEXT runtime·ctrlhandler(SB),NOSPLIT,$0
PUSHL $runtime·ctrlhandler1(SB)
CALL runtime·externalthreadhandler(SB)
MOVL 4(SP), CX
ADDL $12, SP
JMP CX
-TEXT runtime·profileloop(SB),7,$0
+TEXT runtime·profileloop(SB),NOSPLIT,$0
PUSHL $runtime·profileloop1(SB)
CALL runtime·externalthreadhandler(SB)
MOVL 4(SP), CX
ADDL $12, SP
JMP CX
-TEXT runtime·externalthreadhandler(SB),7,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
PUSHL BX
GLOBL runtime·cbctxts(SB), $4
-TEXT runtime·callbackasm1+0(SB),7,$0
+TEXT runtime·callbackasm1+0(SB),NOSPLIT,$0
MOVL 0(SP), AX // will use to find our callback context
// remove return address from stack, we are not returning there
RET
// void tstart(M *newm);
-TEXT runtime·tstart(SB),7,$0
+TEXT runtime·tstart(SB),NOSPLIT,$0
MOVL newm+4(SP), CX // m
MOVL m_g0(CX), DX // g
RET
// uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),7,$0
+TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
MOVL newm+4(SP), BX
PUSHL BX
RET
// setldt(int entry, int address, int limit)
-TEXT runtime·setldt(SB),7,$0
+TEXT runtime·setldt(SB),NOSPLIT,$0
MOVL address+4(FP), CX
MOVL CX, 0x14(FS)
RET
// void install_exception_handler()
-TEXT runtime·install_exception_handler(SB),7,$0
+TEXT runtime·install_exception_handler(SB),NOSPLIT,$0
get_tls(CX)
MOVL m(CX), CX // m
RET
// void remove_exception_handler()
-TEXT runtime·remove_exception_handler(SB),7,$0
+TEXT runtime·remove_exception_handler(SB),NOSPLIT,$0
get_tls(CX)
MOVL m(CX), CX // m
RET
// Sleep duration is in 100ns units.
-TEXT runtime·usleep1(SB),7,$0
+TEXT runtime·usleep1(SB),NOSPLIT,$0
MOVL duration+0(FP), BX
MOVL $runtime·usleep2(SB), AX // to hide from 8l
RET
// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2(SB),7,$20
+TEXT runtime·usleep2(SB),NOSPLIT,$20
// Want negative 100ns units.
NEGL BX
MOVL $-1, hi-4(SP)
// license that can be found in the LICENSE file.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
// maxargs should be divisible by 2, as Windows stack
// must be kept 16-byte aligned on syscall entry.
#define maxargs 16
// void runtime·asmstdcall(void *c);
-TEXT runtime·asmstdcall(SB),7,$0
+TEXT runtime·asmstdcall(SB),NOSPLIT,$0
// asmcgocall will put first argument into CX.
PUSHQ CX // save for later
MOVQ wincall_fn(CX), AX
RET
-TEXT runtime·badsignal2(SB),7,$48
+TEXT runtime·badsignal2(SB),NOSPLIT,$48
// stderr
MOVQ $-12, CX // stderr
MOVQ CX, 0(SP)
RET
// faster get/set last error
-TEXT runtime·getlasterror(SB),7,$0
+TEXT runtime·getlasterror(SB),NOSPLIT,$0
MOVQ 0x30(GS), AX
MOVL 0x68(AX), AX
RET
-TEXT runtime·setlasterror(SB),7,$0
+TEXT runtime·setlasterror(SB),NOSPLIT,$0
MOVL err+0(FP), AX
MOVQ 0x30(GS), CX
MOVL AX, 0x68(CX)
RET
-TEXT runtime·sigtramp(SB),7,$0
+TEXT runtime·sigtramp(SB),NOSPLIT,$0
// CX: exception record
// R8: context
sigdone:
RET
-TEXT runtime·ctrlhandler(SB),7,$8
+TEXT runtime·ctrlhandler(SB),NOSPLIT,$8
MOVQ CX, 16(SP) // spill
MOVQ $runtime·ctrlhandler1(SB), CX
MOVQ CX, 0(SP)
CALL runtime·externalthreadhandler(SB)
RET
-TEXT runtime·profileloop(SB),7,$8
+TEXT runtime·profileloop(SB),NOSPLIT,$8
MOVQ $runtime·profileloop1(SB), CX
MOVQ CX, 0(SP)
CALL runtime·externalthreadhandler(SB)
RET
-TEXT runtime·externalthreadhandler(SB),7,$0
+TEXT runtime·externalthreadhandler(SB),NOSPLIT,$0
PUSHQ BP
MOVQ SP, BP
PUSHQ BX
GLOBL runtime·cbctxts(SB), $8
-TEXT runtime·callbackasm1(SB),7,$0
+TEXT runtime·callbackasm1(SB),NOSPLIT,$0
// Construct args vector for cgocallback().
// By windows/amd64 calling convention first 4 args are in CX, DX, R8, R9
// args from the 5th on are on the stack.
POPQ -8(CX)(DX*1) // restore bytes just after the args
RET
-TEXT runtime·setstacklimits(SB),7,$0
+TEXT runtime·setstacklimits(SB),NOSPLIT,$0
MOVQ 0x30(GS), CX
MOVQ $0, 0x10(CX)
MOVQ $0xffffffffffff, AX
RET
// uint32 tstart_stdcall(M *newm);
-TEXT runtime·tstart_stdcall(SB),7,$0
+TEXT runtime·tstart_stdcall(SB),NOSPLIT,$0
// CX contains first arg newm
MOVQ m_g0(CX), DX // g
RET
// set tls base to DI
-TEXT runtime·settls(SB),7,$0
+TEXT runtime·settls(SB),NOSPLIT,$0
MOVQ DI, 0x28(GS)
RET
// void install_exception_handler()
-TEXT runtime·install_exception_handler(SB),7,$0
+TEXT runtime·install_exception_handler(SB),NOSPLIT,$0
CALL runtime·setstacklimits(SB)
RET
-TEXT runtime·remove_exception_handler(SB),7,$0
+TEXT runtime·remove_exception_handler(SB),NOSPLIT,$0
RET
// Sleep duration is in 100ns units.
-TEXT runtime·usleep1(SB),7,$0
+TEXT runtime·usleep1(SB),NOSPLIT,$0
MOVL duration+0(FP), BX
MOVQ $runtime·usleep2(SB), AX // to hide from 6l
RET
// Runs on OS stack. duration (in 100ns units) is in BX.
-TEXT runtime·usleep2(SB),7,$8
+TEXT runtime·usleep2(SB),NOSPLIT,$8
// Want negative 100ns units.
NEGQ BX
MOVQ SP, R8 // ptime
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
+#include "../../cmd/ld/textflag.h"
+
/*
* C runtime for 64-bit divide.
*/
-TEXT _mul64by32(SB), 7, $0
+TEXT _mul64by32(SB), NOSPLIT, $0
MOVL r+0(FP), CX
MOVL a+4(FP), AX
MULL b+12(FP)
MOVL BX, 4(CX)
RET
-TEXT _div64by32(SB), 7, $0
+TEXT _div64by32(SB), NOSPLIT, $0
MOVL r+12(FP), CX
MOVL a+0(FP), AX
MOVL a+4(FP), DX
// THE SOFTWARE.
#include "zasm_GOOS_GOARCH.h"
+#include "../../cmd/ld/textflag.h"
arg=0
/* replaced use of R10 by R11 because the former can be the data segment base register */
-TEXT _mulv(SB), 7, $0
+TEXT _mulv(SB), NOSPLIT, $0
MOVW 0(FP), R0
MOVW 4(FP), R2 /* l0 */
MOVW 8(FP), R11 /* h0 */
// trampoline for _sfloat2. passes LR as arg0 and
// saves registers R0-R13 and CPSR on the stack. R0-R12 and CPSR flags can
// be changed by _sfloat2.
-TEXT _sfloat(SB), 7, $64-0 // 4 arg + 14*4 saved regs + cpsr
+TEXT _sfloat(SB), NOSPLIT, $64-0 // 4 arg + 14*4 saved regs + cpsr
MOVW R14, 4(R13)
MOVW R0, 8(R13)
MOVW $12(R13), R0
// Please be careful when changing this, it is pretty fragile:
// 1, don't use unconditional branch as the linker is free to reorder the blocks;
// 2. if a == 11, beware that the linker will use R11 if you use certain instructions.
-TEXT udiv<>(SB),7,$-4
+TEXT udiv<>(SB),NOSPLIT,$-4
CLZ R(q), R(s) // find normalizing shift
MOVW.S R(q)<<R(s), R(a)
ADD R(a)>>25, PC, R(a) // most significant 7 bits of divisor
// expects the result in R(TMP)
TMP = 11
-TEXT _divu(SB), 7, $16
+TEXT _divu(SB), NOSPLIT, $16
MOVW R(q), 4(R13)
MOVW R(r), 8(R13)
MOVW R(s), 12(R13)
MOVW 16(R13), R(M)
RET
-TEXT _modu(SB), 7, $16
+TEXT _modu(SB), NOSPLIT, $16
MOVW R(q), 4(R13)
MOVW R(r), 8(R13)
MOVW R(s), 12(R13)
MOVW 16(R13), R(M)
RET
-TEXT _div(SB),7,$16
+TEXT _div(SB),NOSPLIT,$16
MOVW R(q), 4(R13)
MOVW R(r), 8(R13)
MOVW R(s), 12(R13)
RSB $0, R(q), R(TMP)
B out
-TEXT _mod(SB),7,$16
+TEXT _mod(SB),NOSPLIT,$16
MOVW R(q), 4(R13)
MOVW R(r), 8(R13)
MOVW R(s), 12(R13)