qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-20 04:14:49 -07:00
Code Releases Activity
ed09e0e2bf
go/src/runtime/rt0_linux_amd64.s

65 lines
1.6 KiB
ArmAsm
Raw Normal View History

goos and goarch SVN=121345
2008-06-05 17:54:34 -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.
runtime: use new #include "textflag.h" I did this just to clean things up, but it will be important when we drop the pkg directory later. LGTM=bradfitz R=r, bradfitz CC=golang-codereviews https://golang.org/cl/132600043
2014-09-04 21:05:18 -06:00
#include "textflag.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
TEXT _rt0_amd64_linux(SB),NOSPLIT,$-8
runtime: change amd64 startup convention Now the default startup is that the program begins at _rt0_amd64_$GOOS, which sets DI = argc, SI = argv and jumps to _rt0_amd64. This makes the _rt0_amd64 entry match the expected semantics for the standard C "main" function, which we can now provide for use when linking against a standard C library. R=golang-dev, devon.odell, minux.ma CC=golang-dev https://golang.org/cl/7525043
2013-03-06 13:03:04 -07:00
LEAQ 8(SP), SI // argv
MOVQ 0(SP), DI // argc
MOVQ $main(SB), AX
JMP AX
runtime: shared library init support for android/arm. Follows http://golang.org/cl/8454, a similar CL for arm architectures. This CL involves android-specific changes, namely, synthesizing argv/auxv, as android doesn't provide those to the init functions. This code is based on crawshaw@ android code in golang.org/x/mobile. Change-Id: I32364efbb2662e80270a99bd7dfb1d0421b5417d Reviewed-on: https://go-review.googlesource.com/8457 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-03 10:48:51 -06:00
// When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded.
runtime: merge clone0 and clone We initially added clone0 to handle the case when G or M don't exist, but it turns out that we could have just modified clone. (It also helps that the function we're invoking in clone0 no longer needs arguments.) As a side-effect, newosproc0 is now supported on all linux archs. Change-Id: Ie603af75d8f164310fc16446052d83743961f3ca Reviewed-on: https://go-review.googlesource.com/9164 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-17 18:27:07 -06:00
TEXT _rt0_amd64_linux_lib(SB),NOSPLIT,$0x40
MOVQ BX, 0x10(SP)
MOVQ BP, 0x18(SP)
MOVQ R12, 0x20(SP)
MOVQ R13, 0x28(SP)
MOVQ R14, 0x30(SP)
MOVQ R15, 0x38(SP)
runtime: save registers in linux/{386,amd64} lib entry point The callee-saved registers must be saved because for the c-shared case this code is invoked from C code in the system library, and that code expects the registers to be saved. The tests were passing because in the normal case the code calls a cgo function that naturally saves callee-saved registers anyhow. However, it fails when the code takes the non-cgo path. Change-Id: I9c1f5e884f5a72db9614478049b1863641c8b2b9 Reviewed-on: https://go-review.googlesource.com/9114 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-20 11:32:39 -06:00
runtime: initialize shared library at library-load time This is Part 2 of the change, see Part 1 here: in https://go-review.googlesource.com/#/c/7692/ Suggested by iant@, we use the library initialization entry point to: - create a new OS thread and run the "regular" runtime init stack on that thread - return immediately from the main (i.e., loader) thread - at the first CGO invocation, we wait for the runtime initialization to complete. The above mechanism is implemented only on linux_amd64. Next step is to support it on linux_arm. Other platforms don't yet support shared library compiling/linking, but we intend to use the same strategy there as well. Change-Id: Ib2c81b1b83bee837134084b75a3beecfb8de6bf4 Reviewed-on: https://go-review.googlesource.com/8094 Run-TryBot: Srdjan Petrovic <spetrovic@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-25 18:50:35 -06:00
MOVQ DI, _rt0_amd64_linux_lib_argc<>(SB)
MOVQ SI, _rt0_amd64_linux_lib_argv<>(SB)
// Create a new thread to do the runtime initialization and return.
MOVQ _cgo_sys_thread_create(SB), AX
TESTQ AX, AX
JZ nocgo
MOVQ $_rt0_amd64_linux_lib_go(SB), DI
MOVQ $0, SI
CALL AX
runtime: save registers in linux/{386,amd64} lib entry point The callee-saved registers must be saved because for the c-shared case this code is invoked from C code in the system library, and that code expects the registers to be saved. The tests were passing because in the normal case the code calls a cgo function that naturally saves callee-saved registers anyhow. However, it fails when the code takes the non-cgo path. Change-Id: I9c1f5e884f5a72db9614478049b1863641c8b2b9 Reviewed-on: https://go-review.googlesource.com/9114 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-20 11:32:39 -06:00
JMP restore
runtime: initialize shared library at library-load time This is Part 2 of the change, see Part 1 here: in https://go-review.googlesource.com/#/c/7692/ Suggested by iant@, we use the library initialization entry point to: - create a new OS thread and run the "regular" runtime init stack on that thread - return immediately from the main (i.e., loader) thread - at the first CGO invocation, we wait for the runtime initialization to complete. The above mechanism is implemented only on linux_amd64. Next step is to support it on linux_arm. Other platforms don't yet support shared library compiling/linking, but we intend to use the same strategy there as well. Change-Id: Ib2c81b1b83bee837134084b75a3beecfb8de6bf4 Reviewed-on: https://go-review.googlesource.com/8094 Run-TryBot: Srdjan Petrovic <spetrovic@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-25 18:50:35 -06:00
nocgo:
MOVQ $8388608, 0(SP) // stacksize
MOVQ $_rt0_amd64_linux_lib_go(SB), AX
MOVQ AX, 8(SP) // fn
MOVQ $runtime·newosproc0(SB), AX
CALL AX
runtime: save registers in linux/{386,amd64} lib entry point The callee-saved registers must be saved because for the c-shared case this code is invoked from C code in the system library, and that code expects the registers to be saved. The tests were passing because in the normal case the code calls a cgo function that naturally saves callee-saved registers anyhow. However, it fails when the code takes the non-cgo path. Change-Id: I9c1f5e884f5a72db9614478049b1863641c8b2b9 Reviewed-on: https://go-review.googlesource.com/9114 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-20 11:32:39 -06:00
restore:
runtime: merge clone0 and clone We initially added clone0 to handle the case when G or M don't exist, but it turns out that we could have just modified clone. (It also helps that the function we're invoking in clone0 no longer needs arguments.) As a side-effect, newosproc0 is now supported on all linux archs. Change-Id: Ie603af75d8f164310fc16446052d83743961f3ca Reviewed-on: https://go-review.googlesource.com/9164 Reviewed-by: David Crawshaw <crawshaw@golang.org>
2015-04-17 18:27:07 -06:00
MOVQ 0x10(SP), BX
MOVQ 0x18(SP), BP
MOVQ 0x20(SP), R12
MOVQ 0x28(SP), R13
MOVQ 0x30(SP), R14
MOVQ 0x38(SP), R15
cmd: linker changes for shared library initialization Suggested by iant@, this change: - looks for a symbol _rt0_<GOARCH>_<GOOS>_lib, - if the symbol is present, adds a new entry into the .init_array ELF section that points to the symbol. The end-effect is that the symbol _rt0_<GOARCH>_<GOOS>_lib will be invoked as soon as the (ELF) shared library is loaded, which will in turn initialize the runtime. (To be implemented.) Change-Id: I99911a180215a6df18f8a18483d12b9b497b48f4 Reviewed-on: https://go-review.googlesource.com/7692 TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-17 10:47:01 -06:00
RET
runtime: initialize shared library at library-load time This is Part 2 of the change, see Part 1 here: in https://go-review.googlesource.com/#/c/7692/ Suggested by iant@, we use the library initialization entry point to: - create a new OS thread and run the "regular" runtime init stack on that thread - return immediately from the main (i.e., loader) thread - at the first CGO invocation, we wait for the runtime initialization to complete. The above mechanism is implemented only on linux_amd64. Next step is to support it on linux_arm. Other platforms don't yet support shared library compiling/linking, but we intend to use the same strategy there as well. Change-Id: Ib2c81b1b83bee837134084b75a3beecfb8de6bf4 Reviewed-on: https://go-review.googlesource.com/8094 Run-TryBot: Srdjan Petrovic <spetrovic@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2015-03-25 18:50:35 -06:00
TEXT _rt0_amd64_linux_lib_go(SB),NOSPLIT,$0
MOVQ _rt0_amd64_linux_lib_argc<>(SB), DI
MOVQ _rt0_amd64_linux_lib_argv<>(SB), SI
MOVQ $runtime·rt0_go(SB), AX
JMP AX
DATA _rt0_amd64_linux_lib_argc<>(SB)/8, $0
GLOBL _rt0_amd64_linux_lib_argc<>(SB),NOPTR, $8
DATA _rt0_amd64_linux_lib_argv<>(SB)/8, $0
GLOBL _rt0_amd64_linux_lib_argv<>(SB),NOPTR, $8
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 main(SB),NOSPLIT,$-8
runtime: convert a few traceback-related functions from proc.c to traceback.go They were in proc.c mainly because there was no portable traceback source file. As part of converting them to Go, move to traceback.go. In order to get access to the PC of _rt0_go, rename to runtime.rt0_go. LGTM=r R=golang-codereviews, r CC=dvyukov, golang-codereviews, iant, khr https://golang.org/cl/139110043
2014-09-03 09:11:16 -06:00
MOVQ $runtime·rt0_go(SB), AX
Break runtime.c into separate pieces for maps, strings, print, etc. Share common assembler for amd64 runtime SVN=125317
2008-06-30 12:50:36 -06:00
JMP AX
Copy Permalink