qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-10-04 04:31:21 -06:00
Code Releases Activity
c46bcd4d13
go/src/pkg/runtime/sys_openbsd_amd64.s

351 lines
7.3 KiB
ArmAsm
Raw Normal View History

runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//
// System calls and other sys.stuff for AMD64, OpenBSD
// /usr/src/sys/kern/syscalls.master for syscall numbers.
//
runtime: separate out auto-generated files, take 2 This is like the ill-fated CL 5493063 except that I have written a shell script (autogen.sh) instead of thinking I could possibly write a correct Makefile. R=golang-dev, r CC=golang-dev https://golang.org/cl/5496075
2011-12-19 13:51:13 -07:00
#include "zasm_GOOS_GOARCH.h"
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
#include "../../cmd/ld/textflag.h"
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
runtime: use monotonic clock for openbsd/386 and openbsd/amd64 timers Switch nanotime to a monotonic clock on openbsd/386 and openbsd/amd64. Also use a monotonic clock when for thrsleep, since the sleep duration is based on the value returned from nanotime. Update #6007 LGTM=bradfitz R=golang-codereviews, bradfitz CC=golang-codereviews https://golang.org/cl/68460044
2014-02-25 19:20:36 -07:00
#define CLOCK_MONOTONIC $3
runtime: use "mp" and "gp" instead of "m" and "g" for local variable name to avoid confusion with the global "m" and "g". R=golang-dev, minux.ma, rsc CC=bradfitz, golang-dev https://golang.org/cl/6939064
2012-12-18 09:30:29 -07:00
// int64 tfork(void *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·tfork(SB),NOSPLIT,$32
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
runtime: use "mp" and "gp" instead of "m" and "g" for local variable name to avoid confusion with the global "m" and "g". R=golang-dev, minux.ma, rsc CC=bradfitz, golang-dev https://golang.org/cl/6939064
2012-12-18 09:30:29 -07:00
// Copy mp, gp and fn off parent stack for use by child.
runtime: use __tfork() syscall on openbsd Switch from using the rfork() syscall on OpenBSD, to the __tfork() syscall. The __tfork() syscall is the preferred way of creating system threads and the rfork() syscall has recently been removed. Note: this will break compatibility with OpenBSD releases prior to 5.1. R=golang-dev, bradfitz, devon.odell, rsc CC=golang-dev https://golang.org/cl/6037048
2012-04-25 08:08:02 -06:00
MOVQ mm+16(FP), R8
MOVQ gg+24(FP), R9
MOVQ fn+32(FP), R12
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
runtime: use __tfork() syscall on openbsd Switch from using the rfork() syscall on OpenBSD, to the __tfork() syscall. The __tfork() syscall is the preferred way of creating system threads and the rfork() syscall has recently been removed. Note: this will break compatibility with OpenBSD releases prior to 5.1. R=golang-dev, bradfitz, devon.odell, rsc CC=golang-dev https://golang.org/cl/6037048
2012-04-25 08:08:02 -06:00
MOVQ param+0(FP), DI
runtime: update openbsd runtime to use new tfork syscall Update OpenBSD runtime to use the new version of the sys___tfork syscall and switch TLS initialisation from sys_arch to sys___set_tcb (note that both of these syscalls are available in OpenBSD 5.2). R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6843058
2012-11-21 07:25:53 -07:00
MOVQ psize+8(FP), SI
MOVL $8, AX // sys___tfork
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
runtime: use __tfork() syscall on openbsd Switch from using the rfork() syscall on OpenBSD, to the __tfork() syscall. The __tfork() syscall is the preferred way of creating system threads and the rfork() syscall has recently been removed. Note: this will break compatibility with OpenBSD releases prior to 5.1. R=golang-dev, bradfitz, devon.odell, rsc CC=golang-dev https://golang.org/cl/6037048
2012-04-25 08:08:02 -06:00
// Return if tfork syscall failed.
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
JCC 4(PC)
runtime: use 64-bit negative error code on 64-bit machines NEGL does a negation of the bottom 32 bits and then zero-extends to 64 bits, resulting in a negative 32-bit number but a positive 64-bit number. NEGQ does a full 64-bit negation, so that the result is negative both as a 32-bit and as a 64-bit number. This doesn't matter for the functions that are declared to return int32. It only matters for the ones that return int64 or void* [sic]. This will fix the current incorrect error in the OpenBSD/amd64 build. The build will still be broken, but it won't report a bogus error. R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/7536046
2013-03-14 21:42:11 -06:00
NEGQ AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ AX, ret+40(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
// In parent, return.
CMPL AX, $0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
JEQ 3(PC)
MOVQ AX, ret+40(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
// Set FS to point at m->tls.
LEAQ m_tls(R8), DI
CALL runtime·settls(SB)
runtime: use __tfork() syscall on openbsd Switch from using the rfork() syscall on OpenBSD, to the __tfork() syscall. The __tfork() syscall is the preferred way of creating system threads and the rfork() syscall has recently been removed. Note: this will break compatibility with OpenBSD releases prior to 5.1. R=golang-dev, bradfitz, devon.odell, rsc CC=golang-dev https://golang.org/cl/6037048
2012-04-25 08:08:02 -06:00
// In child, set up new stack.
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
get_tls(CX)
all: remove 'extern register M *m' from runtime The runtime has historically held two dedicated values g (current goroutine) and m (current thread) in 'extern register' slots (TLS on x86, real registers backed by TLS on ARM). This CL removes the extern register m; code now uses g->m. On ARM, this frees up the register that formerly held m (R9). This is important for NaCl, because NaCl ARM code cannot use R9 at all. The Go 1 macrobenchmarks (those with per-op times >= 10 µs) are unaffected: BenchmarkBinaryTree17 5491374955 5471024381 -0.37% BenchmarkFannkuch11 4357101311 4275174828 -1.88% BenchmarkGobDecode 11029957 11364184 +3.03% BenchmarkGobEncode 6852205 6784822 -0.98% BenchmarkGzip 650795967 650152275 -0.10% BenchmarkGunzip 140962363 141041670 +0.06% BenchmarkHTTPClientServer 71581 73081 +2.10% BenchmarkJSONEncode 31928079 31913356 -0.05% BenchmarkJSONDecode 117470065 113689916 -3.22% BenchmarkMandelbrot200 6008923 5998712 -0.17% BenchmarkGoParse 6310917 6327487 +0.26% BenchmarkRegexpMatchMedium_1K 114568 114763 +0.17% BenchmarkRegexpMatchHard_1K 168977 169244 +0.16% BenchmarkRevcomp 935294971 914060918 -2.27% BenchmarkTemplate 145917123 148186096 +1.55% Minux previous reported larger variations, but these were caused by run-to-run noise, not repeatable slowdowns. Actual code changes by Minux. I only did the docs and the benchmarking. LGTM=dvyukov, iant, minux R=minux, josharian, iant, dave, bradfitz, dvyukov CC=golang-codereviews https://golang.org/cl/109050043
2014-06-26 09:54:39 -06:00
MOVQ R8, g_m(R9)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVQ R9, g(CX)
CALL runtime·stackcheck(SB)
// Call fn
CALL R12
// It shouldn't return. If it does, exit
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVQ $0, DI // arg 1 - notdead
MOVL $302, AX // sys___threxit
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
runtime: openbsd thread tweaks - Rename sys_sched_yield() to osyield() as this is now defined in asm.h. - Only print kern.rtheads message if rfork_thread() failed with ENOTSUP. - Remove unused variables. R=rsc CC=golang-dev https://golang.org/cl/4973043
2011-08-29 07:35:13 -06:00
JMP -3(PC) // keep exiting
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·osyield(SB),NOSPLIT,$0
runtime: update openbsd runtime to use new tfork syscall Update OpenBSD runtime to use the new version of the sys___tfork syscall and switch TLS initialisation from sys_arch to sys___set_tcb (note that both of these syscalls are available in OpenBSD 5.2). R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6843058
2012-11-21 07:25:53 -07:00
MOVL $298, AX // sys_sched_yield
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·thrsleep(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ ident+0(FP), DI // arg 1 - ident
MOVL clock_id+8(FP), SI // arg 2 - clock_id
MOVQ tsp+16(FP), DX // arg 3 - tp
MOVQ lock+24(FP), R10 // arg 4 - lock
MOVQ abort+32(FP), R8 // arg 5 - abort
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $94, AX // sys___thrsleep
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+40(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·thrwakeup(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ ident+0(FP), DI // arg 1 - ident
MOVL n+8(FP), SI // arg 2 - n
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $301, AX // sys___thrwakeup
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+16(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
// Exit the entire program (like C exit)
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·exit(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL code+0(FP), DI // arg 1 - exit status
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $1, AX // sys_exit
SYSCALL
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·exit1(SB),NOSPLIT,$-8
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVQ $0, DI // arg 1 - notdead
MOVL $302, AX // sys___threxit
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·open(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ name+0(FP), DI // arg 1 pathname
MOVL mode+8(FP), SI // arg 2 flags
MOVL perm+12(FP), DX // arg 3 mode
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
MOVL $5, AX
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+16(FP)
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·close(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL fd+0(FP), DI // arg 1 fd
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
MOVL $6, AX
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+8(FP)
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·read(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL fd+0(FP), DI // arg 1 fd
MOVQ p+8(FP), SI // arg 2 buf
MOVL n+16(FP), DX // arg 3 count
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
MOVL $3, AX
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+24(FP)
runtime: faster & safer hash function Uses AES hardware instructions on 386/amd64 to implement a fast hash function. Incorporates a random key to thwart hash collision DOS attacks. Depends on CL#7548043 for new assembly instructions. Update #3885 Helps some by making hashing faster. Go time drops from 0.65s to 0.51s. R=rsc, r, bradfitz, remyoudompheng, khr, dsymonds, minux.ma, elias.naur CC=golang-dev https://golang.org/cl/7543043
2013-03-12 11:47:44 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·write(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ fd+0(FP), DI // arg 1 - fd
MOVQ p+8(FP), SI // arg 2 - buf
MOVL n+16(FP), DX // arg 3 - nbyte
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $4, AX // sys_write
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+24(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·usleep(SB),NOSPLIT,$16
runtime: implement runtime usleep for openbsd R=golang-dev, mikioh.mikioh, hectorchu CC=golang-dev https://golang.org/cl/5173043
2011-10-01 12:58:36 -06:00
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
DIVL CX
MOVQ AX, 0(SP) // tv_sec
MOVL $1000, AX
MULL DX
MOVQ AX, 8(SP) // tv_nsec
MOVQ SP, DI // arg 1 - rqtp
MOVQ $0, SI // arg 2 - rmtp
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $91, AX // sys_nanosleep
runtime: implement runtime usleep for openbsd R=golang-dev, mikioh.mikioh, hectorchu CC=golang-dev https://golang.org/cl/5173043
2011-10-01 12:58:36 -06:00
SYSCALL
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·raise(SB),NOSPLIT,$16
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $299, AX // sys_getthrid
SYSCALL
MOVQ AX, DI // arg 1 - pid
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL sig+0(FP), SI // arg 2 - signum
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $37, AX // sys_kill
SYSCALL
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·setitimer(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL mode+0(FP), DI // arg 1 - which
MOVQ new+8(FP), SI // arg 2 - itv
MOVQ old+16(FP), DX // arg 3 - oitv
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $69, AX // sys_setitimer
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
RET
time: new Time, Duration, ZoneInfo types R=r, bradfitz, gri, dsymonds, iant CC=golang-dev https://golang.org/cl/5392041
2011-11-30 09:59:44 -07:00
// func now() (sec int64, nsec int32)
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT time·now(SB), NOSPLIT, $32
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
MOVQ $0, DI // arg 1 - clock_id
LEAQ 8(SP), SI // arg 2 - tp
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $87, AX // sys_clock_gettime
time: new Time, Duration, ZoneInfo types R=r, bradfitz, gri, dsymonds, iant CC=golang-dev https://golang.org/cl/5392041
2011-11-30 09:59:44 -07:00
SYSCALL
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVQ 8(SP), AX // sec
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
MOVQ 16(SP), DX // nsec
time: new Time, Duration, ZoneInfo types R=r, bradfitz, gri, dsymonds, iant CC=golang-dev https://golang.org/cl/5392041
2011-11-30 09:59:44 -07:00
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
// sec is in AX, nsec in DX
time: new Time, Duration, ZoneInfo types R=r, bradfitz, gri, dsymonds, iant CC=golang-dev https://golang.org/cl/5392041
2011-11-30 09:59:44 -07:00
MOVQ AX, sec+0(FP)
MOVL DX, nsec+8(FP)
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·nanotime(SB),NOSPLIT,$24
runtime: use monotonic clock for openbsd/386 and openbsd/amd64 timers Switch nanotime to a monotonic clock on openbsd/386 and openbsd/amd64. Also use a monotonic clock when for thrsleep, since the sleep duration is based on the value returned from nanotime. Update #6007 LGTM=bradfitz R=golang-codereviews, bradfitz CC=golang-codereviews https://golang.org/cl/68460044
2014-02-25 19:20:36 -07:00
MOVQ CLOCK_MONOTONIC, DI // arg 1 - clock_id
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
LEAQ 8(SP), SI // arg 2 - tp
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $87, AX // sys_clock_gettime
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVQ 8(SP), AX // sec
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
MOVQ 16(SP), DX // nsec
time: faster Nanoseconds call runtime knows how to get the time of day without allocating memory. R=golang-dev, dsymonds, dave, hectorchu, r, cw CC=golang-dev https://golang.org/cl/5297078
2011-11-03 15:35:28 -06:00
runtime: use clock_gettime to get ns resolution for time.now & runtime.nanotime For Linux/{386,arm}, FreeBSD/{386,amd64,arm}, NetBSD/{386,amd64}, OpenBSD/{386,amd64}. Note: our Darwin implementation already has ns resolution. Linux/386 (Core i7-2600 @ 3.40GHz, kernel 3.5.2-gentoo) benchmark old ns/op new ns/op delta BenchmarkNow 110 118 +7.27% Linux/ARM (ARM Cortex-A8 @ 800MHz, kernel 2.6.32.28 android) benchmark old ns/op new ns/op delta BenchmarkNow 625 542 -13.28% Linux/ARM (ARM Cortex-A9 @ 1GHz, Pandaboard) benchmark old ns/op new ns/op delta BenchmarkNow 992 909 -8.37% FreeBSD 9-REL-p1/amd64 (Dell R610 Server with Xeon X5650 @ 2.67GHz) benchmark old ns/op new ns/op delta BenchmarkNow 699 695 -0.57% FreeBSD 9-REL-p1/amd64 (Atom D525 @ 1.80GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1553 1658 +6.76% OpenBSD/amd64 (Dell E6410 with i5 CPU M 540 @ 2.53GHz) benchmark old ns/op new ns/op delta BenchmarkNow 1262 1236 -2.06% OpenBSD/i386 (Asus eeePC 701 with Intel Celeron M 900MHz - locked to 631MHz) benchmark old ns/op new ns/op delta BenchmarkNow 5089 5043 -0.90% NetBSD/i386 (VMware VM with Core i5 CPU @ 2.7GHz) benchmark old ns/op new ns/op delta BenchmarkNow 277 278 +0.36% NetBSD/amd64 (VMware VM with Core i5 CPU @ 2.7Ghz) benchmark old ns/op new ns/op delta BenchmarkNow 103 105 +1.94% Thanks Maxim Khitrov, Joel Sing, and Dave Cheney for providing benchmark data. R=jsing, dave, rsc CC=golang-dev https://golang.org/cl/6820120
2012-12-18 07:57:25 -07:00
// sec is in AX, nsec in DX
time: faster Nanoseconds call runtime knows how to get the time of day without allocating memory. R=golang-dev, dsymonds, dave, hectorchu, r, cw CC=golang-dev https://golang.org/cl/5297078
2011-11-03 15:35:28 -06:00
// return nsec in AX
IMULQ $1000000000, AX
ADDQ DX, AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ AX, ret+0(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·sigaction(SB),NOSPLIT,$-8
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL sig+0(FP), DI // arg 1 - signum
MOVQ new+8(FP), SI // arg 2 - nsa
MOVQ old+16(FP), DX // arg 3 - osa
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $46, AX
SYSCALL
JCC 2(PC)
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·sigprocmask(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL mode+0(FP), DI // arg 1 - how
MOVL new+4(FP), SI // arg 2 - set
runtime: block signals during thread creation on openbsd Block signals during thread creation, otherwise the new thread can receive a signal prior to initialisation completing. Fixes #3102. R=golang-dev, rsc, devon.odell, minux.ma CC=golang-dev https://golang.org/cl/5757064
2012-04-10 05:57:05 -06:00
MOVL $48, AX // sys_sigprocmask
SYSCALL
JCC 2(PC)
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+8(FP)
runtime: block signals during thread creation on openbsd Block signals during thread creation, otherwise the new thread can receive a signal prior to initialisation completing. Fixes #3102. R=golang-dev, rsc, devon.odell, minux.ma CC=golang-dev https://golang.org/cl/5757064
2012-04-10 05:57:05 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·sigtramp(SB),NOSPLIT,$64
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
get_tls(BX)
all: remove 'extern register M *m' from runtime The runtime has historically held two dedicated values g (current goroutine) and m (current thread) in 'extern register' slots (TLS on x86, real registers backed by TLS on ARM). This CL removes the extern register m; code now uses g->m. On ARM, this frees up the register that formerly held m (R9). This is important for NaCl, because NaCl ARM code cannot use R9 at all. The Go 1 macrobenchmarks (those with per-op times >= 10 µs) are unaffected: BenchmarkBinaryTree17 5491374955 5471024381 -0.37% BenchmarkFannkuch11 4357101311 4275174828 -1.88% BenchmarkGobDecode 11029957 11364184 +3.03% BenchmarkGobEncode 6852205 6784822 -0.98% BenchmarkGzip 650795967 650152275 -0.10% BenchmarkGunzip 140962363 141041670 +0.06% BenchmarkHTTPClientServer 71581 73081 +2.10% BenchmarkJSONEncode 31928079 31913356 -0.05% BenchmarkJSONDecode 117470065 113689916 -3.22% BenchmarkMandelbrot200 6008923 5998712 -0.17% BenchmarkGoParse 6310917 6327487 +0.26% BenchmarkRegexpMatchMedium_1K 114568 114763 +0.17% BenchmarkRegexpMatchHard_1K 168977 169244 +0.16% BenchmarkRevcomp 935294971 914060918 -2.27% BenchmarkTemplate 145917123 148186096 +1.55% Minux previous reported larger variations, but these were caused by run-to-run noise, not repeatable slowdowns. Actual code changes by Minux. I only did the docs and the benchmarking. LGTM=dvyukov, iant, minux R=minux, josharian, iant, dave, bradfitz, dvyukov CC=golang-codereviews https://golang.org/cl/109050043
2014-06-26 09:54:39 -06:00
// check that g exists
MOVQ g(BX), R10
CMPQ R10, $0
runtime: correctly handle signals received on foreign threads Fixes #3250. R=rsc CC=golang-dev https://golang.org/cl/10757044
2013-07-11 14:39:39 -06:00
JNE 5(PC)
runtime: discard SIGPROF delivered to non-Go threads. Signal handlers are global resources but many language environments (Go, C++ at Google, etc) assume they have sole ownership of a particular handler. Signal handlers in mixed-language applications must therefore be robust against unexpected delivery of certain signals, such as SIGPROF. The default Go signal handler runtime·sigtramp assumes that it will never be called on a non-Go thread, but this assumption is violated by when linking in C++ code that spawns threads. Specifically, the handler asserts the thread has an associated "m" (Go scheduler). This CL is a very simple workaround: discard SIGPROF delivered to non-Go threads. runtime.badsignal(int32) now receives the signal number; if it returns without panicking (e.g. sig==SIGPROF) the signal is discarded. I don't think there is any really satisfactory solution to the problem of signal-based profiling in a mixed-language application. It's not only the issue of handler clobbering, but also that a C++ SIGPROF handler called in a Go thread can't unwind the Go stack (and vice versa). The best we can hope for is not crashing. Note: - I've ported this to all POSIX platforms, except ARM-linux which already ignores unexpected signals on m-less threads. - I've avoided tail-calling runtime.badsignal because AFAICT the 6a/6l don't support it. - I've avoided hoisting 'push sig' (common to both function calls) because it makes the code harder to read. - Fixed an (apparently incorrect?) docstring. R=iant, rsc, minux.ma CC=golang-dev https://golang.org/cl/6498057
2012-09-04 12:40:49 -06:00
MOVQ DI, 0(SP)
runtime: correctly handle signals received on foreign threads Fixes #3250. R=rsc CC=golang-dev https://golang.org/cl/10757044
2013-07-11 14:39:39 -06:00
MOVQ $runtime·badsignal(SB), AX
CALL AX
runtime: discard SIGPROF delivered to non-Go threads. Signal handlers are global resources but many language environments (Go, C++ at Google, etc) assume they have sole ownership of a particular handler. Signal handlers in mixed-language applications must therefore be robust against unexpected delivery of certain signals, such as SIGPROF. The default Go signal handler runtime·sigtramp assumes that it will never be called on a non-Go thread, but this assumption is violated by when linking in C++ code that spawns threads. Specifically, the handler asserts the thread has an associated "m" (Go scheduler). This CL is a very simple workaround: discard SIGPROF delivered to non-Go threads. runtime.badsignal(int32) now receives the signal number; if it returns without panicking (e.g. sig==SIGPROF) the signal is discarded. I don't think there is any really satisfactory solution to the problem of signal-based profiling in a mixed-language application. It's not only the issue of handler clobbering, but also that a C++ SIGPROF handler called in a Go thread can't unwind the Go stack (and vice versa). The best we can hope for is not crashing. Note: - I've ported this to all POSIX platforms, except ARM-linux which already ignores unexpected signals on m-less threads. - I've avoided tail-calling runtime.badsignal because AFAICT the 6a/6l don't support it. - I've avoided hoisting 'push sig' (common to both function calls) because it makes the code harder to read. - Fixed an (apparently incorrect?) docstring. R=iant, rsc, minux.ma CC=golang-dev https://golang.org/cl/6498057
2012-09-04 12:40:49 -06:00
RET
runtime: print error on receipt of signal on non-Go thread It's the best we can do before Go 1. For issue 3250; not a fix but at least less mysterious. R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/5797068
2012-03-12 13:55:18 -06:00
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
// save g
MOVQ R10, 40(SP)
// g = m->signal
all: remove 'extern register M *m' from runtime The runtime has historically held two dedicated values g (current goroutine) and m (current thread) in 'extern register' slots (TLS on x86, real registers backed by TLS on ARM). This CL removes the extern register m; code now uses g->m. On ARM, this frees up the register that formerly held m (R9). This is important for NaCl, because NaCl ARM code cannot use R9 at all. The Go 1 macrobenchmarks (those with per-op times >= 10 µs) are unaffected: BenchmarkBinaryTree17 5491374955 5471024381 -0.37% BenchmarkFannkuch11 4357101311 4275174828 -1.88% BenchmarkGobDecode 11029957 11364184 +3.03% BenchmarkGobEncode 6852205 6784822 -0.98% BenchmarkGzip 650795967 650152275 -0.10% BenchmarkGunzip 140962363 141041670 +0.06% BenchmarkHTTPClientServer 71581 73081 +2.10% BenchmarkJSONEncode 31928079 31913356 -0.05% BenchmarkJSONDecode 117470065 113689916 -3.22% BenchmarkMandelbrot200 6008923 5998712 -0.17% BenchmarkGoParse 6310917 6327487 +0.26% BenchmarkRegexpMatchMedium_1K 114568 114763 +0.17% BenchmarkRegexpMatchHard_1K 168977 169244 +0.16% BenchmarkRevcomp 935294971 914060918 -2.27% BenchmarkTemplate 145917123 148186096 +1.55% Minux previous reported larger variations, but these were caused by run-to-run noise, not repeatable slowdowns. Actual code changes by Minux. I only did the docs and the benchmarking. LGTM=dvyukov, iant, minux R=minux, josharian, iant, dave, bradfitz, dvyukov CC=golang-codereviews https://golang.org/cl/109050043
2014-06-26 09:54:39 -06:00
MOVQ g_m(R10), BP
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVQ m_gsignal(BP), BP
MOVQ BP, g(BX)
MOVQ DI, 0(SP)
MOVQ SI, 8(SP)
MOVQ DX, 16(SP)
MOVQ R10, 24(SP)
CALL runtime·sighandler(SB)
// restore g
get_tls(BX)
MOVQ 40(SP), R10
MOVQ R10, g(BX)
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·mmap(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ addr+0(FP), DI // arg 1 - addr
MOVQ n+8(FP), SI // arg 2 - len
MOVL prot+16(FP), DX // arg 3 - prot
MOVL flags+20(FP), R10 // arg 4 - flags
MOVL fd+24(FP), R8 // arg 5 - fd
MOVL off+28(FP), R9
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SUBQ $16, SP
MOVQ R9, 8(SP) // arg 7 - offset (passed on stack)
MOVQ $0, R9 // arg 6 - pad
MOVL $197, AX
SYSCALL
ADDQ $16, SP
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ AX, ret+32(FP)
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·munmap(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ addr+0(FP), DI // arg 1 - addr
MOVQ n+8(FP), SI // arg 2 - len
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVL $73, AX // sys_munmap
SYSCALL
JCC 2(PC)
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·madvise(SB),NOSPLIT,$0
runtime: implement SysUnused for openbsd R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6854079
2012-11-26 04:32:59 -07:00
MOVQ addr+0(FP), DI // arg 1 - addr
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ n+8(FP), SI // arg 2 - len
MOVL flags+16(FP), DX // arg 3 - behav
runtime: implement SysUnused for openbsd R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6854079
2012-11-26 04:32:59 -07:00
MOVQ $75, AX // sys_madvise
SYSCALL
runtime: ignore failure from madvise When we release memory to the OS, if the OS doesn't want us to release it (for example, because the program executed mlockall(MCL_FUTURE)), madvise will fail. Ignore the failure instead of crashing. Fixes #3435. R=ken2 CC=golang-dev https://golang.org/cl/6998052
2012-12-22 13:06:28 -07:00
// ignore failure - maybe pages are locked
runtime: implement SysUnused for openbsd R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6854079
2012-11-26 04:32:59 -07:00
RET
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
MOVQ new+8(SP), DI // arg 1 - nss
MOVQ old+16(SP), SI // arg 2 - oss
MOVQ $288, AX // sys_sigaltstack
SYSCALL
JCC 2(PC)
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
// set tls base to DI
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·settls(SB),NOSPLIT,$0
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
// adjust for ELF: wants to use -16(FS) and -8(FS) for g and m
ADDQ $16, DI
runtime: update openbsd runtime to use new tfork syscall Update OpenBSD runtime to use the new version of the sys___tfork syscall and switch TLS initialisation from sys_arch to sys___set_tcb (note that both of these syscalls are available in OpenBSD 5.2). R=golang-dev, minux.ma CC=golang-dev https://golang.org/cl/6843058
2012-11-21 07:25:53 -07:00
MOVQ $329, AX // sys___settcb
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
SYSCALL
JCC 2(PC)
runtime: update openbsd thread related syscalls to match kernel Update the threxit and thrsleep syscalls to match the ABI of the OpenBSD 5.1 kernel. These changes are backwards compatible with older kernels. Fixes #3311. R=golang-dev, rsc, devon.odell CC=golang-dev https://golang.org/cl/5777079
2012-04-11 06:02:08 -06:00
MOVL $0xf1, 0xf1 // crash
runtime: openbsd amd64 runtime support Add support for the go runtime on openbsd/amd64. This is based on the existing freebsd runtime. Threads are implemented using OpenBSD's rthreads, which are currently disabled by default, however can be enabled via the kern.rthreads sysctl. For now, cgo is disabled. R=rsc CC=golang-dev https://golang.org/cl/4815067
2011-08-08 07:56:38 -06:00
RET
runtime: set runtime ncpu on openbsd Set the runtime ncpu based on the hw.ncpu sysctl. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5191043
2011-10-05 11:16:43 -06:00
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·sysctl(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVQ mib+0(FP), DI // arg 1 - name
MOVL miblen+8(FP), SI // arg 2 - namelen
MOVQ out+16(FP), DX // arg 3 - oldp
MOVQ size+24(FP), R10 // arg 4 - oldlenp
MOVQ dst+32(FP), R8 // arg 5 - newp
MOVQ ndst+40(FP), R9 // arg 6 - newlen
runtime: set runtime ncpu on openbsd Set the runtime ncpu based on the hw.ncpu sysctl. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5191043
2011-10-05 11:16:43 -06:00
MOVQ $202, AX // sys___sysctl
SYSCALL
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
JCC 4(PC)
runtime: use 64-bit negative error code on 64-bit machines NEGL does a negation of the bottom 32 bits and then zero-extends to 64 bits, resulting in a negative 32-bit number but a positive 64-bit number. NEGQ does a full 64-bit negation, so that the result is negative both as a 32-bit and as a 64-bit number. This doesn't matter for the functions that are declared to return int32. It only matters for the ones that return int64 or void* [sic]. This will fix the current incorrect error in the OpenBSD/amd64 build. The build will still be broken, but it won't report a bogus error. R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/7536046
2013-03-14 21:42:11 -06:00
NEGQ AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+48(FP)
runtime: set runtime ncpu on openbsd Set the runtime ncpu based on the hw.ncpu sysctl. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5191043
2011-10-05 11:16:43 -06:00
RET
MOVL $0, AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+48(FP)
runtime: set runtime ncpu on openbsd Set the runtime ncpu based on the hw.ncpu sysctl. R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5191043
2011-10-05 11:16:43 -06:00
RET
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
// int32 runtime·kqueue(void);
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·kqueue(SB),NOSPLIT,$0
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
MOVQ $0, DI
MOVQ $0, SI
MOVQ $0, DX
MOVL $269, AX
SYSCALL
JCC 2(PC)
NEGQ AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+0(FP)
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout);
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·kevent(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL fd+0(FP), DI
MOVQ ev1+8(FP), SI
MOVL nev1+16(FP), DX
MOVQ ev2+24(FP), R10
MOVL nev2+32(FP), R8
MOVQ ts+40(FP), R9
runtime, syscall: update for openbsd system ABI break Update Go so that it continues to work past the OpenBSD system ABI break, with 64-bit time_t: http://www.openbsd.org/faq/current.html#20130813 Note: this makes OpenBSD 5.5 (currently 5.4-current) the minimum supported release for Go. Fixes #7049. R=golang-codereviews, mikioh.mikioh CC=golang-codereviews https://golang.org/cl/13368046
2014-01-11 01:00:32 -07:00
MOVL $72, AX
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
SYSCALL
JCC 2(PC)
NEGQ AX
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL AX, ret+48(FP)
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
RET
// void runtime·closeonexec(int32 fd);
runtime: convert .s textflags from numbers to symbolic constants. Remove NOPROF/DUPOK from everything. Edits done with a script, except pclinetest.asm which depended on the DUPOK flag on main(). R=golang-dev, bradfitz CC=golang-dev https://golang.org/cl/12613044
2013-08-07 13:20:05 -06:00
TEXT runtime·closeonexec(SB),NOSPLIT,$0
cmd/cc, runtime: convert C compilers to use Go calling convention To date, the C compilers and Go compilers differed only in how values were returned from functions. This made it difficult to call Go from C or C from Go if return values were involved. It also made assembly called from Go and assembly called from C different. This CL changes the C compiler to use the Go conventions, passing results on the stack, after the arguments. [Exception: this does not apply to C ... functions, because you can't know where on the stack the arguments end.] By doing this, the CL makes it possible to rewrite C functions into Go one at a time, without worrying about which languages call that function or which languages it calls. This CL also updates all the assembly files in package runtime to use the new conventions. Argument references of the form 40(SP) have been rewritten to the form name+10(FP) instead, and there are now Go func prototypes for every assembly function called from C or Go. This means that 'go vet runtime' checks effectively every assembly function, and go vet's output was used to automate the bulk of the conversion. Some functions, like seek and nsec on Plan 9, needed to be rewritten. Many assembly routines called from C were reading arguments incorrectly, using MOVL instead of MOVQ or vice versa, especially on the less used systems like openbsd. These were found by go vet and have been corrected too. If we're lucky, this may reduce flakiness on those systems. Tested on: darwin/386 darwin/amd64 linux/arm linux/386 linux/amd64 If this breaks another system, the bug is almost certainly in the sys_$GOOS_$GOARCH.s file, since the rest of the CL is tested by the combination of the above systems. LGTM=dvyukov, iant R=golang-codereviews, 0intro, dave, alex.brainman, dvyukov, iant CC=golang-codereviews, josharian, r https://golang.org/cl/135830043
2014-08-27 09:32:17 -06:00
MOVL fd+0(FP), DI // fd
runtime: integrated network poller for freebsd/amd64,386, openbsd/amd64,386 Update #5199 R=golang-dev, dvyukov CC=golang-dev https://golang.org/cl/8825043
2013-05-20 04:25:32 -06:00
MOVQ $2, SI // F_SETFD
MOVQ $1, DX // FD_CLOEXEC
MOVL $92, AX // fcntl
SYSCALL
RET
Copy Permalink