qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 14:54:43 -07:00
Code Releases Activity
3ba818c894
go/src/runtime/sys_linux_mips64x.s

446 lines
8.5 KiB
ArmAsm
Raw Normal View History

runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
// Copyright 2015 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.
// +build linux
// +build mips64 mips64le
//
// System calls and other sys.stuff for mips64, Linux
//
#include "go_asm.h"
#include "go_tls.h"
#include "textflag.h"
#define SYS_exit 5058
#define SYS_read 5000
#define SYS_write 5001
#define SYS_open 5002
#define SYS_close 5003
#define SYS_getpid 5038
#define SYS_kill 5060
#define SYS_fcntl 5080
#define SYS_gettimeofday 5094
#define SYS_mmap 5009
#define SYS_munmap 5011
#define SYS_setitimer 5036
#define SYS_clone 5055
#define SYS_newselect 5022
#define SYS_sched_yield 5023
#define SYS_rt_sigreturn 5211
#define SYS_rt_sigaction 5013
#define SYS_rt_sigprocmask 5014
#define SYS_sigaltstack 5129
#define SYS_getrlimit 5095
#define SYS_madvise 5027
#define SYS_mincore 5026
#define SYS_gettid 5178
#define SYS_tkill 5192
#define SYS_futex 5194
#define SYS_sched_getaffinity 5196
#define SYS_exit_group 5205
#define SYS_epoll_create 5207
#define SYS_epoll_ctl 5208
#define SYS_epoll_wait 5209
#define SYS_clock_gettime 5222
#define SYS_epoll_create1 5285
runtime: inform arena placement using sbrk(0) On 32-bit architectures (or if we fail to map a 64-bit-style arena), we try to map the heap arena just above the end of the process image. While we can accept any address, using lower addresses is preferable because lower addresses cause us to map less of the heap bitmap. However, if a program is linked against C code that has global constructors, those constructors may call brk/sbrk to allocate memory (e.g., many C malloc implementations do this for small allocations). The brk also starts just above the process image, so this may adjust the brk past the beginning of where we want to put the heap arena. In this case, the kernel will pick a different address for the arena and it will usually be very high (at least, as these things go in a 32-bit address space). Fix this by consulting the current value of the brk and using this in addition to the end of the process image to compute the initial arena placement. This is implemented only on Linux currently, since we have no evidence that it's an issue on any other OSes. Fixes #19831. Change-Id: Id64b45d08d8c91e4f50d92d0339146250b04f2f8 Reviewed-on: https://go-review.googlesource.com/39810 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-04-06 12:32:37 -06:00
#define SYS_brk 5012
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
TEXT runtime·exit(SB),NOSPLIT,$-8-4
MOVW code+0(FP), R4
MOVV $SYS_exit_group, R2
SYSCALL
RET
runtime: make it possible to exit Go-created threads Currently, threads created by the runtime exist until the whole program exits. For #14592 and #20395, we want to be able to exit and clean up threads created by the runtime. This commit implements that mechanism. The main difficulty is how to clean up the g0 stack. In cgo mode and on Solaris and Windows where the OS manages thread stacks, we simply arrange to return from mstart and let the system clean up the thread. If the runtime allocated the g0 stack, then we use a new exitThread syscall wrapper that arranges to clear a flag in the M once the stack can safely be reaped and call the thread termination syscall. exitThread is based on the existing exit1 wrapper, which was always meant to terminate the calling thread. However, exit1 has never been used since it was introduced 9 years ago, so it was broken on several platforms. exitThread also has the additional complication of having to flag that the stack is unused, which requires some tricks on platforms that use the stack for syscalls. This still leaves the problem of how to reap the unused g0 stacks. For this, we move the M from allm to a new freem list as part of the M exiting. Later, allocm scans the freem list, finds Ms that are marked as done with their stack, removes these from the list and frees their g0 stacks. This also allows these Ms to be garbage collected. This CL does not yet use any of this functionality. Follow-up CLs will. Likewise, there are no new tests in this CL because we'll need follow-up functionality to test it. Change-Id: Ic851ee74227b6d39c6fc1219fc71b45d3004bc63 Reviewed-on: https://go-review.googlesource.com/46037 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
2017-06-16 13:54:21 -06:00
// func exitThread(wait *uint32)
TEXT runtime·exitThread(SB),NOSPLIT,$-8-8
MOVV wait+0(FP), R1
// We're done using the stack.
MOVW $0, R2
SYNC
MOVW R2, (R1)
SYNC
MOVW $0, R4 // exit code
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
MOVV $SYS_exit, R2
SYSCALL
runtime: make it possible to exit Go-created threads Currently, threads created by the runtime exist until the whole program exits. For #14592 and #20395, we want to be able to exit and clean up threads created by the runtime. This commit implements that mechanism. The main difficulty is how to clean up the g0 stack. In cgo mode and on Solaris and Windows where the OS manages thread stacks, we simply arrange to return from mstart and let the system clean up the thread. If the runtime allocated the g0 stack, then we use a new exitThread syscall wrapper that arranges to clear a flag in the M once the stack can safely be reaped and call the thread termination syscall. exitThread is based on the existing exit1 wrapper, which was always meant to terminate the calling thread. However, exit1 has never been used since it was introduced 9 years ago, so it was broken on several platforms. exitThread also has the additional complication of having to flag that the stack is unused, which requires some tricks on platforms that use the stack for syscalls. This still leaves the problem of how to reap the unused g0 stacks. For this, we move the M from allm to a new freem list as part of the M exiting. Later, allocm scans the freem list, finds Ms that are marked as done with their stack, removes these from the list and frees their g0 stacks. This also allows these Ms to be garbage collected. This CL does not yet use any of this functionality. Follow-up CLs will. Likewise, there are no new tests in this CL because we'll need follow-up functionality to test it. Change-Id: Ic851ee74227b6d39c6fc1219fc71b45d3004bc63 Reviewed-on: https://go-review.googlesource.com/46037 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org>
2017-06-16 13:54:21 -06:00
JMP 0(PC)
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
TEXT runtime·open(SB),NOSPLIT,$-8-20
MOVV name+0(FP), R4
MOVW mode+8(FP), R5
MOVW perm+12(FP), R6
MOVV $SYS_open, R2
SYSCALL
BEQ R7, 2(PC)
MOVW $-1, R2
MOVW R2, ret+16(FP)
RET
TEXT runtime·closefd(SB),NOSPLIT,$-8-12
MOVW fd+0(FP), R4
MOVV $SYS_close, R2
SYSCALL
BEQ R7, 2(PC)
MOVW $-1, R2
MOVW R2, ret+8(FP)
RET
TEXT runtime·write(SB),NOSPLIT,$-8-28
MOVV fd+0(FP), R4
MOVV p+8(FP), R5
MOVW n+16(FP), R6
MOVV $SYS_write, R2
SYSCALL
BEQ R7, 2(PC)
MOVW $-1, R2
MOVW R2, ret+24(FP)
RET
TEXT runtime·read(SB),NOSPLIT,$-8-28
MOVW fd+0(FP), R4
MOVV p+8(FP), R5
MOVW n+16(FP), R6
MOVV $SYS_read, R2
SYSCALL
BEQ R7, 2(PC)
MOVW $-1, R2
MOVW R2, ret+24(FP)
RET
TEXT runtime·getrlimit(SB),NOSPLIT,$-8-20
MOVW kind+0(FP), R4 // _RLIMIT_AS = 6 on linux/mips
MOVV limit+8(FP), R5
MOVV $SYS_getrlimit, R2
SYSCALL
MOVW R2, ret+16(FP)
RET
TEXT runtime·usleep(SB),NOSPLIT,$16-4
MOVWU usec+0(FP), R3
MOVV R3, R5
MOVW $1000000, R4
DIVVU R4, R3
MOVV LO, R3
MOVV R3, 8(R29)
MULVU R3, R4
MOVV LO, R4
SUBVU R4, R5
MOVV R5, 16(R29)
// select(0, 0, 0, 0, &tv)
MOVW $0, R4
MOVW $0, R5
MOVW $0, R6
MOVW $0, R7
ADDV $8, R29, R8
MOVV $SYS_newselect, R2
SYSCALL
RET
TEXT runtime·gettid(SB),NOSPLIT,$0-4
MOVV $SYS_gettid, R2
SYSCALL
MOVW R2, ret+0(FP)
RET
TEXT runtime·raise(SB),NOSPLIT,$-8
MOVV $SYS_gettid, R2
SYSCALL
MOVW R2, R4 // arg 1 tid
MOVW sig+0(FP), R5 // arg 2
MOVV $SYS_tkill, R2
SYSCALL
RET
TEXT runtime·raiseproc(SB),NOSPLIT,$-8
MOVV $SYS_getpid, R2
SYSCALL
MOVW R2, R4 // arg 1 pid
MOVW sig+0(FP), R5 // arg 2
MOVV $SYS_kill, R2
SYSCALL
RET
TEXT runtime·setitimer(SB),NOSPLIT,$-8-24
MOVW mode+0(FP), R4
MOVV new+8(FP), R5
MOVV old+16(FP), R6
MOVV $SYS_setitimer, R2
SYSCALL
RET
TEXT runtime·mincore(SB),NOSPLIT,$-8-28
MOVV addr+0(FP), R4
MOVV n+8(FP), R5
MOVV dst+16(FP), R6
MOVV $SYS_mincore, R2
SYSCALL
runtime: fix errno sign for some mmap and mincore cases The caller of mmap expects it to return a positive errno value, but the linux-arm64 and nacl-386 system calls returned a negative errno value. Correct them to negate the errno value. The caller of mincore expects it to return a negative errno value (yes, this is inconsistent), but the linux-mips64x and linux-ppc64x system call returned a positive errno value. Correct them to negate the errno value. Add a test that mmap returns errno with the correct sign. Brad added a test for mincore's errno value in https://golang.org/cl/19457. Fixes #14297. Change-Id: I2b93f32e679bd1eae1c9aef9ae7bcf0ba39521b5 Reviewed-on: https://go-review.googlesource.com/19455 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Minux Ma <minux@golang.org> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
2016-02-10 22:46:51 -07:00
SUBVU R2, R0, R2 // caller expects negative errno
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
MOVW R2, ret+24(FP)
RET
time: record monotonic clock reading in time.Now, for more accurate comparisons See https://golang.org/design/12914-monotonic for details. Fixes #12914. Change-Id: I80edc2e6c012b4ace7161c84cf067d444381a009 Reviewed-on: https://go-review.googlesource.com/36255 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Caleb Spare <cespare@gmail.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-02-02 14:20:58 -07:00
// func walltime() (sec int64, nsec int32)
TEXT runtime·walltime(SB),NOSPLIT,$16
runtime: use clock_gettime(CLOCK_REALTIME) for nanosecond-precision time.now on arm64, mips64x Assembly copied from the clock_gettime(CLOCK_MONOTONIC) call in runtime.nanotime in these files and then modified to use CLOCK_REALTIME. Also comment system call numbers in a few other files. Fixes #11222. Change-Id: Ie132086de7386f865908183aac2713f90fc73e0d Reviewed-on: https://go-review.googlesource.com/32177 Reviewed-by: Cherry Zhang <cherryyz@google.com>
2016-10-27 07:22:43 -06:00
MOVW $0, R4 // CLOCK_REALTIME
MOVV $0(R29), R5
MOVV $SYS_clock_gettime, R2
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
SYSCALL
MOVV 0(R29), R3 // sec
runtime: use clock_gettime(CLOCK_REALTIME) for nanosecond-precision time.now on arm64, mips64x Assembly copied from the clock_gettime(CLOCK_MONOTONIC) call in runtime.nanotime in these files and then modified to use CLOCK_REALTIME. Also comment system call numbers in a few other files. Fixes #11222. Change-Id: Ie132086de7386f865908183aac2713f90fc73e0d Reviewed-on: https://go-review.googlesource.com/32177 Reviewed-by: Cherry Zhang <cherryyz@google.com>
2016-10-27 07:22:43 -06:00
MOVV 8(R29), R5 // nsec
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
MOVV R3, sec+0(FP)
MOVW R5, nsec+8(FP)
RET
TEXT runtime·nanotime(SB),NOSPLIT,$16
MOVW $1, R4 // CLOCK_MONOTONIC
MOVV $0(R29), R5
MOVV $SYS_clock_gettime, R2
SYSCALL
MOVV 0(R29), R3 // sec
MOVV 8(R29), R5 // nsec
// sec is in R3, nsec in R5
// return nsec in R3
MOVV $1000000000, R4
MULVU R4, R3
MOVV LO, R3
ADDVU R5, R3
MOVV R3, ret+0(FP)
RET
TEXT runtime·rtsigprocmask(SB),NOSPLIT,$-8-28
runtime: unify some signal handling functions Unify the OS-specific versions of msigsave, msigrestore, sigblock, updatesigmask, and unblocksig into single versions in signal_unix.go. To do this, make sigprocmask work the same way on all systems, which required adding a definition of sigprocmask for linux and openbsd. Also add a single OS-specific function sigmaskToSigset. Change-Id: I7cbf75131dddb57eeefe648ef845b0791404f785 Reviewed-on: https://go-review.googlesource.com/29689 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2016-09-23 18:54:51 -06:00
MOVW how+0(FP), R4
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
MOVV new+8(FP), R5
MOVV old+16(FP), R6
MOVW size+24(FP), R7
MOVV $SYS_rt_sigprocmask, R2
SYSCALL
BEQ R7, 2(PC)
MOVV R0, 0xf1(R0) // crash
RET
TEXT runtime·rt_sigaction(SB),NOSPLIT,$-8-36
MOVV sig+0(FP), R4
MOVV new+8(FP), R5
MOVV old+16(FP), R6
MOVV size+24(FP), R7
MOVV $SYS_rt_sigaction, R2
SYSCALL
MOVW R2, ret+32(FP)
RET
TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
MOVW sig+8(FP), R4
MOVV info+16(FP), R5
MOVV ctx+24(FP), R6
runtime: add linux/mips64x cgo support Change-Id: Id40dd05b7b264f3b779fdf9ccc2421ba4bc70589 Reviewed-on: https://go-review.googlesource.com/19806 Reviewed-by: Minux Ma <minux@golang.org>
2016-04-27 20:18:24 -06:00
MOVV fn+0(FP), R25
JAL (R25)
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
RET
TEXT runtime·sigtramp(SB),NOSPLIT,$64
cmd/internal/obj/mips et al.: introduce SB register on mips64x SB register (R28) is introduced for access external addresses with shorter instruction sequences. It is loaded at entry points. External data within 2G of SB can be accessed this way. cmd/internal/obj: relocaltion R_ADDRMIPS is split into two relocations R_ADDRMIPS and R_ADDRMIPSU, handling the low 16 bits and the "upper" 16 bits of external addresses, respectively, since the instructios may not be adjacent. It might be better if relocation Variant could be used. cmd/link/internal/mips64: support new relocations. cmd/compile/internal/mips64: reserve SB register. runtime: initialize SB register at entry points. Change-Id: I5f34868f88c5a9698c042a8a1f12f76806c187b9 Reviewed-on: https://go-review.googlesource.com/19802 Reviewed-by: Minux Ma <minux@golang.org>
2016-04-27 20:18:02 -06:00
// initialize REGSB = PC&0xffffffff00000000
BGEZAL R0, 1(PC)
SRLV $32, R31, RSB
SLLV $32, RSB
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
// this might be called in external code context,
// where g is not set.
MOVB runtime·iscgo(SB), R1
BEQ R1, 2(PC)
JAL runtime·load_g(SB)
MOVW R4, 8(R29)
MOVV R5, 16(R29)
MOVV R6, 24(R29)
MOVV $runtime·sigtrampgo(SB), R1
JAL (R1)
RET
runtime: support symbolic backtrace of C code in a cgo crash The new function runtime.SetCgoTraceback may be used to register stack traceback and symbolizer functions, written in C, to do a stack traceback from cgo code. There is a sample implementation of runtime.SetCgoSymbolizer at github.com/ianlancetaylor/cgosymbolizer. Just importing that package is sufficient to get symbolic C backtraces. Currently only supported on linux/amd64. Change-Id: If96ee2eb41c6c7379d407b9561b87557bfe47341 Reviewed-on: https://go-review.googlesource.com/17761 Reviewed-by: Austin Clements <austin@google.com>
2015-12-11 18:16:48 -07:00
TEXT runtime·cgoSigtramp(SB),NOSPLIT,$0
cmd/internal/obj/mips et al.: introduce SB register on mips64x SB register (R28) is introduced for access external addresses with shorter instruction sequences. It is loaded at entry points. External data within 2G of SB can be accessed this way. cmd/internal/obj: relocaltion R_ADDRMIPS is split into two relocations R_ADDRMIPS and R_ADDRMIPSU, handling the low 16 bits and the "upper" 16 bits of external addresses, respectively, since the instructios may not be adjacent. It might be better if relocation Variant could be used. cmd/link/internal/mips64: support new relocations. cmd/compile/internal/mips64: reserve SB register. runtime: initialize SB register at entry points. Change-Id: I5f34868f88c5a9698c042a8a1f12f76806c187b9 Reviewed-on: https://go-review.googlesource.com/19802 Reviewed-by: Minux Ma <minux@golang.org>
2016-04-27 20:18:02 -06:00
JMP runtime·sigtramp(SB)
runtime: support symbolic backtrace of C code in a cgo crash The new function runtime.SetCgoTraceback may be used to register stack traceback and symbolizer functions, written in C, to do a stack traceback from cgo code. There is a sample implementation of runtime.SetCgoSymbolizer at github.com/ianlancetaylor/cgosymbolizer. Just importing that package is sufficient to get symbolic C backtraces. Currently only supported on linux/amd64. Change-Id: If96ee2eb41c6c7379d407b9561b87557bfe47341 Reviewed-on: https://go-review.googlesource.com/17761 Reviewed-by: Austin Clements <austin@google.com>
2015-12-11 18:16:48 -07:00
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
TEXT runtime·mmap(SB),NOSPLIT,$-8
MOVV addr+0(FP), R4
MOVV n+8(FP), R5
MOVW prot+16(FP), R6
MOVW flags+20(FP), R7
MOVW fd+24(FP), R8
MOVW off+28(FP), R9
MOVV $SYS_mmap, R2
SYSCALL
MOVV R2, ret+32(FP)
RET
TEXT runtime·munmap(SB),NOSPLIT,$-8
MOVV addr+0(FP), R4
MOVV n+8(FP), R5
MOVV $SYS_munmap, R2
SYSCALL
BEQ R7, 2(PC)
MOVV R0, 0xf3(R0) // crash
RET
TEXT runtime·madvise(SB),NOSPLIT,$-8
MOVV addr+0(FP), R4
MOVV n+8(FP), R5
MOVW flags+16(FP), R6
MOVV $SYS_madvise, R2
SYSCALL
// ignore failure - maybe pages are locked
RET
// int64 futex(int32 *uaddr, int32 op, int32 val,
// struct timespec *timeout, int32 *uaddr2, int32 val2);
TEXT runtime·futex(SB),NOSPLIT,$-8
MOVV addr+0(FP), R4
MOVW op+8(FP), R5
MOVW val+12(FP), R6
MOVV ts+16(FP), R7
MOVV addr2+24(FP), R8
MOVW val3+32(FP), R9
MOVV $SYS_futex, R2
SYSCALL
MOVW R2, ret+40(FP)
RET
// int64 clone(int32 flags, void *stk, M *mp, G *gp, void (*fn)(void));
TEXT runtime·clone(SB),NOSPLIT,$-8
MOVW flags+0(FP), R4
MOVV stk+8(FP), R5
// Copy mp, gp, fn off parent stack for use by child.
// Careful: Linux system call clobbers ???.
all: fix assembly vet issues Add missing function prototypes. Fix function prototypes. Use FP references instead of SP references. Fix variable names. Update comments. Clean up whitespace. (Not for vet.) All fairly minor fixes to make vet happy. Updates #11041 Change-Id: Ifab2cdf235ff61cdc226ab1d84b8467b5ac9446c Reviewed-on: https://go-review.googlesource.com/27713 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2016-07-11 17:05:57 -06:00
MOVV mp+16(FP), R16
MOVV gp+24(FP), R17
runtime: added assembly part of linux/mips64{,le} support Change-Id: I9e94027ef66c88007107de2b2b75c3d7cf1352af Reviewed-on: https://go-review.googlesource.com/14467 Reviewed-by: Minux Ma <minux@golang.org>
2015-09-10 09:25:58 -06:00
MOVV fn+32(FP), R18
MOVV R16, -8(R5)
MOVV R17, -16(R5)
MOVV R18, -24(R5)
MOVV $1234, R16
MOVV R16, -32(R5)
MOVV $SYS_clone, R2
SYSCALL
// In parent, return.
BEQ R2, 3(PC)
MOVW R2, ret+40(FP)
RET
// In child, on new stack.
MOVV -32(R29), R16
MOVV $1234, R1
BEQ R16, R1, 2(PC)
MOVV R0, 0(R0)
// Initialize m->procid to Linux tid
MOVV $SYS_gettid, R2
SYSCALL
MOVV -24(R29), R18 // fn
MOVV -16(R29), R17 // g
MOVV -8(R29), R16 // m
BEQ R16, nog
BEQ R17, nog
MOVV R2, m_procid(R16)
// TODO: setup TLS.
// In child, set up new stack
MOVV R16, g_m(R17)
MOVV R17, g
//CALL runtime·stackcheck(SB)
nog:
// Call fn
JAL (R18)
// It shouldn't return. If it does, exit that thread.
MOVW $111, R4
MOVV $SYS_exit, R2
SYSCALL
JMP -3(PC) // keep exiting
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
MOVV new+0(FP), R4
MOVV old+8(FP), R5
MOVV $SYS_sigaltstack, R2
SYSCALL
BEQ R7, 2(PC)
MOVV R0, 0xf1(R0) // crash
RET
TEXT runtime·osyield(SB),NOSPLIT,$-8
MOVV $SYS_sched_yield, R2
SYSCALL
RET
TEXT runtime·sched_getaffinity(SB),NOSPLIT,$-8
MOVV pid+0(FP), R4
MOVV len+8(FP), R5
MOVV buf+16(FP), R6
MOVV $SYS_sched_getaffinity, R2
SYSCALL
MOVW R2, ret+24(FP)
RET
// int32 runtime·epollcreate(int32 size);
TEXT runtime·epollcreate(SB),NOSPLIT,$-8
MOVW size+0(FP), R4
MOVV $SYS_epoll_create, R2
SYSCALL
MOVW R2, ret+8(FP)
RET
// int32 runtime·epollcreate1(int32 flags);
TEXT runtime·epollcreate1(SB),NOSPLIT,$-8
MOVW flags+0(FP), R4
MOVV $SYS_epoll_create1, R2
SYSCALL
MOVW R2, ret+8(FP)
RET
// func epollctl(epfd, op, fd int32, ev *epollEvent) int
TEXT runtime·epollctl(SB),NOSPLIT,$-8
MOVW epfd+0(FP), R4
MOVW op+4(FP), R5
MOVW fd+8(FP), R6
MOVV ev+16(FP), R7
MOVV $SYS_epoll_ctl, R2
SYSCALL
MOVW R2, ret+24(FP)
RET
// int32 runtime·epollwait(int32 epfd, EpollEvent *ev, int32 nev, int32 timeout);
TEXT runtime·epollwait(SB),NOSPLIT,$-8
MOVW epfd+0(FP), R4
MOVV ev+8(FP), R5
MOVW nev+16(FP), R6
MOVW timeout+20(FP), R7
MOVV $SYS_epoll_wait, R2
SYSCALL
MOVW R2, ret+24(FP)
RET
// void runtime·closeonexec(int32 fd);
TEXT runtime·closeonexec(SB),NOSPLIT,$-8
MOVW fd+0(FP), R4 // fd
MOVV $2, R5 // F_SETFD
MOVV $1, R6 // FD_CLOEXEC
MOVV $SYS_fcntl, R2
SYSCALL
RET
runtime: inform arena placement using sbrk(0) On 32-bit architectures (or if we fail to map a 64-bit-style arena), we try to map the heap arena just above the end of the process image. While we can accept any address, using lower addresses is preferable because lower addresses cause us to map less of the heap bitmap. However, if a program is linked against C code that has global constructors, those constructors may call brk/sbrk to allocate memory (e.g., many C malloc implementations do this for small allocations). The brk also starts just above the process image, so this may adjust the brk past the beginning of where we want to put the heap arena. In this case, the kernel will pick a different address for the arena and it will usually be very high (at least, as these things go in a 32-bit address space). Fix this by consulting the current value of the brk and using this in addition to the end of the process image to compute the initial arena placement. This is implemented only on Linux currently, since we have no evidence that it's an issue on any other OSes. Fixes #19831. Change-Id: Id64b45d08d8c91e4f50d92d0339146250b04f2f8 Reviewed-on: https://go-review.googlesource.com/39810 Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-04-06 12:32:37 -06:00
// func sbrk0() uintptr
TEXT runtime·sbrk0(SB),NOSPLIT,$-8-8
// Implemented as brk(NULL).
MOVV $0, R4
MOVV $SYS_brk, R2
SYSCALL
MOVV R2, ret+0(FP)
RET
Copy Permalink