github.com/MangoDowner/go-gm@v0.0.0-20180818020936-8baa2bd4408c/src/runtime/stubs.go (about) 1 // Copyright 2014 The Go Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package runtime 6 7 import ( 8 "runtime/internal/sys" 9 "unsafe" 10 ) 11 12 // Should be a built-in for unsafe.Pointer? 13 //go:nosplit 14 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer { 15 return unsafe.Pointer(uintptr(p) + x) 16 } 17 18 // getg returns the pointer to the current g. 19 // The compiler rewrites calls to this function into instructions 20 // that fetch the g directly (from TLS or from the dedicated register). 21 func getg() *g 22 23 // mcall switches from the g to the g0 stack and invokes fn(g), 24 // where g is the goroutine that made the call. 25 // mcall saves g's current PC/SP in g->sched so that it can be restored later. 26 // It is up to fn to arrange for that later execution, typically by recording 27 // g in a data structure, causing something to call ready(g) later. 28 // mcall returns to the original goroutine g later, when g has been rescheduled. 29 // fn must not return at all; typically it ends by calling schedule, to let the m 30 // run other goroutines. 31 // 32 // mcall can only be called from g stacks (not g0, not gsignal). 33 // 34 // This must NOT be go:noescape: if fn is a stack-allocated closure, 35 // fn puts g on a run queue, and g executes before fn returns, the 36 // closure will be invalidated while it is still executing. 37 func mcall(fn func(*g)) 38 39 // systemstack runs fn on a system stack. 40 // If systemstack is called from the per-OS-thread (g0) stack, or 41 // if systemstack is called from the signal handling (gsignal) stack, 42 // systemstack calls fn directly and returns. 43 // Otherwise, systemstack is being called from the limited stack 44 // of an ordinary goroutine. In this case, systemstack switches 45 // to the per-OS-thread stack, calls fn, and switches back. 46 // It is common to use a func literal as the argument, in order 47 // to share inputs and outputs with the code around the call 48 // to system stack: 49 // 50 // ... set up y ... 51 // systemstack(func() { 52 // x = bigcall(y) 53 // }) 54 // ... use x ... 55 // 56 //go:noescape 57 func systemstack(fn func()) 58 59 func badsystemstack() { 60 throw("systemstack called from unexpected goroutine") 61 } 62 63 // memclrNoHeapPointers clears n bytes starting at ptr. 64 // 65 // Usually you should use typedmemclr. memclrNoHeapPointers should be 66 // used only when the caller knows that *ptr contains no heap pointers 67 // because either: 68 // 69 // 1. *ptr is initialized memory and its type is pointer-free. 70 // 71 // 2. *ptr is uninitialized memory (e.g., memory that's being reused 72 // for a new allocation) and hence contains only "junk". 73 // 74 // in memclr_*.s 75 //go:noescape 76 func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) 77 78 //go:linkname reflect_memclrNoHeapPointers reflect.memclrNoHeapPointers 79 func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) { 80 memclrNoHeapPointers(ptr, n) 81 } 82 83 // memmove copies n bytes from "from" to "to". 84 // in memmove_*.s 85 //go:noescape 86 func memmove(to, from unsafe.Pointer, n uintptr) 87 88 //go:linkname reflect_memmove reflect.memmove 89 func reflect_memmove(to, from unsafe.Pointer, n uintptr) { 90 memmove(to, from, n) 91 } 92 93 // exported value for testing 94 var hashLoad = loadFactor 95 96 //go:nosplit 97 func fastrand() uint32 { 98 mp := getg().m 99 fr := mp.fastrand 100 mx := uint32(int32(fr)>>31) & 0xa8888eef 101 fr = fr<<1 ^ mx 102 mp.fastrand = fr 103 return fr 104 } 105 106 //go:nosplit 107 func fastrandn(n uint32) uint32 { 108 // Don't be clever. 109 // fastrand is not good enough for cleverness. 110 // Just use mod. 111 // See golang.org/issue/21806. 112 return fastrand() % n 113 } 114 115 //go:linkname sync_fastrand sync.fastrand 116 func sync_fastrand() uint32 { return fastrand() } 117 118 // in asm_*.s 119 //go:noescape 120 func memequal(a, b unsafe.Pointer, size uintptr) bool 121 122 // noescape hides a pointer from escape analysis. noescape is 123 // the identity function but escape analysis doesn't think the 124 // output depends on the input. noescape is inlined and currently 125 // compiles down to zero instructions. 126 // USE CAREFULLY! 127 //go:nosplit 128 func noescape(p unsafe.Pointer) unsafe.Pointer { 129 x := uintptr(p) 130 return unsafe.Pointer(x ^ 0) 131 } 132 133 func cgocallback(fn, frame unsafe.Pointer, framesize, ctxt uintptr) 134 func gogo(buf *gobuf) 135 func gosave(buf *gobuf) 136 func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32 137 138 //go:noescape 139 func jmpdefer(fv *funcval, argp uintptr) 140 func exit1(code int32) 141 func asminit() 142 func setg(gg *g) 143 func breakpoint() 144 145 // reflectcall calls fn with a copy of the n argument bytes pointed at by arg. 146 // After fn returns, reflectcall copies n-retoffset result bytes 147 // back into arg+retoffset before returning. If copying result bytes back, 148 // the caller should pass the argument frame type as argtype, so that 149 // call can execute appropriate write barriers during the copy. 150 // Package reflect passes a frame type. In package runtime, there is only 151 // one call that copies results back, in cgocallbackg1, and it does NOT pass a 152 // frame type, meaning there are no write barriers invoked. See that call 153 // site for justification. 154 func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32) 155 156 func procyield(cycles uint32) 157 158 type neverCallThisFunction struct{} 159 160 // goexit is the return stub at the top of every goroutine call stack. 161 // Each goroutine stack is constructed as if goexit called the 162 // goroutine's entry point function, so that when the entry point 163 // function returns, it will return to goexit, which will call goexit1 164 // to perform the actual exit. 165 // 166 // This function must never be called directly. Call goexit1 instead. 167 // gentraceback assumes that goexit terminates the stack. A direct 168 // call on the stack will cause gentraceback to stop walking the stack 169 // prematurely and if there is leftover state it may panic. 170 func goexit(neverCallThisFunction) 171 172 // Not all cgocallback_gofunc frames are actually cgocallback_gofunc, 173 // so not all have these arguments. Mark them uintptr so that the GC 174 // does not misinterpret memory when the arguments are not present. 175 // cgocallback_gofunc is not called from go, only from cgocallback, 176 // so the arguments will be found via cgocallback's pointer-declared arguments. 177 // See the assembly implementations for more details. 178 func cgocallback_gofunc(fv uintptr, frame uintptr, framesize, ctxt uintptr) 179 180 // publicationBarrier performs a store/store barrier (a "publication" 181 // or "export" barrier). Some form of synchronization is required 182 // between initializing an object and making that object accessible to 183 // another processor. Without synchronization, the initialization 184 // writes and the "publication" write may be reordered, allowing the 185 // other processor to follow the pointer and observe an uninitialized 186 // object. In general, higher-level synchronization should be used, 187 // such as locking or an atomic pointer write. publicationBarrier is 188 // for when those aren't an option, such as in the implementation of 189 // the memory manager. 190 // 191 // There's no corresponding barrier for the read side because the read 192 // side naturally has a data dependency order. All architectures that 193 // Go supports or seems likely to ever support automatically enforce 194 // data dependency ordering. 195 func publicationBarrier() 196 197 // getcallerpc returns the program counter (PC) of its caller's caller. 198 // getcallersp returns the stack pointer (SP) of its caller's caller. 199 // For both, the argp must be a pointer to the caller's first function argument. 200 // The implementation may or may not use argp, depending on 201 // the architecture. 202 // 203 // For example: 204 // 205 // func f(arg1, arg2, arg3 int) { 206 // pc := getcallerpc(unsafe.Pointer(&arg1)) 207 // sp := getcallersp(unsafe.Pointer(&arg1)) 208 // } 209 // 210 // These two lines find the PC and SP immediately following 211 // the call to f (where f will return). 212 // 213 // The call to getcallerpc and getcallersp must be done in the 214 // frame being asked about. It would not be correct for f to pass &arg1 215 // to another function g and let g call getcallerpc/getcallersp. 216 // The call inside g might return information about g's caller or 217 // information about f's caller or complete garbage. 218 // 219 // The result of getcallersp is correct at the time of the return, 220 // but it may be invalidated by any subsequent call to a function 221 // that might relocate the stack in order to grow or shrink it. 222 // A general rule is that the result of getcallersp should be used 223 // immediately and can only be passed to nosplit functions. 224 225 //go:noescape 226 func getcallerpc(argp unsafe.Pointer) uintptr 227 228 //go:nosplit 229 func getcallersp(argp unsafe.Pointer) uintptr { 230 return uintptr(argp) - sys.MinFrameSize 231 } 232 233 //go:noescape 234 func asmcgocall(fn, arg unsafe.Pointer) int32 235 236 // argp used in Defer structs when there is no argp. 237 const _NoArgs = ^uintptr(0) 238 239 func morestack() 240 func morestack_noctxt() 241 func rt0_go() 242 243 // return0 is a stub used to return 0 from deferproc. 244 // It is called at the very end of deferproc to signal 245 // the calling Go function that it should not jump 246 // to deferreturn. 247 // in asm_*.s 248 func return0() 249 250 // in asm_*.s 251 // not called directly; definitions here supply type information for traceback. 252 func call32(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 253 func call64(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 254 func call128(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 255 func call256(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 256 func call512(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 257 func call1024(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 258 func call2048(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 259 func call4096(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 260 func call8192(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 261 func call16384(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 262 func call32768(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 263 func call65536(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 264 func call131072(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 265 func call262144(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 266 func call524288(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 267 func call1048576(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 268 func call2097152(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 269 func call4194304(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 270 func call8388608(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 271 func call16777216(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 272 func call33554432(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 273 func call67108864(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 274 func call134217728(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 275 func call268435456(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 276 func call536870912(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 277 func call1073741824(typ, fn, arg unsafe.Pointer, n, retoffset uint32) 278 279 func systemstack_switch() 280 281 func prefetcht0(addr uintptr) 282 func prefetcht1(addr uintptr) 283 func prefetcht2(addr uintptr) 284 func prefetchnta(addr uintptr) 285 286 // round n up to a multiple of a. a must be a power of 2. 287 func round(n, a uintptr) uintptr { 288 return (n + a - 1) &^ (a - 1) 289 } 290 291 // checkASM returns whether assembly runtime checks have passed. 292 func checkASM() bool 293 294 func memequal_varlen(a, b unsafe.Pointer) bool 295 func eqstring(s1, s2 string) bool 296 297 // bool2int returns 0 if x is false or 1 if x is true. 298 func bool2int(x bool) int { 299 // Avoid branches. In the SSA compiler, this compiles to 300 // exactly what you would want it to. 301 return int(uint8(*(*uint8)(unsafe.Pointer(&x)))) 302 }