// Generated by Lisette bindgen
// Source: runtime (Go stdlib)
// Go: 1.25.5
// Lisette: 0.1.14
pub fn AddCleanup<T, S>(ptr: Ref<T>, cleanup: fn(S) -> (), arg: S) -> Cleanup
/// BlockProfile returns n, the number of records in the current blocking profile.
/// If len(p) >= n, BlockProfile copies the profile into p and returns n, true.
/// If len(p) < n, BlockProfile does not change p and returns n, false.
///
/// Most clients should use the [runtime/pprof] package or
/// the [testing] package's -test.blockprofile flag instead
/// of calling BlockProfile directly.
pub fn BlockProfile(mut p: Slice<BlockProfileRecord>) -> Option<int>
/// Breakpoint executes a breakpoint trap.
pub fn Breakpoint()
/// CPUProfile panics.
/// It formerly provided raw access to chunks of
/// a pprof-format profile generated by the runtime.
/// The details of generating that format have changed,
/// so this functionality has been removed.
///
/// Deprecated: Use the [runtime/pprof] package,
/// or the handlers in the [net/http/pprof] package,
/// or the [testing] package's -test.cpuprofile flag instead.
pub fn CPUProfile() -> Slice<uint8>
/// Caller reports file and line number information about function invocations on
/// the calling goroutine's stack. The argument skip is the number of stack frames
/// to ascend, with 0 identifying the caller of Caller. (For historical reasons the
/// meaning of skip differs between Caller and [Callers].) The return values report
/// the program counter, the file name (using forward slashes as path separator, even
/// on Windows), and the line number within the file of the corresponding call.
/// The boolean ok is false if it was not possible to recover the information.
pub fn Caller(skip: int) -> Option<(uint, string, int)>
/// Callers fills the slice pc with the return program counters of function invocations
/// on the calling goroutine's stack. The argument skip is the number of stack frames
/// to skip before recording in pc, with 0 identifying the frame for Callers itself and
/// 1 identifying the caller of Callers.
/// It returns the number of entries written to pc.
///
/// To translate these PCs into symbolic information such as function
/// names and line numbers, use [CallersFrames]. CallersFrames accounts
/// for inlined functions and adjusts the return program counters into
/// call program counters. Iterating over the returned slice of PCs
/// directly is discouraged, as is using [FuncForPC] on any of the
/// returned PCs, since these cannot account for inlining or return
/// program counter adjustment.
pub fn Callers(skip: int, mut pc: Slice<uint>) -> int
pub fn CallersFrames(callers: Slice<uint>) -> Ref<Frames>
pub fn FuncForPC(pc: uint) -> Option<Ref<Func>>
/// GC runs a garbage collection and blocks the caller until the
/// garbage collection is complete. It may also block the entire
/// program.
pub fn GC()
/// GOMAXPROCS sets the maximum number of CPUs that can be executing
/// simultaneously and returns the previous setting. If n < 1, it does not change
/// the current setting.
///
/// # Default
///
/// If the GOMAXPROCS environment variable is set to a positive whole number,
/// GOMAXPROCS defaults to that value.
///
/// Otherwise, the Go runtime selects an appropriate default value from a combination of
/// - the number of logical CPUs on the machine,
/// - the process’s CPU affinity mask,
/// - and, on Linux, the process’s average CPU throughput limit based on cgroup CPU
/// quota, if any.
///
/// If GODEBUG=containermaxprocs=0 is set and GOMAXPROCS is not set by the
/// environment variable, then GOMAXPROCS instead defaults to the value of
/// [runtime.NumCPU]. Note that GODEBUG=containermaxprocs=0 is [default] for
/// language version 1.24 and below.
///
/// # Updates
///
/// The Go runtime periodically updates the default value based on changes to
/// the total logical CPU count, the CPU affinity mask, or cgroup quota. Setting
/// a custom value with the GOMAXPROCS environment variable or by calling
/// GOMAXPROCS disables automatic updates. The default value and automatic
/// updates can be restored by calling [SetDefaultGOMAXPROCS].
///
/// If GODEBUG=updatemaxprocs=0 is set, the Go runtime does not perform
/// automatic GOMAXPROCS updating. Note that GODEBUG=updatemaxprocs=0 is
/// [default] for language version 1.24 and below.
///
/// # Compatibility
///
/// Note that the default GOMAXPROCS behavior may change as the scheduler
/// improves, especially the implementation detail below.
///
/// # Implementation details
///
/// When computing default GOMAXPROCS via cgroups, the Go runtime computes the
/// "average CPU throughput limit" as the cgroup CPU quota / period. In cgroup
/// v2, these values come from the cpu.max file. In cgroup v1, they come from
/// cpu.cfs_quota_us and cpu.cfs_period_us, respectively. In container runtimes
/// that allow configuring CPU limits, this value usually corresponds to the
/// "CPU limit" option, not "CPU request".
///
/// The Go runtime typically selects the default GOMAXPROCS as the minimum of
/// the logical CPU count, the CPU affinity mask count, or the cgroup CPU
/// throughput limit. However, it will never set GOMAXPROCS less than 2 unless
/// the logical CPU count or CPU affinity mask count are below 2.
///
/// If the cgroup CPU throughput limit is not a whole number, the Go runtime
/// rounds up to the next whole number.
///
/// GOMAXPROCS updates are performed up to once per second, or less if the
/// application is idle.
///
/// [default]: https://go.dev/doc/godebug#default
pub fn GOMAXPROCS(n: int) -> int
/// GOROOT returns the root of the Go tree. It uses the
/// GOROOT environment variable, if set at process start,
/// or else the root used during the Go build.
///
/// Deprecated: The root used during the Go build will not be
/// meaningful if the binary is copied to another machine.
/// Use the system path to locate the “go” binary, and use
/// “go env GOROOT” to find its GOROOT.
pub fn GOROOT() -> string
/// Goexit terminates the goroutine that calls it. No other goroutine is affected.
/// Goexit runs all deferred calls before terminating the goroutine. Because Goexit
/// is not a panic, any recover calls in those deferred functions will return nil.
///
/// Calling Goexit from the main goroutine terminates that goroutine
/// without func main returning. Since func main has not returned,
/// the program continues execution of other goroutines.
/// If all other goroutines exit, the program crashes.
///
/// It crashes if called from a thread not created by the Go runtime.
pub fn Goexit()
/// GoroutineProfile returns n, the number of records in the active goroutine stack profile.
/// If len(p) >= n, GoroutineProfile copies the profile into p and returns n, true.
/// If len(p) < n, GoroutineProfile does not change p and returns n, false.
///
/// Most clients should use the [runtime/pprof] package instead
/// of calling GoroutineProfile directly.
pub fn GoroutineProfile(mut p: Slice<StackRecord>) -> Option<int>
/// Gosched yields the processor, allowing other goroutines to run. It does not
/// suspend the current goroutine, so execution resumes automatically.
pub fn Gosched()
/// KeepAlive marks its argument as currently reachable.
/// This ensures that the object is not freed, and its finalizer is not run,
/// before the point in the program where KeepAlive is called.
///
/// A very simplified example showing where KeepAlive is required:
///
/// type File struct { d int }
/// d, err := syscall.Open("/file/path", syscall.O_RDONLY, 0)
/// // ... do something if err != nil ...
/// p := &File{d}
/// runtime.SetFinalizer(p, func(p *File) { syscall.Close(p.d) })
/// var buf [10]byte
/// n, err := syscall.Read(p.d, buf[:])
/// // Ensure p is not finalized until Read returns.
/// runtime.KeepAlive(p)
/// // No more uses of p after this point.
///
/// Without the KeepAlive call, the finalizer could run at the start of
/// [syscall.Read], closing the file descriptor before syscall.Read makes
/// the actual system call.
///
/// Note: KeepAlive should only be used to prevent finalizers from
/// running prematurely. In particular, when used with [unsafe.Pointer],
/// the rules for valid uses of unsafe.Pointer still apply.
pub fn KeepAlive(x: Unknown)
/// 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,
/// until the calling goroutine has made as many calls to
/// [UnlockOSThread] as to LockOSThread.
/// If the calling goroutine exits without unlocking the thread,
/// the thread will be terminated.
///
/// All init functions are run on the startup thread. Calling LockOSThread
/// from an init function will cause the main function to be invoked on
/// that thread.
///
/// A goroutine should call LockOSThread before calling OS services or
/// non-Go library functions that depend on per-thread state.
pub fn LockOSThread()
/// MemProfile returns a profile of memory allocated and freed per allocation
/// site.
///
/// MemProfile returns n, the number of records in the current memory profile.
/// If len(p) >= n, MemProfile copies the profile into p and returns n, true.
/// If len(p) < n, MemProfile does not change p and returns n, false.
///
/// If inuseZero is true, the profile includes allocation records
/// where r.AllocBytes > 0 but r.AllocBytes == r.FreeBytes.
/// These are sites where memory was allocated, but it has all
/// been released back to the runtime.
///
/// The returned profile may be up to two garbage collection cycles old.
/// This is to avoid skewing the profile toward allocations; because
/// allocations happen in real time but frees are delayed until the garbage
/// collector performs sweeping, the profile only accounts for allocations
/// that have had a chance to be freed by the garbage collector.
///
/// Most clients should use the runtime/pprof package or
/// the testing package's -test.memprofile flag instead
/// of calling MemProfile directly.
pub fn MemProfile(mut p: Slice<MemProfileRecord>, inuseZero: bool) -> Option<int>
/// MutexProfile returns n, the number of records in the current mutex profile.
/// If len(p) >= n, MutexProfile copies the profile into p and returns n, true.
/// Otherwise, MutexProfile does not change p, and returns n, false.
///
/// Most clients should use the [runtime/pprof] package
/// instead of calling MutexProfile directly.
pub fn MutexProfile(mut p: Slice<BlockProfileRecord>) -> Option<int>
/// NumCPU returns the number of logical CPUs usable by the current process.
///
/// The set of available CPUs is checked by querying the operating system
/// at process startup. Changes to operating system CPU allocation after
/// process startup are not reflected.
pub fn NumCPU() -> int
/// NumCgoCall returns the number of cgo calls made by the current process.
pub fn NumCgoCall() -> int64
/// NumGoroutine returns the number of goroutines that currently exist.
pub fn NumGoroutine() -> int
/// ReadMemStats populates m with memory allocator statistics.
///
/// The returned memory allocator statistics are up to date as of the
/// call to ReadMemStats. This is in contrast with a heap profile,
/// which is a snapshot as of the most recently completed garbage
/// collection cycle.
pub fn ReadMemStats(m: Ref<MemStats>)
/// ReadTrace returns the next chunk of binary tracing data, blocking until data
/// is available. If tracing is turned off and all the data accumulated while it
/// was on has been returned, ReadTrace returns nil. The caller must copy the
/// returned data before calling ReadTrace again.
/// ReadTrace must be called from one goroutine at a time.
pub fn ReadTrace() -> Slice<uint8>
/// SetBlockProfileRate controls the fraction of goroutine blocking events
/// that are reported in the blocking profile. The profiler aims to sample
/// an average of one blocking event per rate nanoseconds spent blocked.
///
/// To include every blocking event in the profile, pass rate = 1.
/// To turn off profiling entirely, pass rate <= 0.
pub fn SetBlockProfileRate(rate: int)
/// SetCPUProfileRate sets the CPU profiling rate to hz samples per second.
/// If hz <= 0, SetCPUProfileRate turns off profiling.
/// If the profiler is on, the rate cannot be changed without first turning it off.
///
/// Most clients should use the [runtime/pprof] package or
/// the [testing] package's -test.cpuprofile flag instead of calling
/// SetCPUProfileRate directly.
pub fn SetCPUProfileRate(hz: int)
/// SetCgoTraceback records three C functions to use to gather
/// traceback information from C code and to convert that traceback
/// information into symbolic information. These are used when printing
/// stack traces for a program that uses cgo.
///
/// The traceback and context functions may be called from a signal
/// handler, and must therefore use only async-signal safe functions.
/// The symbolizer function may be called while the program is
/// crashing, and so must be cautious about using memory. None of the
/// functions may call back into Go.
///
/// The context function will be called with a single argument, a
/// pointer to a struct:
///
/// struct {
/// Context uintptr
/// }
///
/// In C syntax, this struct will be
///
/// struct {
/// uintptr_t Context;
/// };
///
/// If the Context field is 0, the context function is being called to
/// record the current traceback context. It should record in the
/// Context field whatever information is needed about the current
/// point of execution to later produce a stack trace, probably the
/// stack pointer and PC. In this case the context function will be
/// called from C code.
///
/// If the Context field is not 0, then it is a value returned by a
/// previous call to the context function. This case is called when the
/// context is no longer needed; that is, when the Go code is returning
/// to its C code caller. This permits the context function to release
/// any associated resources.
///
/// While it would be correct for the context function to record a
/// complete a stack trace whenever it is called, and simply copy that
/// out in the traceback function, in a typical program the context
/// function will be called many times without ever recording a
/// traceback for that context. Recording a complete stack trace in a
/// call to the context function is likely to be inefficient.
///
/// The traceback function will be called with a single argument, a
/// pointer to a struct:
///
/// struct {
/// Context uintptr
/// SigContext uintptr
/// Buf *uintptr
/// Max uintptr
/// }
///
/// In C syntax, this struct will be
///
/// struct {
/// uintptr_t Context;
/// uintptr_t SigContext;
/// uintptr_t* Buf;
/// uintptr_t Max;
/// };
///
/// The Context field will be zero to gather a traceback from the
/// current program execution point. In this case, the traceback
/// function will be called from C code.
///
/// Otherwise Context will be a value previously returned by a call to
/// the context function. The traceback function should gather a stack
/// trace from that saved point in the program execution. The traceback
/// function may be called from an execution thread other than the one
/// that recorded the context, but only when the context is known to be
/// valid and unchanging. The traceback function may also be called
/// deeper in the call stack on the same thread that recorded the
/// context. The traceback function may be called multiple times with
/// the same Context value; it will usually be appropriate to cache the
/// result, if possible, the first time this is called for a specific
/// context value.
///
/// If the traceback function is called from a signal handler on a Unix
/// system, SigContext will be the signal context argument passed to
/// the signal handler (a C ucontext_t* cast to uintptr_t). This may be
/// used to start tracing at the point where the signal occurred. If
/// the traceback function is not called from a signal handler,
/// SigContext will be zero.
///
/// Buf is where the traceback information should be stored. It should
/// be PC values, such that Buf[0] is the PC of the caller, Buf[1] is
/// the PC of that function's caller, and so on. Max is the maximum
/// number of entries to store. The function should store a zero to
/// indicate the top of the stack, or that the caller is on a different
/// stack, presumably a Go stack.
///
/// Unlike runtime.Callers, the PC values returned should, when passed
/// to the symbolizer function, return the file/line of the call
/// instruction. No additional subtraction is required or appropriate.
///
/// On all platforms, the traceback function is invoked when a call from
/// Go to C to Go requests a stack trace. On linux/amd64, linux/ppc64le,
/// linux/arm64, and freebsd/amd64, the traceback function is also invoked
/// when a signal is received by a thread that is executing a cgo call.
/// The traceback function should not make assumptions about when it is
/// called, as future versions of Go may make additional calls.
///
/// The symbolizer function will be called with a single argument, a
/// pointer to a struct:
///
/// struct {
/// PC uintptr // program counter to fetch information for
/// File *byte // file name (NUL terminated)
/// Lineno uintptr // line number
/// Func *byte // function name (NUL terminated)
/// Entry uintptr // function entry point
/// More uintptr // set non-zero if more info for this PC
/// Data uintptr // unused by runtime, available for function
/// }
///
/// In C syntax, this struct will be
///
/// struct {
/// uintptr_t PC;
/// char* File;
/// uintptr_t Lineno;
/// char* Func;
/// uintptr_t Entry;
/// uintptr_t More;
/// uintptr_t Data;
/// };
///
/// The PC field will be a value returned by a call to the traceback
/// function.
///
/// The first time the function is called for a particular traceback,
/// all the fields except PC will be 0. The function should fill in the
/// other fields if possible, setting them to 0/nil if the information
/// is not available. The Data field may be used to store any useful
/// information across calls. The More field should be set to non-zero
/// if there is more information for this PC, zero otherwise. If More
/// is set non-zero, the function will be called again with the same
/// PC, and may return different information (this is intended for use
/// with inlined functions). If More is zero, the function will be
/// called with the next PC value in the traceback. When the traceback
/// is complete, the function will be called once more with PC set to
/// zero; this may be used to free any information. Each call will
/// leave the fields of the struct set to the same values they had upon
/// return, except for the PC field when the More field is zero. The
/// function must not keep a copy of the struct pointer between calls.
///
/// When calling SetCgoTraceback, the version argument is the version
/// number of the structs that the functions expect to receive.
/// Currently this must be zero.
///
/// The symbolizer function may be nil, in which case the results of
/// the traceback function will be displayed as numbers. If the
/// traceback function is nil, the symbolizer function will never be
/// called. The context function may be nil, in which case the
/// traceback function will only be called with the context field set
/// to zero. If the context function is nil, then calls from Go to C
/// to Go will not show a traceback for the C portion of the call stack.
///
/// SetCgoTraceback should be called only once, ideally from an init function.
pub fn SetCgoTraceback(
version: int,
traceback: Unknown,
context: Unknown,
symbolizer: Unknown,
)
/// SetDefaultGOMAXPROCS updates the GOMAXPROCS setting to the runtime
/// default, as described by [GOMAXPROCS], ignoring the GOMAXPROCS
/// environment variable.
///
/// SetDefaultGOMAXPROCS can be used to enable the default automatic updating
/// GOMAXPROCS behavior if it has been disabled by the GOMAXPROCS
/// environment variable or a prior call to [GOMAXPROCS], or to force an immediate
/// update if the caller is aware of a change to the total logical CPU count, CPU
/// affinity mask or cgroup quota.
pub fn SetDefaultGOMAXPROCS()
/// SetFinalizer sets the finalizer associated with obj to the provided
/// finalizer function. When the garbage collector finds an unreachable block
/// with an associated finalizer, it clears the association and runs
/// finalizer(obj) in a separate goroutine. This makes obj reachable again,
/// but now without an associated finalizer. Assuming that SetFinalizer
/// is not called again, the next time the garbage collector sees
/// that obj is unreachable, it will free obj.
///
/// SetFinalizer(obj, nil) clears any finalizer associated with obj.
///
/// New Go code should consider using [AddCleanup] instead, which is much
/// less error-prone than SetFinalizer.
///
/// The argument obj must be a pointer to an object allocated by calling
/// new, by taking the address of a composite literal, or by taking the
/// address of a local variable.
/// The argument finalizer must be a function that takes a single argument
/// to which obj's type can be assigned, and can have arbitrary ignored return
/// values. If either of these is not true, SetFinalizer may abort the
/// program.
///
/// Finalizers are run in dependency order: if A points at B, both have
/// finalizers, and they are otherwise unreachable, only the finalizer
/// for A runs; once A is freed, the finalizer for B can run.
/// If a cyclic structure includes a block with a finalizer, that
/// cycle is not guaranteed to be garbage collected and the finalizer
/// is not guaranteed to run, because there is no ordering that
/// respects the dependencies.
///
/// The finalizer is scheduled to run at some arbitrary time after the
/// program can no longer reach the object to which obj points.
/// There is no guarantee that finalizers will run before a program exits,
/// so typically they are useful only for releasing non-memory resources
/// associated with an object during a long-running program.
/// For example, an [os.File] object could use a finalizer to close the
/// associated operating system file descriptor when a program discards
/// an os.File without calling Close, but it would be a mistake
/// to depend on a finalizer to flush an in-memory I/O buffer such as a
/// [bufio.Writer], because the buffer would not be flushed at program exit.
///
/// It is not guaranteed that a finalizer will run if the size of *obj is
/// zero bytes, because it may share same address with other zero-size
/// objects in memory. See https://go.dev/ref/spec#Size_and_alignment_guarantees.
///
/// It is not guaranteed that a finalizer will run for objects allocated
/// in initializers for package-level variables. Such objects may be
/// linker-allocated, not heap-allocated.
///
/// Note that because finalizers may execute arbitrarily far into the future
/// after an object is no longer referenced, the runtime is allowed to perform
/// a space-saving optimization that batches objects together in a single
/// allocation slot. The finalizer for an unreferenced object in such an
/// allocation may never run if it always exists in the same batch as a
/// referenced object. Typically, this batching only happens for tiny
/// (on the order of 16 bytes or less) and pointer-free objects.
///
/// A finalizer may run as soon as an object becomes unreachable.
/// In order to use finalizers correctly, the program must ensure that
/// the object is reachable until it is no longer required.
/// Objects stored in global variables, or that can be found by tracing
/// pointers from a global variable, are reachable. A function argument or
/// receiver may become unreachable at the last point where the function
/// mentions it. To make an unreachable object reachable, pass the object
/// to a call of the [KeepAlive] function to mark the last point in the
/// function where the object must be reachable.
///
/// For example, if p points to a struct, such as os.File, that contains
/// a file descriptor d, and p has a finalizer that closes that file
/// descriptor, and if the last use of p in a function is a call to
/// syscall.Write(p.d, buf, size), then p may be unreachable as soon as
/// the program enters [syscall.Write]. The finalizer may run at that moment,
/// closing p.d, causing syscall.Write to fail because it is writing to
/// a closed file descriptor (or, worse, to an entirely different
/// file descriptor opened by a different goroutine). To avoid this problem,
/// call KeepAlive(p) after the call to syscall.Write.
///
/// A single goroutine runs all finalizers for a program, sequentially.
/// If a finalizer must run for a long time, it should do so by starting
/// a new goroutine.
///
/// In the terminology of the Go memory model, a call
/// SetFinalizer(x, f) “synchronizes before” the finalization call f(x).
/// However, there is no guarantee that KeepAlive(x) or any other use of x
/// “synchronizes before” f(x), so in general a finalizer should use a mutex
/// or other synchronization mechanism if it needs to access mutable state in x.
/// For example, consider a finalizer that inspects a mutable field in x
/// that is modified from time to time in the main program before x
/// becomes unreachable and the finalizer is invoked.
/// The modifications in the main program and the inspection in the finalizer
/// need to use appropriate synchronization, such as mutexes or atomic updates,
/// to avoid read-write races.
pub fn SetFinalizer(obj: Unknown, finalizer: Unknown)
/// SetMutexProfileFraction controls the fraction of mutex contention events
/// that are reported in the mutex profile. On average 1/rate events are
/// reported. The previous rate is returned.
///
/// To turn off profiling entirely, pass rate 0.
/// To just read the current rate, pass rate < 0.
/// (For n>1 the details of sampling may change.)
pub fn SetMutexProfileFraction(rate: int) -> int
/// Stack formats a stack trace of the calling goroutine into buf
/// and returns the number of bytes written to buf.
/// If all is true, Stack formats stack traces of all other goroutines
/// into buf after the trace for the current goroutine.
pub fn Stack(mut buf: Slice<uint8>, all: bool) -> int
/// StartTrace enables tracing for the current process.
/// While tracing, the data will be buffered and available via [ReadTrace].
/// StartTrace returns an error if tracing is already enabled.
/// Most clients should use the [runtime/trace] package or the [testing] package's
/// -test.trace flag instead of calling StartTrace directly.
pub fn StartTrace() -> Result<(), error>
/// StopTrace stops tracing, if it was previously enabled.
/// StopTrace only returns after all the reads for the trace have completed.
pub fn StopTrace()
/// ThreadCreateProfile returns n, the number of records in the thread creation profile.
/// If len(p) >= n, ThreadCreateProfile copies the profile into p and returns n, true.
/// If len(p) < n, ThreadCreateProfile does not change p and returns n, false.
///
/// Most clients should use the runtime/pprof package instead
/// of calling ThreadCreateProfile directly.
pub fn ThreadCreateProfile(mut p: Slice<StackRecord>) -> Option<int>
/// 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
/// its fixed operating system thread.
/// If there are no active LockOSThread calls, this is a no-op.
///
/// Before calling UnlockOSThread, the caller must ensure that the OS
/// thread is suitable for running other goroutines. If the caller made
/// any permanent changes to the state of the thread that would affect
/// 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.
pub fn UnlockOSThread()
/// Version returns the Go tree's version string.
/// It is either the commit hash and date at the time of the build or,
/// when possible, a release tag like "go1.3".
pub fn Version() -> string
/// BlockProfileRecord describes blocking events originated
/// at a particular call sequence (stack trace).
pub struct BlockProfileRecord {
pub Count: int64,
pub Cycles: int64,
pub StackRecord: StackRecord,
}
/// Cleanup is a handle to a cleanup call for a specific object.
pub type Cleanup
/// Error identifies a runtime error used in panic.
///
/// The Go runtime triggers panics for a variety of cases, as described by the
/// Go Language Spec, such as out-of-bounds slice/array access, close of nil
/// channels, type assertion failures, etc.
///
/// When these cases occur, the Go runtime panics with an error that implements
/// Error. This can be useful when recovering from panics to distinguish between
/// custom application panics and fundamental runtime panics.
///
/// Packages outside of the Go standard library should not implement Error.
pub interface Error {
fn Error() -> string
fn RuntimeError()
}
/// Frame is the information returned by [Frames] for each call frame.
pub struct Frame {
pub PC: uint,
pub Func: Option<Ref<Func>>,
pub Function: string,
pub File: string,
pub Line: int,
pub Entry: uint,
}
/// Frames may be used to get function/file/line information for a
/// slice of PC values returned by [Callers].
pub type Frames
/// A Func represents a Go function in the running binary.
pub type Func
/// A MemProfileRecord describes the live objects allocated
/// by a particular call sequence (stack trace).
pub struct MemProfileRecord {
pub AllocBytes: int64,
pub FreeBytes: int64,
pub AllocObjects: int64,
pub FreeObjects: int64,
pub Stack0: Slice<uint>,
}
/// A MemStats records statistics about the memory allocator.
pub struct MemStats {
pub Alloc: uint64,
pub TotalAlloc: uint64,
pub Sys: uint64,
pub Lookups: uint64,
pub Mallocs: uint64,
pub Frees: uint64,
pub HeapAlloc: uint64,
pub HeapSys: uint64,
pub HeapIdle: uint64,
pub HeapInuse: uint64,
pub HeapReleased: uint64,
pub HeapObjects: uint64,
pub StackInuse: uint64,
pub StackSys: uint64,
pub MSpanInuse: uint64,
pub MSpanSys: uint64,
pub MCacheInuse: uint64,
pub MCacheSys: uint64,
pub BuckHashSys: uint64,
pub GCSys: uint64,
pub OtherSys: uint64,
pub NextGC: uint64,
pub LastGC: uint64,
pub PauseTotalNs: uint64,
pub PauseNs: Slice<uint64>,
pub PauseEnd: Slice<uint64>,
pub NumGC: uint32,
pub NumForcedGC: uint32,
pub GCCPUFraction: float64,
pub EnableGC: bool,
pub DebugGC: bool,
}
/// A PanicNilError happens when code calls panic(nil).
///
/// Before Go 1.21, programs that called panic(nil) observed recover returning nil.
/// Starting in Go 1.21, programs that call panic(nil) observe recover returning a *PanicNilError.
/// Programs can change back to the old behavior by setting GODEBUG=panicnil=1.
pub type PanicNilError
/// A Pinner is a set of Go objects each pinned to a fixed location in memory. The
/// [Pinner.Pin] method pins one object, while [Pinner.Unpin] unpins all pinned
/// objects. See their comments for more information.
pub type Pinner
/// A StackRecord describes a single execution stack.
pub struct StackRecord {
pub Stack0: Slice<uint>,
}
/// A TypeAssertionError explains a failed type assertion.
pub type TypeAssertionError
/// 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"
/// GOARCH is the running program's architecture target:
/// one of 386, amd64, arm, s390x, and so on.
const GOARCH = "arm64"
/// GOOS is the running program's operating system target:
/// one of darwin, freebsd, linux, and so on.
/// To view possible combinations of GOOS and GOARCH, run "go tool dist list".
const GOOS = "darwin"
/// MemProfileRate controls the fraction of memory allocations
/// that are recorded and reported in the memory profile.
/// The profiler aims to sample an average of
/// one allocation per MemProfileRate bytes allocated.
///
/// To include every allocated block in the profile, set MemProfileRate to 1.
/// To turn off profiling entirely, set MemProfileRate to 0.
///
/// The tools that process the memory profiles assume that the
/// profile rate is constant across the lifetime of the program
/// and equal to the current value. Programs that change the
/// memory profiling rate should do so just once, as early as
/// possible in the execution of the program (for example,
/// at the beginning of main).
pub var MemProfileRate: int
impl BlockProfileRecord {
/// Stack returns the stack trace associated with the record,
/// a prefix of r.Stack0.
fn Stack(self: Ref<BlockProfileRecord>) -> Slice<uint>
}
impl Cleanup {
/// Stop cancels the cleanup call. Stop will have no effect if the cleanup call
/// has already been queued for execution (because ptr became unreachable).
/// To guarantee that Stop removes the cleanup function, the caller must ensure
/// that the pointer that was passed to AddCleanup is reachable across the call to Stop.
fn Stop(self)
}
impl Frames {
/// Next returns a [Frame] representing the next call frame in the slice
/// of PC values. If it has already returned all call frames, Next
/// returns a zero [Frame].
///
/// The more result indicates whether the next call to Next will return
/// a valid [Frame]. It does not necessarily indicate whether this call
/// returned one.
///
/// See the [Frames] example for idiomatic usage.
fn Next(self: Ref<Frames>) -> (Frame, bool)
}
impl Func {
/// Entry returns the entry address of the function.
fn Entry(self: Ref<Func>) -> uint
/// FileLine returns the file name and line number of the
/// source code corresponding to the program counter pc.
/// The result will not be accurate if pc is not a program
/// counter within f.
fn FileLine(self: Ref<Func>, pc: uint) -> (string, int)
/// Name returns the name of the function.
fn Name(self: Ref<Func>) -> string
}
impl MemProfileRecord {
/// InUseBytes returns the number of bytes in use (AllocBytes - FreeBytes).
fn InUseBytes(self: Ref<MemProfileRecord>) -> int64
/// InUseObjects returns the number of objects in use (AllocObjects - FreeObjects).
fn InUseObjects(self: Ref<MemProfileRecord>) -> int64
/// Stack returns the stack trace associated with the record,
/// a prefix of r.Stack0.
fn Stack(self: Ref<MemProfileRecord>) -> Slice<uint>
}
impl PanicNilError {
fn Error(self: Ref<PanicNilError>) -> string
fn RuntimeError(self: Ref<PanicNilError>)
}
impl Pinner {
/// Pin pins a Go object, preventing it from being moved or freed by the garbage
/// collector until the [Pinner.Unpin] method has been called.
///
/// A pointer to a pinned object can be directly stored in C memory or can be
/// contained in Go memory passed to C functions. If the pinned object itself
/// contains pointers to Go objects, these objects must be pinned separately if they
/// are going to be accessed from C code.
///
/// The argument must be a pointer of any type or an [unsafe.Pointer].
/// It's safe to call Pin on non-Go pointers, in which case Pin will do nothing.
fn Pin(self: Ref<Pinner>, pointer: Unknown)
/// Unpin unpins all pinned objects of the [Pinner].
fn Unpin(self: Ref<Pinner>)
}
impl StackRecord {
/// Stack returns the stack trace associated with the record,
/// a prefix of r.Stack0.
fn Stack(self: Ref<StackRecord>) -> Slice<uint>
}
impl TypeAssertionError {
fn Error(self: Ref<TypeAssertionError>) -> string
fn RuntimeError(self: Ref<TypeAssertionError>)
}