This repository has been archived by the owner on Dec 5, 2019. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 15
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
- Loading branch information
Showing
213 changed files
with
11,665 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
|
@@ -20,3 +20,4 @@ go: | |
- 1.8.1 | ||
- 1.8.2 | ||
- 1.8.3 | ||
- 1.9 |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,44 @@ | ||
// Copyright 2014 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. | ||
|
||
package runtime | ||
|
||
import ( | ||
"github.com/huandu/goroutine/hack/go1_9/runtime/internal/sys" | ||
"unsafe" | ||
) | ||
|
||
const ( | ||
c0 = uintptr((8-sys.PtrSize)/4*2860486313 + (sys.PtrSize-4)/4*33054211828000289) | ||
c1 = uintptr((8-sys.PtrSize)/4*3267000013 + (sys.PtrSize-4)/4*23344194077549503) | ||
) | ||
|
||
// type algorithms - known to compiler | ||
const ( | ||
alg_NOEQ = iota | ||
alg_MEM0 | ||
alg_MEM8 | ||
alg_MEM16 | ||
alg_MEM32 | ||
alg_MEM64 | ||
alg_MEM128 | ||
alg_STRING | ||
alg_INTER | ||
alg_NILINTER | ||
alg_FLOAT32 | ||
alg_FLOAT64 | ||
alg_CPLX64 | ||
alg_CPLX128 | ||
alg_max | ||
) | ||
|
||
// typeAlg is also copied/used in reflect/type.go. | ||
// keep them in sync. | ||
type typeAlg struct { | ||
hash func(unsafe.Pointer, uintptr) uintptr | ||
|
||
equal func(unsafe.Pointer, unsafe.Pointer) bool | ||
} | ||
|
||
const hashRandomBytes = sys.PtrSize / 4 * 64 |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,87 @@ | ||
// 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. | ||
|
||
// Cgo call and callback support. | ||
// | ||
// To call into the C function f from Go, the cgo-generated code calls | ||
// runtime.cgocall(_cgo_Cfunc_f, frame), where _cgo_Cfunc_f is a | ||
// gcc-compiled function written by cgo. | ||
// | ||
// runtime.cgocall (below) locks g to m, calls entersyscall | ||
// so as not to block other goroutines or the garbage collector, | ||
// and then calls runtime.asmcgocall(_cgo_Cfunc_f, frame). | ||
// | ||
// runtime.asmcgocall (in asm_$GOARCH.s) switches to the m->g0 stack | ||
// (assumed to be an operating system-allocated stack, so safe to run | ||
// gcc-compiled code on) and calls _cgo_Cfunc_f(frame). | ||
// | ||
// _cgo_Cfunc_f invokes the actual C function f with arguments | ||
// taken from the frame structure, records the results in the frame, | ||
// and returns to runtime.asmcgocall. | ||
// | ||
// After it regains control, runtime.asmcgocall switches back to the | ||
// original g (m->curg)'s stack and returns to runtime.cgocall. | ||
// | ||
// After it regains control, runtime.cgocall calls exitsyscall, which blocks | ||
// until this m can run Go code without violating the $GOMAXPROCS limit, | ||
// and then unlocks g from m. | ||
// | ||
// The above description skipped over the possibility of the gcc-compiled | ||
// function f calling back into Go. If that happens, we continue down | ||
// the rabbit hole during the execution of f. | ||
// | ||
// To make it possible for gcc-compiled C code to call a Go function p.GoF, | ||
// cgo writes a gcc-compiled function named GoF (not p.GoF, since gcc doesn't | ||
// know about packages). The gcc-compiled C function f calls GoF. | ||
// | ||
// GoF calls crosscall2(_cgoexp_GoF, frame, framesize). Crosscall2 | ||
// (in cgo/gcc_$GOARCH.S, a gcc-compiled assembly file) is a two-argument | ||
// adapter from the gcc function call ABI to the 6c function call ABI. | ||
// It is called from gcc to call 6c functions. In this case it calls | ||
// _cgoexp_GoF(frame, framesize), still running on m->g0's stack | ||
// and outside the $GOMAXPROCS limit. Thus, this code cannot yet | ||
// call arbitrary Go code directly and must be careful not to allocate | ||
// memory or use up m->g0's stack. | ||
// | ||
// _cgoexp_GoF calls runtime.cgocallback(p.GoF, frame, framesize, ctxt). | ||
// (The reason for having _cgoexp_GoF instead of writing a crosscall3 | ||
// to make this call directly is that _cgoexp_GoF, because it is compiled | ||
// with 6c instead of gcc, can refer to dotted names like | ||
// runtime.cgocallback and p.GoF.) | ||
// | ||
// runtime.cgocallback (in asm_$GOARCH.s) switches from m->g0's | ||
// stack to the original g (m->curg)'s stack, on which it calls | ||
// runtime.cgocallbackg(p.GoF, frame, framesize). | ||
// As part of the stack switch, runtime.cgocallback saves the current | ||
// SP as m->g0->sched.sp, so that any use of m->g0's stack during the | ||
// execution of the callback will be done below the existing stack frames. | ||
// Before overwriting m->g0->sched.sp, it pushes the old value on the | ||
// m->g0 stack, so that it can be restored later. | ||
// | ||
// runtime.cgocallbackg (below) is now running on a real goroutine | ||
// stack (not an m->g0 stack). First it calls runtime.exitsyscall, which will | ||
// block until the $GOMAXPROCS limit allows running this goroutine. | ||
// Once exitsyscall has returned, it is safe to do things like call the memory | ||
// allocator or invoke the Go callback function p.GoF. runtime.cgocallbackg | ||
// first defers a function to unwind m->g0.sched.sp, so that if p.GoF | ||
// panics, m->g0.sched.sp will be restored to its old value: the m->g0 stack | ||
// and the m->curg stack will be unwound in lock step. | ||
// Then it calls p.GoF. Finally it pops but does not execute the deferred | ||
// function, calls runtime.entersyscall, and returns to runtime.cgocallback. | ||
// | ||
// After it regains control, runtime.cgocallback switches back to | ||
// m->g0's stack (the pointer is still in m->g0.sched.sp), restores the old | ||
// m->g0.sched.sp value from the stack, and returns to _cgoexp_GoF. | ||
// | ||
// _cgoexp_GoF immediately returns to crosscall2, which restores the | ||
// callee-save registers for gcc and returns to GoF, which returns to f. | ||
|
||
package runtime | ||
|
||
// Addresses collected in a cgo backtrace when crashing. | ||
// Length must match arg.Max in x_cgo_callers in runtime/cgo/gcc_traceback.c. | ||
type cgoCallers [32]uintptr | ||
|
||
const cgoCheckPointerFail = "cgo argument has Go pointer to Go pointer" | ||
const cgoResultFail = "cgo result has Go pointer" |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,10 @@ | ||
// Copyright 2015 The Go Authors. All rights reserved. | ||
// Use of this source code is governed by a BSD-style | ||
// license that can be found in the LICENSE file. | ||
|
||
// Code to check that pointer writes follow the cgo rules. | ||
// These functions are invoked via the write barrier when debug.cgocheck > 1. | ||
|
||
package runtime | ||
|
||
const cgoWriteBarrierFail = "Go pointer stored into non-Go memory" |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,35 @@ | ||
// Copyright 2014 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. | ||
|
||
package runtime | ||
|
||
import ( | ||
"unsafe" | ||
) | ||
|
||
const ( | ||
maxAlign = 8 | ||
hchanSize = unsafe.Sizeof(hchan{}) + uintptr(-int(unsafe.Sizeof(hchan{}))&(maxAlign-1)) | ||
debugChan = false | ||
) | ||
|
||
type hchan struct { | ||
qcount uint | ||
dataqsiz uint | ||
buf unsafe.Pointer | ||
elemsize uint16 | ||
closed uint32 | ||
elemtype *_type | ||
sendx uint | ||
recvx uint | ||
recvq waitq | ||
sendq waitq | ||
|
||
lock mutex | ||
} | ||
|
||
type waitq struct { | ||
first *sudog | ||
last *sudog | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,13 @@ | ||
// Copyright 2012 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. | ||
|
||
package runtime | ||
|
||
// Compiler is the name of the compiler toolchain that built the | ||
// running binary. Known toolchains are: | ||
// | ||
// gc Also known as cmd/compile. | ||
// gccgo The gccgo front end, part of the GCC compiler suite. | ||
// | ||
const Compiler = "gc" |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,25 @@ | ||
// Copyright 2011 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. | ||
|
||
// CPU profiling. | ||
// | ||
// The signal handler for the profiling clock tick adds a new stack trace | ||
// to a log of recent traces. The log is read by a user goroutine that | ||
// turns it into formatted profile data. If the reader does not keep up | ||
// with the log, those writes will be recorded as a count of lost records. | ||
// The actual profile buffer is in profbuf.go. | ||
|
||
package runtime | ||
|
||
const maxCPUProfStack = 64 | ||
|
||
type cpuProfile struct { | ||
lock mutex | ||
on bool | ||
log *profBuf | ||
|
||
extra [1000]uintptr | ||
numExtra int | ||
lostExtra uint64 | ||
} |
Oops, something went wrong.