delve: github.com/go-delve/delve/service/debugger Index | Files

package debugger

import "github.com/go-delve/delve/service/debugger"

Index

Package Files

debugger.go debugger_linux.go locations.go

Variables

❖
var ErrCanNotRestart = errors.New("can not restart this target")
❖
var ErrNoAttachPath = errors.New("must specify executable path on macOS")

ErrNoAttachPath is the error returned when the client tries to attach to a process on macOS using the lldb backend without specifying the path to the target's executable.

type AddrLocationSpec Uses

❖
type AddrLocationSpec struct {
    AddrExpr string
}

func (*AddrLocationSpec) Find Uses

❖
func (loc *AddrLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

type AmbiguousLocationError Uses

❖
type AmbiguousLocationError struct {
    Location           string
    CandidatesString   []string
    CandidatesLocation []api.Location
}

func (AmbiguousLocationError) Error Uses

❖
func (ale AmbiguousLocationError) Error() string

type Config Uses

❖
type Config struct {
    // WorkingDir is working directory of the new process. This field is used
    // only when launching a new process.
    WorkingDir string

    // AttachPid is the PID of an existing process to which the debugger should
    // attach.
    AttachPid int

    // CoreFile specifies the path to the core dump to open.
    CoreFile string
    // Backend specifies the debugger backend.
    Backend string

    // Foreground lets target process access stdin.
    Foreground bool

    // DebugInfoDirectories is the list of directories to look for
    // when resolving external debug info files.
    DebugInfoDirectories []string

    // CheckGoVersion is true if the debugger should check the version of Go
    // used to compile the executable and refuse to work on incompatible
    // versions.
    CheckGoVersion bool
}

Config provides the configuration to start a Debugger.

Only one of ProcessArgs or AttachPid should be specified. If ProcessArgs is provided, a new process will be launched. Otherwise, the debugger will try to attach to an existing process with AttachPid.

type Debugger Uses

❖
type Debugger struct {
    // contains filtered or unexported fields
}

Debugger service.

Debugger provides a higher level of abstraction over proc.Process. It handles converting from internal types to the types expected by clients. It also handles functionality needed by clients, but not needed in lower lever packages such as proc.

func New Uses

❖
func New(config *Config, processArgs []string) (*Debugger, error)

New creates a new Debugger. ProcessArgs specify the commandline arguments for the new process.

func (*Debugger) AmendBreakpoint Uses

❖
func (d *Debugger) AmendBreakpoint(amend *api.Breakpoint) error

AmendBreakpoint will update the breakpoint with the matching ID.

func (*Debugger) Ancestors Uses

❖
func (d *Debugger) Ancestors(goroutineID, numAncestors, depth int) ([]api.Ancestor, error)

Ancestors returns the stacktraces for the ancestors of a goroutine.

func (*Debugger) Attach Uses

❖
func (d *Debugger) Attach(pid int, path string) (proc.Process, error)

Attach will attach to the process specified by 'pid'.

func (*Debugger) Breakpoints Uses

❖
func (d *Debugger) Breakpoints() []*api.Breakpoint

Breakpoints returns the list of current breakpoints.

func (*Debugger) CancelNext Uses

❖
func (d *Debugger) CancelNext() error

CancelNext will clear internal breakpoints, thus cancelling the 'next', 'step' or 'stepout' operation.

func (*Debugger) Checkpoint Uses

❖
func (d *Debugger) Checkpoint(where string) (int, error)

Checkpoint will set a checkpoint specified by the locspec.

func (*Debugger) Checkpoints Uses

❖
func (d *Debugger) Checkpoints() ([]api.Checkpoint, error)

Checkpoints will return a list of checkpoints.

func (*Debugger) ClearBreakpoint Uses

❖
func (d *Debugger) ClearBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoint, error)

ClearBreakpoint clears a breakpoint.

func (*Debugger) ClearCheckpoint Uses

❖
func (d *Debugger) ClearCheckpoint(id int) error

ClearCheckpoint will clear the checkpoint of the given ID.

func (*Debugger) Command Uses

❖
func (d *Debugger) Command(command *api.DebuggerCommand) (*api.DebuggerState, error)

Command handles commands which control the debugger lifecycle

func (*Debugger) CreateBreakpoint Uses

❖
func (d *Debugger) CreateBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoint, error)

CreateBreakpoint creates a breakpoint.

func (*Debugger) Detach Uses

❖
func (d *Debugger) Detach(kill bool) error

Detach detaches from the target process. If `kill` is true we will kill the process after detaching.

func (*Debugger) Disassemble Uses

❖
func (d *Debugger) Disassemble(goroutineID int, addr1, addr2 uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error)

Disassemble code between startPC and endPC. if endPC == 0 it will find the function containing startPC and disassemble the whole function.

func (*Debugger) EvalVariableInScope Uses

❖
func (d *Debugger) EvalVariableInScope(scope api.EvalScope, symbol string, cfg proc.LoadConfig) (*api.Variable, error)

EvalVariableInScope will attempt to evaluate the variable represented by 'symbol' in the scope provided.

func (*Debugger) FindBreakpoint Uses

❖
func (d *Debugger) FindBreakpoint(id int) *api.Breakpoint

FindBreakpoint returns the breakpoint specified by 'id'.

func (*Debugger) FindBreakpointByName Uses

❖
func (d *Debugger) FindBreakpointByName(name string) *api.Breakpoint

FindBreakpointByName returns the breakpoint specified by 'name'

func (*Debugger) FindLocation Uses

❖
func (d *Debugger) FindLocation(scope api.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

FindLocation will find the location specified by 'locStr'.

func (*Debugger) FindThread Uses

❖
func (d *Debugger) FindThread(id int) (*api.Thread, error)

FindThread returns the thread for the given 'id'.

func (*Debugger) FunctionArguments Uses

❖
func (d *Debugger) FunctionArguments(scope api.EvalScope, cfg proc.LoadConfig) ([]api.Variable, error)

FunctionArguments returns the arguments to the current function.

func (*Debugger) FunctionReturnLocations Uses

❖
func (d *Debugger) FunctionReturnLocations(fnName string) ([]uint64, error)

FunctionReturnLocations returns all return locations for the given function, a list of addresses corresponding to 'ret' or 'call runtime.deferreturn'.

func (*Debugger) Functions Uses

❖
func (d *Debugger) Functions(filter string) ([]string, error)

Functions returns a list of functions in the target process.

func (*Debugger) GetVersion Uses

❖
func (d *Debugger) GetVersion(out *api.GetVersionOut) error

func (*Debugger) Goroutines Uses

❖
func (d *Debugger) Goroutines(start, count int) ([]*api.Goroutine, int, error)

Goroutines will return a list of goroutines in the target process.

func (*Debugger) LastModified Uses

❖
func (d *Debugger) LastModified() time.Time

LastModified returns the time that the process' executable was last modified.

func (*Debugger) Launch Uses

❖
func (d *Debugger) Launch(processArgs []string, wd string) (proc.Process, error)

Launch will start a process with the given args and working directory.

func (*Debugger) ListDynamicLibraries Uses

❖
func (d *Debugger) ListDynamicLibraries() []api.Image

ListDynamicLibraries returns a list of loaded dynamic libraries.

func (*Debugger) LocalVariables Uses

❖
func (d *Debugger) LocalVariables(scope api.EvalScope, cfg proc.LoadConfig) ([]api.Variable, error)

LocalVariables returns a list of the local variables.

func (*Debugger) PackageVariables Uses

❖
func (d *Debugger) PackageVariables(threadID int, filter string, cfg proc.LoadConfig) ([]api.Variable, error)

PackageVariables returns a list of package variables for the thread, optionally regexp filtered using regexp described in 'filter'.

func (*Debugger) ProcessPid Uses

❖
func (d *Debugger) ProcessPid() int

ProcessPid returns the PID of the process the debugger is debugging.

func (*Debugger) Recorded Uses

❖
func (d *Debugger) Recorded() (recorded bool, tracedir string)

Recorded returns true if the target is a recording.

func (*Debugger) Registers Uses

❖
func (d *Debugger) Registers(threadID int, floatingPoint bool) (api.Registers, error)

Registers returns string representation of the CPU registers.

func (*Debugger) Restart Uses

❖
func (d *Debugger) Restart(rerecord bool, pos string, resetArgs bool, newArgs []string) ([]api.DiscardedBreakpoint, error)

Restart will restart the target process, first killing and then exec'ing it again. If the target process is a recording it will restart it from the given position. If pos starts with 'c' it's a checkpoint ID, otherwise it's an event number. If resetArgs is true, newArgs will replace the process args.

func (*Debugger) SetVariableInScope Uses

❖
func (d *Debugger) SetVariableInScope(scope api.EvalScope, symbol, value string) error

SetVariableInScope will set the value of the variable represented by 'symbol' to the value given, in the given scope.

func (*Debugger) Sources Uses

❖
func (d *Debugger) Sources(filter string) ([]string, error)

Sources returns a list of the source files for target binary.

func (*Debugger) Stacktrace Uses

❖
func (d *Debugger) Stacktrace(goroutineID, depth int, opts api.StacktraceOptions, cfg *proc.LoadConfig) ([]api.Stackframe, error)

Stacktrace returns a list of Stackframes for the given goroutine. The length of the returned list will be min(stack_len, depth). If 'full' is true, then local vars, function args, etc will be returned as well.

func (*Debugger) State Uses

❖
func (d *Debugger) State(nowait bool) (*api.DebuggerState, error)

State returns the current state of the debugger.

func (*Debugger) Threads Uses

❖
func (d *Debugger) Threads() ([]*api.Thread, error)

Threads returns the threads of the target process.

func (*Debugger) Types Uses

❖
func (d *Debugger) Types(filter string) ([]string, error)

Types returns all type information in the binary.

type FuncLocationSpec Uses

❖
type FuncLocationSpec struct {
    PackageName           string
    AbsolutePackage       bool
    ReceiverName          string
    PackageOrReceiverName string
    BaseName              string
}

func (*FuncLocationSpec) Match Uses

❖
func (spec *FuncLocationSpec) Match(sym proc.Function, packageMap map[string][]string) bool

type LineLocationSpec Uses

❖
type LineLocationSpec struct {
    Line int
}

func (*LineLocationSpec) Find Uses

❖
func (loc *LineLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

type LocationSpec Uses

❖
type LocationSpec interface {
    Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)
}

type NormalLocationSpec Uses

❖
type NormalLocationSpec struct {
    Base       string
    FuncBase   *FuncLocationSpec
    LineOffset int
}

func (*NormalLocationSpec) FileMatch Uses

❖
func (loc *NormalLocationSpec) FileMatch(path string) bool

func (*NormalLocationSpec) Find Uses

❖
func (loc *NormalLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

type OffsetLocationSpec Uses

❖
type OffsetLocationSpec struct {
    Offset int
}

func (*OffsetLocationSpec) Find Uses

❖
func (loc *OffsetLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

type RegexLocationSpec Uses

❖
type RegexLocationSpec struct {
    FuncRegex string
}

func (*RegexLocationSpec) Find Uses

❖
func (loc *RegexLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string, includeNonExecutableLines bool) ([]api.Location, error)

Package debugger imports 27 packages (graph) and is imported by 14 packages. Updated 2019-12-06. Refresh now. Tools for package owners.