]> Cypherpunks.ru repositories - gostls13.git/blob - src/runtime/stubs.go
net: remove dependency on math/rand
[gostls13.git] / src / runtime / stubs.go
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 "unsafe"
8
9 // Should be a built-in for unsafe.Pointer?
10 //go:nosplit
11 func add(p unsafe.Pointer, x uintptr) unsafe.Pointer {
12         return unsafe.Pointer(uintptr(p) + x)
13 }
14
15 // getg returns the pointer to the current g.
16 // The compiler rewrites calls to this function into instructions
17 // that fetch the g directly (from TLS or from the dedicated register).
18 func getg() *g
19
20 // mcall switches from the g to the g0 stack and invokes fn(g),
21 // where g is the goroutine that made the call.
22 // mcall saves g's current PC/SP in g->sched so that it can be restored later.
23 // It is up to fn to arrange for that later execution, typically by recording
24 // g in a data structure, causing something to call ready(g) later.
25 // mcall returns to the original goroutine g later, when g has been rescheduled.
26 // fn must not return at all; typically it ends by calling schedule, to let the m
27 // run other goroutines.
28 //
29 // mcall can only be called from g stacks (not g0, not gsignal).
30 //
31 // This must NOT be go:noescape: if fn is a stack-allocated closure,
32 // fn puts g on a run queue, and g executes before fn returns, the
33 // closure will be invalidated while it is still executing.
34 func mcall(fn func(*g))
35
36 // systemstack runs fn on a system stack.
37 // If systemstack is called from the per-OS-thread (g0) stack, or
38 // if systemstack is called from the signal handling (gsignal) stack,
39 // systemstack calls fn directly and returns.
40 // Otherwise, systemstack is being called from the limited stack
41 // of an ordinary goroutine. In this case, systemstack switches
42 // to the per-OS-thread stack, calls fn, and switches back.
43 // It is common to use a func literal as the argument, in order
44 // to share inputs and outputs with the code around the call
45 // to system stack:
46 //
47 //      ... set up y ...
48 //      systemstack(func() {
49 //              x = bigcall(y)
50 //      })
51 //      ... use x ...
52 //
53 //go:noescape
54 func systemstack(fn func())
55
56 var badsystemstackMsg = "fatal: systemstack called from unexpected goroutine"
57
58 //go:nosplit
59 //go:nowritebarrierrec
60 func badsystemstack() {
61         sp := stringStructOf(&badsystemstackMsg)
62         write(2, sp.str, int32(sp.len))
63 }
64
65 // memclrNoHeapPointers clears n bytes starting at ptr.
66 //
67 // Usually you should use typedmemclr. memclrNoHeapPointers should be
68 // used only when the caller knows that *ptr contains no heap pointers
69 // because either:
70 //
71 // *ptr is initialized memory and its type is pointer-free, or
72 //
73 // *ptr is uninitialized memory (e.g., memory that's being reused
74 // for a new allocation) and hence contains only "junk".
75 //
76 // The (CPU-specific) implementations of this function are in memclr_*.s.
77 //go:noescape
78 func memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr)
79
80 //go:linkname reflect_memclrNoHeapPointers reflect.memclrNoHeapPointers
81 func reflect_memclrNoHeapPointers(ptr unsafe.Pointer, n uintptr) {
82         memclrNoHeapPointers(ptr, n)
83 }
84
85 // memmove copies n bytes from "from" to "to".
86 //
87 // memmove ensures that any pointer in "from" is written to "to" with
88 // an indivisible write, so that racy reads cannot observe a
89 // half-written pointer. This is necessary to prevent the garbage
90 // collector from observing invalid pointers, and differs from memmove
91 // in unmanaged languages. However, memmove is only required to do
92 // this if "from" and "to" may contain pointers, which can only be the
93 // case if "from", "to", and "n" are all be word-aligned.
94 //
95 // Implementations are in memmove_*.s.
96 //
97 //go:noescape
98 func memmove(to, from unsafe.Pointer, n uintptr)
99
100 //go:linkname reflect_memmove reflect.memmove
101 func reflect_memmove(to, from unsafe.Pointer, n uintptr) {
102         memmove(to, from, n)
103 }
104
105 // exported value for testing
106 var hashLoad = float32(loadFactorNum) / float32(loadFactorDen)
107
108 //go:nosplit
109 func fastrand() uint32 {
110         mp := getg().m
111         // Implement xorshift64+: 2 32-bit xorshift sequences added together.
112         // Shift triplet [17,7,16] was calculated as indicated in Marsaglia's
113         // Xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
114         // This generator passes the SmallCrush suite, part of TestU01 framework:
115         // http://simul.iro.umontreal.ca/testu01/tu01.html
116         s1, s0 := mp.fastrand[0], mp.fastrand[1]
117         s1 ^= s1 << 17
118         s1 = s1 ^ s0 ^ s1>>7 ^ s0>>16
119         mp.fastrand[0], mp.fastrand[1] = s0, s1
120         return s0 + s1
121 }
122
123 //go:nosplit
124 func fastrandn(n uint32) uint32 {
125         // This is similar to fastrand() % n, but faster.
126         // See https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
127         return uint32(uint64(fastrand()) * uint64(n) >> 32)
128 }
129
130 //go:linkname sync_fastrand sync.fastrand
131 func sync_fastrand() uint32 { return fastrand() }
132
133 //go:linkname net_fastrand net.fastrand
134 func net_fastrand() uint32 { return fastrand() }
135
136 // in internal/bytealg/equal_*.s
137 //go:noescape
138 func memequal(a, b unsafe.Pointer, size uintptr) bool
139
140 // noescape hides a pointer from escape analysis.  noescape is
141 // the identity function but escape analysis doesn't think the
142 // output depends on the input.  noescape is inlined and currently
143 // compiles down to zero instructions.
144 // USE CAREFULLY!
145 //go:nosplit
146 func noescape(p unsafe.Pointer) unsafe.Pointer {
147         x := uintptr(p)
148         return unsafe.Pointer(x ^ 0)
149 }
150
151 func cgocallback(fn, frame unsafe.Pointer, framesize, ctxt uintptr)
152 func gogo(buf *gobuf)
153 func gosave(buf *gobuf)
154
155 //go:noescape
156 func jmpdefer(fv *funcval, argp uintptr)
157 func asminit()
158 func setg(gg *g)
159 func breakpoint()
160
161 // reflectcall calls fn with a copy of the n argument bytes pointed at by arg.
162 // After fn returns, reflectcall copies n-retoffset result bytes
163 // back into arg+retoffset before returning. If copying result bytes back,
164 // the caller should pass the argument frame type as argtype, so that
165 // call can execute appropriate write barriers during the copy.
166 // Package reflect passes a frame type. In package runtime, there is only
167 // one call that copies results back, in cgocallbackg1, and it does NOT pass a
168 // frame type, meaning there are no write barriers invoked. See that call
169 // site for justification.
170 //
171 // Package reflect accesses this symbol through a linkname.
172 func reflectcall(argtype *_type, fn, arg unsafe.Pointer, argsize uint32, retoffset uint32)
173
174 func procyield(cycles uint32)
175
176 type neverCallThisFunction struct{}
177
178 // goexit is the return stub at the top of every goroutine call stack.
179 // Each goroutine stack is constructed as if goexit called the
180 // goroutine's entry point function, so that when the entry point
181 // function returns, it will return to goexit, which will call goexit1
182 // to perform the actual exit.
183 //
184 // This function must never be called directly. Call goexit1 instead.
185 // gentraceback assumes that goexit terminates the stack. A direct
186 // call on the stack will cause gentraceback to stop walking the stack
187 // prematurely and if there is leftover state it may panic.
188 func goexit(neverCallThisFunction)
189
190 // Not all cgocallback_gofunc frames are actually cgocallback_gofunc,
191 // so not all have these arguments. Mark them uintptr so that the GC
192 // does not misinterpret memory when the arguments are not present.
193 // cgocallback_gofunc is not called from go, only from cgocallback,
194 // so the arguments will be found via cgocallback's pointer-declared arguments.
195 // See the assembly implementations for more details.
196 func cgocallback_gofunc(fv, frame, framesize, ctxt uintptr)
197
198 // publicationBarrier performs a store/store barrier (a "publication"
199 // or "export" barrier). Some form of synchronization is required
200 // between initializing an object and making that object accessible to
201 // another processor. Without synchronization, the initialization
202 // writes and the "publication" write may be reordered, allowing the
203 // other processor to follow the pointer and observe an uninitialized
204 // object. In general, higher-level synchronization should be used,
205 // such as locking or an atomic pointer write. publicationBarrier is
206 // for when those aren't an option, such as in the implementation of
207 // the memory manager.
208 //
209 // There's no corresponding barrier for the read side because the read
210 // side naturally has a data dependency order. All architectures that
211 // Go supports or seems likely to ever support automatically enforce
212 // data dependency ordering.
213 func publicationBarrier()
214
215 // getcallerpc returns the program counter (PC) of its caller's caller.
216 // getcallersp returns the stack pointer (SP) of its caller's caller.
217 // The implementation may be a compiler intrinsic; there is not
218 // necessarily code implementing this on every platform.
219 //
220 // For example:
221 //
222 //      func f(arg1, arg2, arg3 int) {
223 //              pc := getcallerpc()
224 //              sp := getcallersp()
225 //      }
226 //
227 // These two lines find the PC and SP immediately following
228 // the call to f (where f will return).
229 //
230 // The call to getcallerpc and getcallersp must be done in the
231 // frame being asked about.
232 //
233 // The result of getcallersp is correct at the time of the return,
234 // but it may be invalidated by any subsequent call to a function
235 // that might relocate the stack in order to grow or shrink it.
236 // A general rule is that the result of getcallersp should be used
237 // immediately and can only be passed to nosplit functions.
238
239 //go:noescape
240 func getcallerpc() uintptr
241
242 //go:noescape
243 func getcallersp() uintptr // implemented as an intrinsic on all platforms
244
245 // getclosureptr returns the pointer to the current closure.
246 // getclosureptr can only be used in an assignment statement
247 // at the entry of a function. Moreover, go:nosplit directive
248 // must be specified at the declaration of caller function,
249 // so that the function prolog does not clobber the closure register.
250 // for example:
251 //
252 //      //go:nosplit
253 //      func f(arg1, arg2, arg3 int) {
254 //              dx := getclosureptr()
255 //      }
256 //
257 // The compiler rewrites calls to this function into instructions that fetch the
258 // pointer from a well-known register (DX on x86 architecture, etc.) directly.
259 func getclosureptr() uintptr
260
261 //go:noescape
262 func asmcgocall(fn, arg unsafe.Pointer) int32
263
264 func morestack()
265 func morestack_noctxt()
266 func rt0_go()
267
268 // return0 is a stub used to return 0 from deferproc.
269 // It is called at the very end of deferproc to signal
270 // the calling Go function that it should not jump
271 // to deferreturn.
272 // in asm_*.s
273 func return0()
274
275 // in asm_*.s
276 // not called directly; definitions here supply type information for traceback.
277 func call16(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
278 func call32(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
279 func call64(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
280 func call128(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
281 func call256(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
282 func call512(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
283 func call1024(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
284 func call2048(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
285 func call4096(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
286 func call8192(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
287 func call16384(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
288 func call32768(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
289 func call65536(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
290 func call131072(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
291 func call262144(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
292 func call524288(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
293 func call1048576(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
294 func call2097152(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
295 func call4194304(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
296 func call8388608(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
297 func call16777216(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
298 func call33554432(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
299 func call67108864(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
300 func call134217728(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
301 func call268435456(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
302 func call536870912(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
303 func call1073741824(typ, fn, arg unsafe.Pointer, n, retoffset uint32)
304
305 func systemstack_switch()
306
307 // alignUp rounds n up to a multiple of a. a must be a power of 2.
308 func alignUp(n, a uintptr) uintptr {
309         return (n + a - 1) &^ (a - 1)
310 }
311
312 // alignDown rounds n down to a multiple of a. a must be a power of 2.
313 func alignDown(n, a uintptr) uintptr {
314         return n &^ (a - 1)
315 }
316
317 // divRoundUp returns ceil(n / a).
318 func divRoundUp(n, a uintptr) uintptr {
319         // a is generally a power of two. This will get inlined and
320         // the compiler will optimize the division.
321         return (n + a - 1) / a
322 }
323
324 // checkASM reports whether assembly runtime checks have passed.
325 func checkASM() bool
326
327 func memequal_varlen(a, b unsafe.Pointer) bool
328
329 // bool2int returns 0 if x is false or 1 if x is true.
330 func bool2int(x bool) int {
331         // Avoid branches. In the SSA compiler, this compiles to
332         // exactly what you would want it to.
333         return int(uint8(*(*uint8)(unsafe.Pointer(&x))))
334 }
335
336 // abort crashes the runtime in situations where even throw might not
337 // work. In general it should do something a debugger will recognize
338 // (e.g., an INT3 on x86). A crash in abort is recognized by the
339 // signal handler, which will attempt to tear down the runtime
340 // immediately.
341 func abort()
342
343 // Called from compiled code; declared for vet; do NOT call from Go.
344 func gcWriteBarrier()
345 func duffzero()
346 func duffcopy()
347
348 // Called from linker-generated .initarray; declared for go vet; do NOT call from Go.
349 func addmoduledata()