qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-19 15:05:00 -07:00
Code Releases Activity
c5da34eabe
go/src/pkg/runtime/sys_plan9_386.s

127 lines
2.0 KiB
ArmAsm
Raw Normal View History

8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
runtime: make more build-friendly Collapse the arch,os-specific directories into the main directory by renaming xxx/foo.c to foo_xxx.c, and so on. There are no substantial edits here, except to the Makefile. The assumption is that the Go tool will #define GOOS_darwin and GOARCH_amd64 and will make any file named something like signals_darwin.h available as signals_GOOS.h during the build. This replaces what used to be done with -I$(GOOS). There is still work to be done to make runtime build with standard tools, but this is a big step. After this we will have to write a script to generate all the generated files so they can be checked in (instead of generated during the build). R=r, iant, r, lucio.dere CC=golang-dev https://golang.org/cl/5490053
2011-12-16 13:33:58 -07:00
#include "defs_GOOS_GOARCH.h"
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"
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
// setldt(int entry, int address, int limit)
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·setldt(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
RET
runtime: fix Plan 9 "lingering goroutines bug". R=rsc, r CC=golang-dev https://golang.org/cl/4589042
2011-06-10 01:23:54 -06:00
TEXT runtime·open(SB),7,$0
MOVL $14, AX
INT $64
RET
runtime: add nanotime for Plan 9 R=paulzhol, rsc, dave, rminnich CC=golang-dev https://golang.org/cl/5327063
2011-11-17 20:09:28 -07:00
TEXT runtime·pread(SB),7,$0
MOVL $50, AX
INT $64
runtime: fix Plan 9 build This change adds the osyield and usleep functions and code to read the number of processors from /dev/sysstat. I also changed SysAlloc to return nil when brk fails (it was returning -1). R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5177049
2011-10-05 10:07:44 -06:00
RET
runtime: add nanotime for Plan 9 R=paulzhol, rsc, dave, rminnich CC=golang-dev https://golang.org/cl/5327063
2011-11-17 20:09:28 -07:00
TEXT runtime·pwrite(SB),7,$0
MOVL $51, AX
INT $64
runtime: fix Plan 9 build This change adds the osyield and usleep functions and code to read the number of processors from /dev/sysstat. I also changed SysAlloc to return nil when brk fails (it was returning -1). R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5177049
2011-10-05 10:07:44 -06:00
RET
runtime: implement getenv for Plan 9 With this change the runtime can now read GOMAXPROCS, GOGC, etc. I'm not quite sure how we missed this. R=seed, lucio.dere, rsc CC=golang-dev https://golang.org/cl/6935062
2012-12-17 09:07:40 -07:00
TEXT runtime·seek(SB),7,$0
MOVL $39, AX
INT $64
CMPL AX, $-1
JNE 4(PC)
MOVL a+0(FP), CX
MOVL AX, 0(CX)
MOVL AX, 4(CX)
RET
runtime: fix Plan 9 build This change adds the osyield and usleep functions and code to read the number of processors from /dev/sysstat. I also changed SysAlloc to return nil when brk fails (it was returning -1). R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5177049
2011-10-05 10:07:44 -06:00
TEXT runtime·close(SB),7,$0
MOVL $4, AX
runtime: implement getenv for Plan 9 With this change the runtime can now read GOMAXPROCS, GOGC, etc. I'm not quite sure how we missed this. R=seed, lucio.dere, rsc CC=golang-dev https://golang.org/cl/6935062
2012-12-17 09:07:40 -07:00
INT $64
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
RET
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·exits(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL $8, AX
INT $64
RET
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·brk_(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL $24, AX
INT $64
RET
runtime: fix Plan 9 build This change adds the osyield and usleep functions and code to read the number of processors from /dev/sysstat. I also changed SysAlloc to return nil when brk fails (it was returning -1). R=golang-dev, rsc CC=golang-dev https://golang.org/cl/5177049
2011-10-05 10:07:44 -06:00
TEXT runtime·sleep(SB),7,$0
MOVL $17, AX
INT $64
RET
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·plan9_semacquire(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL $37, AX
INT $64
RET
pkg/runtime: Plan 9 signal handling in Go This adds proper note handling for Plan 9, and fixes the issue of properly killing go procs. Without this change, the first go proc that dies (using runtime·exit()) would kill all the running go procs. Proper signal handling is needed. R=golang-dev, ality, rminnich, rsc CC=golang-dev, john, mirtchovski https://golang.org/cl/5617048
2012-05-04 04:48:34 -06:00
pkg/runtime: Fix semasleep on Plan 9 With the timed semacquire patch (kernel-tsemacquire) for Plan 9, we can now properly do a timed wait for the semaphore, in semasleep. R=golang-dev, rsc, rminnich, ality, r CC=0intro, golang-dev, john, mirtchovski https://golang.org/cl/6197046
2012-05-16 16:09:28 -06:00
TEXT runtime·plan9_tsemacquire(SB),7,$0
MOVL $52, AX
INT $64
RET
pkg/runtime: Plan 9 signal handling in Go This adds proper note handling for Plan 9, and fixes the issue of properly killing go procs. Without this change, the first go proc that dies (using runtime·exit()) would kill all the running go procs. Proper signal handling is needed. R=golang-dev, ality, rminnich, rsc CC=golang-dev, john, mirtchovski https://golang.org/cl/5617048
2012-05-04 04:48:34 -06:00
TEXT runtime·notify(SB),7,$0
MOVL $28, AX
INT $64
RET
TEXT runtime·noted(SB),7,$0
MOVL $29, AX
INT $64
RET
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·plan9_semrelease(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL $38, AX
INT $64
RET
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
TEXT runtime·rfork(SB),7,$0
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL $19, AX // rfork
INT $64
// In parent, return.
CMPL AX, $0
JEQ 2(PC)
RET
// In child on old stack.
MOVL mm+12(SP), BX // m
MOVL gg+16(SP), DX // g
MOVL fn+20(SP), SI // fn
// set SP to be on the new child stack
MOVL stack+8(SP), CX
MOVL CX, SP
// Initialize m, g.
get_tls(AX)
MOVL DX, g(AX)
MOVL BX, m(AX)
// Initialize AX from _tos->pid
8l, runtime: place G and M pointers relative to _tos on Plan 9, instead of hardcoded values for USTKTOP. This should allow executing both on native Plan 9 and inside 9vx. R=rsc CC=golang-dev https://golang.org/cl/3993044
2011-02-11 11:39:05 -07:00
MOVL _tos(SB), AX
MOVL tos_pid(AX), AX
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL AX, m_procid(BX) // save pid as m->procid
8l, runtime: place G and M pointers relative to _tos on Plan 9, instead of hardcoded values for USTKTOP. This should allow executing both on native Plan 9 and inside 9vx. R=rsc CC=golang-dev https://golang.org/cl/3993044
2011-02-11 11:39:05 -07:00
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
CALL runtime·stackcheck(SB) // smashes AX, CX
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
MOVL 0(DX), DX // paranoia; check they are not nil
MOVL 0(BX), BX
// more paranoia; check that stack splitting code works
runtime: add nanotime for Plan 9 R=paulzhol, rsc, dave, rminnich CC=golang-dev https://golang.org/cl/5327063
2011-11-17 20:09:28 -07:00
PUSHL SI
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
CALL runtime·emptyfunc(SB)
runtime: add nanotime for Plan 9 R=paulzhol, rsc, dave, rminnich CC=golang-dev https://golang.org/cl/5327063
2011-11-17 20:09:28 -07:00
POPL SI
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
CALL SI // fn()
runtime: ,s/[a-zA-Z0-9_]+/runtime·&/g, almost Prefix all external symbols in runtime by runtime·, to avoid conflicts with possible symbols of the same name in linked-in C libraries. The obvious conflicts are printf, malloc, and free, but hide everything to avoid future pain. The symbols left alone are: ** known to cgo ** _cgo_free _cgo_malloc libcgo_thread_start initcgo ncgocall ** known to linker ** _rt0_$GOARCH _rt0_$GOARCH_$GOOS text etext data end pclntab epclntab symtab esymtab ** known to C compiler ** _divv _modv _div64by32 etc (arch specific) Tested on darwin/386, darwin/amd64, linux/386, linux/amd64. Built (but not tested) for freebsd/386, freebsd/amd64, linux/arm, windows/386. R=r, PeterGo CC=golang-dev https://golang.org/cl/2899041
2010-11-04 12:00:19 -06:00
CALL runtime·exit(SB)
8l, runtime: initial support for Plan 9 No multiple processes/locks, managed to compile and run a hello.go (with print not fmt). Also test/sieve.go seems to run until 439 and stops with a 'throw: all goroutines are asleep - deadlock!' - just like runtime/tiny. based on Russ's suggestions at: http://groups.google.com/group/comp.os.plan9/browse_thread/thread/cfda8b82535d2d68/243777a597ec1612 Build instructions: cd src/pkg/runtime make clean && GOOS=plan9 make install this will build and install the runtime. When linking with 8l, you should pass -s to suppress symbol generation in the a.out, otherwise the generated executable will not run. This is runtime only, the porting of the toolchain has already been done: http://code.google.com/p/go-plan9/source/browse in the plan9-quanstro branch. R=rsc CC=golang-dev https://golang.org/cl/2273041
2010-10-18 10:32:55 -06:00
RET
runtime: mask SSE exceptions on plan9/amd64 The Go run-time assumes that all SSE floating-point exceptions are masked so that Go programs are not broken by such invalid operations. By default, the 64-bit version of the Plan 9 kernel masks only some SSE floating-point exceptions. Here, we mask them all on a per-thread basis. R=rsc, rminnich, minux.ma CC=golang-dev https://golang.org/cl/6592056
2012-10-05 14:23:30 -06:00
// Only used by the 64-bit runtime.
TEXT runtime·setfpmasks(SB),7,$0
RET
Copy Permalink