debug: Index | Files

package gocore

import ""


Package Files

dominator.go dwarf.go goroutine.go module.go object.go process.go region.go reverse.go root.go type.go

type Field Uses

type Field struct {
    Name string
    Off  int64
    Type *Type

A Field represents a single field of a struct type.

type Frame Uses

type Frame struct {

    // Set of locations that contain a live pointer. Note that this set
    // may contain locations outside the frame (in particular, the args
    // for the frame).
    Live map[core.Address]bool
    // contains filtered or unexported fields

A Frame represents the local variables of a single Go function invocation. (Note that in the presence of inlining, a Frame may contain local variables for more than one Go function invocation.)

func (*Frame) Func Uses

func (f *Frame) Func() *Func

Func returns the function for which this frame is an activation record.

func (*Frame) Max Uses

func (f *Frame) Max() core.Address

Max returns the maximum address of this frame.

func (*Frame) Min Uses

func (f *Frame) Min() core.Address

Min returns the minimum address of this frame.

func (*Frame) PC Uses

func (f *Frame) PC() core.Address

PC returns the program counter of the next instruction to be executed by this frame.

func (*Frame) Parent Uses

func (f *Frame) Parent() *Frame

Parent returns the parent frame of f, or nil if it is the top of the stack.

func (*Frame) Roots Uses

func (f *Frame) Roots() []*Root

Roots returns a list of all the garbage collection roots in the frame.

type Func Uses

type Func struct {
    // contains filtered or unexported fields

A Func represents a Go function.

func (*Func) Entry Uses

func (f *Func) Entry() core.Address

Entry returns the address of the entry point of f.

func (*Func) Name Uses

func (f *Func) Name() string

Name returns the name of the function, as reported by DWARF. Names are opaque; do not depend on the format of the returned name.

type Goroutine Uses

type Goroutine struct {
    // contains filtered or unexported fields

func (*Goroutine) Addr Uses

func (g *Goroutine) Addr() core.Address

Addr returns the address of the runtime.g that identifies this goroutine.

func (*Goroutine) Frames Uses

func (g *Goroutine) Frames() []*Frame

Frames returns the list of frames on the stack of the Goroutine. The first frame is the most recent one. This list is post-optimization, so any inlined calls, tail calls, etc. will not appear.

func (*Goroutine) Stack Uses

func (g *Goroutine) Stack() int64

Stack returns the total allocated stack for g.

type Kind Uses

type Kind uint8
const (
    KindNone Kind = iota
    KindPtr // includes chan, map, unsafe.Pointer

func (Kind) String Uses

func (k Kind) String() string

type Object Uses

type Object core.Address

An Object represents a single reachable object in the Go heap. Unreachable (garbage) objects are not represented as Objects.

type Process Uses

type Process struct {
    // contains filtered or unexported fields

A Process represents the state of a Go process that core dumped.

func Core Uses

func Core(proc *core.Process) (p *Process, err error)

Core takes a loaded core file and extracts Go information from it.

func (*Process) Addr Uses

func (p *Process) Addr(x Object) core.Address

Addr returns the starting address of x.

func (*Process) BuildVersion Uses

func (p *Process) BuildVersion() string

BuildVersion returns the Go version that was used to build the inferior binary.

func (*Process) DynamicType Uses

func (p *Process) DynamicType(t *Type, a core.Address) *Type

DynamicType returns the concrete type stored in the interface type t at address a. If the interface is nil, returns nil.

func (*Process) FindFunc Uses

func (p *Process) FindFunc(pc core.Address) *Func

FindFunc returns the function which contains the code at address pc, if any.

func (*Process) FindObject Uses

func (p *Process) FindObject(a core.Address) (Object, int64)

FindObject finds the object containing a. Returns that object and the offset within that object to which a points. Returns 0,0 if a doesn't point to a live heap object.

func (*Process) ForEachObject Uses

func (p *Process) ForEachObject(fn func(x Object) bool)

ForEachObject calls fn with each object in the Go heap. If fn returns false, ForEachObject returns immediately.

func (*Process) ForEachPtr Uses

func (p *Process) ForEachPtr(x Object, fn func(int64, Object, int64) bool)

ForEachPtr calls fn for all heap pointers it finds in x. It calls fn with:

the offset of the pointer slot in x
the pointed-to object y
the offset in y where the pointer points.

If fn returns false, ForEachPtr returns immediately. For an edge from an object to its finalizer, the first argument passed to fn will be -1. (TODO: implement)

func (*Process) ForEachReversePtr Uses

func (p *Process) ForEachReversePtr(y Object, fn func(x Object, r *Root, i, j int64) bool)

ForEachReversePtr calls fn for all pointers it finds pointing to y. It calls fn with:

the object or root which points to y (exactly one will be non-nil)
the offset i in that object or root where the pointer appears.
the offset j in y where the pointer points.

If fn returns false, ForEachReversePtr returns immediately.

func (*Process) ForEachRoot Uses

func (p *Process) ForEachRoot(fn func(r *Root) bool)

ForEachRoot calls fn with each garbage collection root. If fn returns false, ForEachRoot returns immediately.

func (*Process) ForEachRootPtr Uses

func (p *Process) ForEachRootPtr(r *Root, fn func(int64, Object, int64) bool)

ForEachRootPtr behaves like ForEachPtr but it starts with a Root instead of an Object.

func (*Process) Globals Uses

func (p *Process) Globals() []*Root

func (*Process) Goroutines Uses

func (p *Process) Goroutines() []*Goroutine

func (*Process) IsPtr Uses

func (p *Process) IsPtr(a core.Address) bool

IsPtr reports whether the inferior at address a contains a pointer.

func (*Process) Process Uses

func (p *Process) Process() *core.Process

Process returns the core.Process used to construct this Process.

func (*Process) Size Uses

func (p *Process) Size(x Object) int64

Size returns the size of x in bytes.

func (*Process) Stats Uses

func (p *Process) Stats() *Stats

Stats returns a breakdown of the program's memory use by category.

func (*Process) Type Uses

func (p *Process) Type(x Object) (*Type, int64)

Type returns the type and repeat count for the object x. x contains at least repeat copies of the returned type.

type Root Uses

type Root struct {
    Name string
    Addr core.Address
    Type *Type // always non-nil
    // Frame, if non-nil, points to the frame in which this root lives.
    // Roots with non-nil Frame fields refer to local variables on a stack.
    // A stack root might be a large type, with some of its fields live and
    // others dead. Consult Frame.Live to find out which pointers in a stack
    // root are live.
    Frame *Frame

A Root is an area of memory that might have pointers into the Go heap.

type Stats Uses

type Stats struct {
    Name     string
    Size     int64
    Children []*Stats

A Stats struct is the node of a tree representing the entire memory usage of the Go program. Children of a node break its usage down by category. We maintain the invariant that, if there are children, Size == sum(c.Size for c in Children).

func (*Stats) Child Uses

func (s *Stats) Child(name string) *Stats

type Type Uses

type Type struct {
    Name string
    Size int64
    Kind Kind

    // Fields only valid for a subset of kinds.
    Count  int64   // for kind == KindArray
    Elem   *Type   // for kind == Kind{Ptr,Array,Slice,String}. nil for unsafe.Pointer. Always uint8 for KindString.
    Fields []Field // for kind == KindStruct

A Type is the representation of the type of a Go object. Types are not necessarily canonical. Names are opaque; do not depend on the format of the returned name.

func (*Type) String Uses

func (t *Type) String() string

Package gocore imports 9 packages (graph) and is imported by 2 packages. Updated 2019-11-16. Refresh now. Tools for package owners.