package notsha256
//go:noescape
-
func block(dig *digest, p []byte)
const haveAsm = true
//go:noescape
-
func block(dig *digest, p []byte)
package sha1
//go:noescape
-
func block(dig *digest, p []byte)
package sha256
//go:noescape
-
func block(dig *digest, p []byte)
package sha512
//go:noescape
-
func block(dig *digest, p []byte)
package bytealg
-//go:noescape
-
// Index returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= MaxLen.
-func Index(a, b []byte) int
-
+//
//go:noescape
+func Index(a, b []byte) int
// IndexString returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= MaxLen.
+//
+//go:noescape
func IndexString(a, b string) int
return r1
}
-//go:nosplit
-
// sysvicall1Err returns both the system call result and the errno value.
// This is used by sysvicall1 and pipe.
+//
+//go:nosplit
func sysvicall1Err(fn *libcFunc, a1 uintptr) (r1, err uintptr) {
// Leave caller's PC/SP around for traceback.
gp := getg()
}
}
-//go:nosplit
-
// Gosched yields the processor, allowing other goroutines to run. It does not
// suspend the current goroutine, so execution resumes automatically.
+//
+//go:nosplit
func Gosched() {
checkTimeouts()
mcall(gosched_m)
gp.lockedm.set(gp.m)
}
-//go:nosplit
-
// LockOSThread wires the calling goroutine to its current operating system thread.
// The calling goroutine will always execute in that thread,
// and no other goroutine will execute in it,
//
// A goroutine should call LockOSThread before calling OS services or
// non-Go library functions that depend on per-thread state.
+//
+//go:nosplit
func LockOSThread() {
if atomic.Load(&newmHandoff.haveTemplateThread) == 0 && GOOS != "plan9" {
// If we need to start a new thread from the locked
gp.lockedm = 0
}
-//go:nosplit
-
// UnlockOSThread undoes an earlier call to LockOSThread.
// If this drops the number of active LockOSThread calls on the
// calling goroutine to zero, it unwires the calling goroutine from
// other goroutines, it should not call this function and thus leave
// the goroutine locked to the OS thread until the goroutine (and
// hence the thread) exits.
+//
+//go:nosplit
func UnlockOSThread() {
gp := getg()
if gp.m.lockedExt == 0 {
return int(n)
}
-//go:nosplit
-
// RaceAcquire/RaceRelease/RaceReleaseMerge establish happens-before relations
// between goroutines. These inform the race detector about actual synchronization
// that it can't see for some reason (e.g. synchronization within RaceDisable/RaceEnable
// RaceReleaseMerge on addr up to and including the last RaceRelease on addr.
// In terms of the C memory model (C11 §5.1.2.4, §7.17.3),
// RaceAcquire is equivalent to atomic_load(memory_order_acquire).
+//
+//go:nosplit
func RaceAcquire(addr unsafe.Pointer) {
raceacquire(addr)
}
-//go:nosplit
-
// RaceRelease performs a release operation on addr that
// can synchronize with a later RaceAcquire on addr.
//
// In terms of the C memory model, RaceRelease is equivalent to
// atomic_store(memory_order_release).
+//
+//go:nosplit
func RaceRelease(addr unsafe.Pointer) {
racerelease(addr)
}
-//go:nosplit
-
// RaceReleaseMerge is like RaceRelease, but also establishes a happens-before
// relation with the preceding RaceRelease or RaceReleaseMerge on addr.
//
// In terms of the C memory model, RaceReleaseMerge is equivalent to
// atomic_exchange(memory_order_release).
+//
+//go:nosplit
func RaceReleaseMerge(addr unsafe.Pointer) {
racereleasemerge(addr)
}
-//go:nosplit
-
// RaceDisable disables handling of race synchronization events in the current goroutine.
// Handling is re-enabled with RaceEnable. RaceDisable/RaceEnable can be nested.
// Non-synchronization events (memory accesses, function entry/exit) still affect
// the race detector.
+//
+//go:nosplit
func RaceDisable() {
gp := getg()
if gp.raceignore == 0 {
gp.raceignore++
}
-//go:nosplit
-
// RaceEnable re-enables handling of race events in the current goroutine.
+//
+//go:nosplit
func RaceEnable() {
gp := getg()
gp.raceignore--
return p.addr
}
-//go:uintptrescapes
-
// Call executes procedure p with arguments a.
//
// The returned error is always non-nil, constructed from the result of GetLastError.
// values are returned in r2. The return value for C type "float" is
// math.Float32frombits(uint32(r2)). For C type "double", it is
// math.Float64frombits(uint64(r2)).
+//
+//go:uintptrescapes
func (p *Proc) Call(a ...uintptr) (uintptr, uintptr, error) {
return SyscallN(p.Addr(), a...)
}
return p.proc.Addr()
}
-//go:uintptrescapes
-
// Call executes procedure p with arguments a. See the documentation of
// Proc.Call for more information.
+//
+//go:uintptrescapes
func (p *LazyProc) Call(a ...uintptr) (r1, r2 uintptr, lastErr error) {
p.mustFind()
return p.proc.Call(a...)