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 debugger_unix.go

Constants

const (
    ExecutingExistingFile = ExecuteKind(iota)
    ExecutingGeneratedFile
    ExecutingGeneratedTest
    ExecutingOther
)

Variables

var (
    // ErrCanNotRestart is returned when the target cannot be restarted.
    // This is returned for targets that have been attached to, or when
    // debugging core files.
    ErrCanNotRestart = errors.New("can not restart this target")

    // ErrNotRecording is returned when StopRecording is called while the
    // debugger is not recording the target.
    ErrNotRecording = errors.New("debugger is not recording")
)

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

    // TTY is passed along to the target process on creation. Used to specify a
    // TTY for that process.
    TTY string

    // Packages contains the packages that we are debugging.
    Packages []string

    // BuildFlags contains the flags passed to the compiler.
    BuildFlags string

    // ExecuteKind contains the kind of the executed program.
    ExecuteKind ExecuteKind

    // Redirects specifies redirect rules for stdin, stdout and stderr
    Redirects [3]string

    // DisableASLR disables ASLR
    DisableASLR 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) AsmInstructionText Uses

func (d *Debugger) AsmInstructionText(inst *proc.AsmInstruction, flavour proc.AssemblyFlavour) string

func (*Debugger) Attach Uses

func (d *Debugger) Attach(pid int, path string) (*proc.Target, 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() ([]proc.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) ConvertStacktrace Uses

func (d *Debugger) ConvertStacktrace(rawlocs []proc.Stackframe, cfg *proc.LoadConfig) ([]api.Stackframe, error)

ConvertStacktrace converts a slice of proc.Stackframe into a slice of api.Stackframe, loading local variables and arguments of each frame if cfg is not nil.

func (*Debugger) CreateBreakpoint Uses

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

CreateBreakpoint creates a breakpoint.

func (*Debugger) CurrentPackage Uses

func (d *Debugger) CurrentPackage() (string, error)

CurrentPackage returns the fully qualified name of the package corresponding to the function location of the current thread.

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) ([]proc.AsmInstruction, error)

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

func (*Debugger) DwarfRegisterToString Uses

func (d *Debugger) DwarfRegisterToString(i int, reg *op.DwarfRegister) (string, bool, string)

DwarfRegisterToString returns the name and value representation of the given register.

func (*Debugger) EvalVariableInScope Uses

func (d *Debugger) EvalVariableInScope(goid, frame, deferredCall int, symbol string, cfg proc.LoadConfig) (*proc.Variable, error)

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

func (*Debugger) ExamineMemory Uses

func (d *Debugger) ExamineMemory(address uint64, length int) ([]byte, error)

ExamineMemory returns the raw memory stored at the given address. The amount of data to be read is specified by length. This function will return an error if it reads less than `length` bytes.

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(goid, frame, deferredCall int, locStr string, includeNonExecutableLines bool, substitutePathRules [][2]string) ([]api.Location, error)

FindLocation will find the location specified by 'locStr'.

func (*Debugger) FindThread Uses

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

FindThread returns the thread for the given 'id'.

func (*Debugger) FindThreadReturnValues Uses

func (d *Debugger) FindThreadReturnValues(id int, cfg proc.LoadConfig) ([]*proc.Variable, error)

FindThreadReturnValues returns the return values of the function that the thread of the given 'id' just stepped out of.

func (*Debugger) FunctionArguments Uses

func (d *Debugger) FunctionArguments(goid, frame, deferredCall int, cfg proc.LoadConfig) ([]*proc.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) ([]*proc.G, 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.Target, error)

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

func (*Debugger) ListDynamicLibraries Uses

func (d *Debugger) ListDynamicLibraries() []*proc.Image

ListDynamicLibraries returns a list of loaded dynamic libraries.

func (*Debugger) ListPackagesBuildInfo Uses

func (d *Debugger) ListPackagesBuildInfo(includeFiles bool) []*proc.PackageBuildInfo

ListPackagesBuildInfo returns the list of packages used by the program along with the directory where each package was compiled and optionally the list of files constituting the package.

func (*Debugger) LocalVariables Uses

func (d *Debugger) LocalVariables(goid, frame, deferredCall int, cfg proc.LoadConfig) ([]*proc.Variable, error)

LocalVariables returns a list of the local variables.

func (*Debugger) LockTarget Uses

func (d *Debugger) LockTarget()

LockTarget acquires the target mutex.

func (*Debugger) PackageVariables Uses

func (d *Debugger) PackageVariables(filter string, cfg proc.LoadConfig) ([]*proc.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) Restart Uses

func (d *Debugger) Restart(rerecord bool, pos string, resetArgs bool, newArgs []string, newRedirects [3]string, rebuild bool) ([]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) ScopeRegisters Uses

func (d *Debugger) ScopeRegisters(goid, frame, deferredCall int, floatingPoint bool) (*op.DwarfRegisters, error)

ScopeRegisters returns registers for the specified scope.

func (*Debugger) SetVariableInScope Uses

func (d *Debugger) SetVariableInScope(goid, frame, deferredCall int, 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) ([]proc.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) StopReason Uses

func (d *Debugger) StopReason() proc.StopReason

StopReason returns the reason the reason why the target process is stopped. A process could be stopped for multiple simultaneous reasons, in which case only one will be reported.

func (*Debugger) StopRecording Uses

func (d *Debugger) StopRecording() error

StopRecording stops a recording (if one is in progress)

func (*Debugger) ThreadRegisters Uses

func (d *Debugger) ThreadRegisters(threadID int, floatingPoint bool) (*op.DwarfRegisters, error)

ThreadRegisters returns registers of the specified thread.

func (*Debugger) Threads Uses

func (d *Debugger) Threads() ([]proc.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.

func (*Debugger) UnlockTarget Uses

func (d *Debugger) UnlockTarget()

UnlockTarget releases the target mutex.

type ExecuteKind Uses

type ExecuteKind int

Package debugger imports 29 packages (graph) and is imported by 30 packages. Updated 2020-12-16. Refresh now. Tools for package owners.