Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AmendBreakpointIn

type AmendBreakpointIn struct {
	Breakpoint api.Breakpoint
}

type AmendBreakpointOut

type AmendBreakpointOut struct {
}

type AncestorsIn

type AncestorsIn struct {
	GoroutineID  int
	NumAncestors int
	Depth        int
}

type AncestorsOut

type AncestorsOut struct {
	Ancestors []api.Ancestor
}

type AttachedToExistingProcessIn

type AttachedToExistingProcessIn struct {
}

type AttachedToExistingProcessOut

type AttachedToExistingProcessOut struct {
	Answer bool
}

type CancelNextIn

type CancelNextIn struct {
}

type CancelNextOut

type CancelNextOut struct {
}

type CheckpointIn

type CheckpointIn struct {
	Where string
}

type CheckpointOut

type CheckpointOut struct {
	ID int
}

type ClearBreakpointIn

type ClearBreakpointIn struct {
	Id   int
	Name string
}

type ClearBreakpointOut

type ClearBreakpointOut struct {
	Breakpoint *api.Breakpoint
}

type ClearCheckpointIn

type ClearCheckpointIn struct {
	ID int
}

type ClearCheckpointOut

type ClearCheckpointOut struct {
}

type CommandOut

type CommandOut struct {
	State api.DebuggerState
}

type CreateBreakpointIn

type CreateBreakpointIn struct {
	Breakpoint api.Breakpoint
}

type CreateBreakpointOut

type CreateBreakpointOut struct {
	Breakpoint api.Breakpoint
}

type DetachIn

type DetachIn struct {
	Kill bool
}

type DetachOut

type DetachOut struct {
}

type DisassembleIn

type DisassembleIn struct {
	Scope          api.EvalScope
	StartPC, EndPC uint64
	Flavour        api.AssemblyFlavour
}

type DisassembleOut

type DisassembleOut struct {
	Disassemble api.AsmInstructions
}

type EvalIn

type EvalIn struct {
	Scope api.EvalScope
	Expr  string
	Cfg   *api.LoadConfig
}

type EvalOut

type EvalOut struct {
	Variable *api.Variable
}

type ExamineMemoryIn

type ExamineMemoryIn struct {
	Address uint64
	Length  int
}

    ExamineMemoryIn holds the arguments of ExamineMemory

    type ExaminedMemoryOut

    type ExaminedMemoryOut struct {
    	Mem            []byte
    	IsLittleEndian bool
    }

      ExaminedMemoryOut holds the return values of ExamineMemory

      type FindLocationIn

      type FindLocationIn struct {
      	Scope                     api.EvalScope
      	Loc                       string
      	IncludeNonExecutableLines bool
      
      	// SubstitutePathRules is a slice of source code path substitution rules,
      	// the first entry of each pair is the path of a directory as it appears in
      	// the executable file (i.e. the location of a source file when the program
      	// was compiled), the second entry of each pair is the location of the same
      	// directory on the client system.
      	SubstitutePathRules [][2]string
      }

      type FindLocationOut

      type FindLocationOut struct {
      	Locations []api.Location
      }

      type FunctionReturnLocationsIn

      type FunctionReturnLocationsIn struct {
      	// FnName is the name of the function for which all
      	// return locations should be given.
      	FnName string
      }

        FunctionReturnLocationsIn holds arguments for the FunctionReturnLocationsRPC call. It holds the name of the function for which all return locations should be given.

        type FunctionReturnLocationsOut

        type FunctionReturnLocationsOut struct {
        	// Addrs is the list of all locations where the given function returns.
        	Addrs []uint64
        }

          FunctionReturnLocationsOut holds the result of the FunctionReturnLocations RPC call. It provides the list of addresses that the given function returns, for example with a `RET` instruction or `CALL runtime.deferreturn`.

          type GetBreakpointIn

          type GetBreakpointIn struct {
          	Id   int
          	Name string
          }

          type GetBreakpointOut

          type GetBreakpointOut struct {
          	Breakpoint api.Breakpoint
          }

          type GetThreadIn

          type GetThreadIn struct {
          	Id int
          }

          type GetThreadOut

          type GetThreadOut struct {
          	Thread *api.Thread
          }

          type IsMulticlientIn

          type IsMulticlientIn struct {
          }

          type IsMulticlientOut

          type IsMulticlientOut struct {
          	// IsMulticlient returns true if the headless instance was started with --accept-multiclient
          	IsMulticlient bool
          }

          type LastModifiedIn

          type LastModifiedIn struct {
          }

          type LastModifiedOut

          type LastModifiedOut struct {
          	Time time.Time
          }

          type ListBreakpointsIn

          type ListBreakpointsIn struct {
          }

          type ListBreakpointsOut

          type ListBreakpointsOut struct {
          	Breakpoints []*api.Breakpoint
          }

          type ListCheckpointsIn

          type ListCheckpointsIn struct {
          }

          type ListCheckpointsOut

          type ListCheckpointsOut struct {
          	Checkpoints []api.Checkpoint
          }

          type ListDynamicLibrariesIn

          type ListDynamicLibrariesIn struct {
          }

            ListDynamicLibrariesIn holds the arguments of ListDynamicLibraries

            type ListDynamicLibrariesOut

            type ListDynamicLibrariesOut struct {
            	List []api.Image
            }

              ListDynamicLibrariesOut holds the return values of ListDynamicLibraries

              type ListFunctionArgsIn

              type ListFunctionArgsIn struct {
              	Scope api.EvalScope
              	Cfg   api.LoadConfig
              }

              type ListFunctionArgsOut

              type ListFunctionArgsOut struct {
              	Args []api.Variable
              }

              type ListFunctionsIn

              type ListFunctionsIn struct {
              	Filter string
              }

              type ListFunctionsOut

              type ListFunctionsOut struct {
              	Funcs []string
              }

              type ListGoroutinesIn

              type ListGoroutinesIn struct {
              	Start int
              	Count int
              }

              type ListGoroutinesOut

              type ListGoroutinesOut struct {
              	Goroutines []*api.Goroutine
              	Nextg      int
              }

              type ListLocalVarsIn

              type ListLocalVarsIn struct {
              	Scope api.EvalScope
              	Cfg   api.LoadConfig
              }

              type ListLocalVarsOut

              type ListLocalVarsOut struct {
              	Variables []api.Variable
              }

              type ListPackageVarsIn

              type ListPackageVarsIn struct {
              	Filter string
              	Cfg    api.LoadConfig
              }

              type ListPackageVarsOut

              type ListPackageVarsOut struct {
              	Variables []api.Variable
              }

              type ListPackagesBuildInfoIn

              type ListPackagesBuildInfoIn struct {
              	IncludeFiles bool
              }

                ListPackagesBuildInfoIn holds the arguments of ListPackages.

                type ListPackagesBuildInfoOut

                type ListPackagesBuildInfoOut struct {
                	List []api.PackageBuildInfo
                }

                  ListPackagesBuildInfoOut holds the return values of ListPackages.

                  type ListRegistersIn

                  type ListRegistersIn struct {
                  	ThreadID  int
                  	IncludeFp bool
                  	Scope     *api.EvalScope
                  }

                  type ListRegistersOut

                  type ListRegistersOut struct {
                  	Registers string
                  	Regs      api.Registers
                  }

                  type ListSourcesIn

                  type ListSourcesIn struct {
                  	Filter string
                  }

                  type ListSourcesOut

                  type ListSourcesOut struct {
                  	Sources []string
                  }

                  type ListThreadsIn

                  type ListThreadsIn struct {
                  }

                  type ListThreadsOut

                  type ListThreadsOut struct {
                  	Threads []*api.Thread
                  }

                  type ListTypesIn

                  type ListTypesIn struct {
                  	Filter string
                  }

                  type ListTypesOut

                  type ListTypesOut struct {
                  	Types []string
                  }

                  type ProcessPidIn

                  type ProcessPidIn struct {
                  }

                  type ProcessPidOut

                  type ProcessPidOut struct {
                  	Pid int
                  }

                  type RPCClient

                  type RPCClient struct {
                  	// contains filtered or unexported fields
                  }

                    Client is a RPC service.Client.

                    func NewClient

                    func NewClient(addr string) *RPCClient

                      NewClient creates a new RPCClient.

                      func NewClientFromConn

                      func NewClientFromConn(conn net.Conn) *RPCClient

                        NewClientFromConn creates a new RPCClient from the given connection.

                        func (*RPCClient) AmendBreakpoint

                        func (c *RPCClient) AmendBreakpoint(bp *api.Breakpoint) error

                        func (*RPCClient) Ancestors

                        func (c *RPCClient) Ancestors(goroutineID int, numAncestors int, depth int) ([]api.Ancestor, error)

                        func (*RPCClient) AttachedToExistingProcess

                        func (c *RPCClient) AttachedToExistingProcess() bool

                        func (*RPCClient) Call

                        func (c *RPCClient) Call(goroutineID int, expr string, unsafe bool) (*api.DebuggerState, error)

                        func (*RPCClient) CallAPI

                        func (c *RPCClient) CallAPI(method string, args, reply interface{}) error

                        func (*RPCClient) CancelNext

                        func (c *RPCClient) CancelNext() error

                        func (*RPCClient) Checkpoint

                        func (c *RPCClient) Checkpoint(where string) (checkpointID int, err error)

                          Checkpoint sets a checkpoint at the current position.

                          func (*RPCClient) ClearBreakpoint

                          func (c *RPCClient) ClearBreakpoint(id int) (*api.Breakpoint, error)

                          func (*RPCClient) ClearBreakpointByName

                          func (c *RPCClient) ClearBreakpointByName(name string) (*api.Breakpoint, error)

                          func (*RPCClient) ClearCheckpoint

                          func (c *RPCClient) ClearCheckpoint(id int) error

                            ClearCheckpoint removes a checkpoint

                            func (*RPCClient) Continue

                            func (c *RPCClient) Continue() <-chan *api.DebuggerState

                            func (*RPCClient) CreateBreakpoint

                            func (c *RPCClient) CreateBreakpoint(breakPoint *api.Breakpoint) (*api.Breakpoint, error)

                            func (*RPCClient) Detach

                            func (c *RPCClient) Detach(kill bool) error

                            func (*RPCClient) DirectionCongruentContinue

                            func (c *RPCClient) DirectionCongruentContinue() <-chan *api.DebuggerState

                            func (*RPCClient) DisassemblePC

                            func (c *RPCClient) DisassemblePC(scope api.EvalScope, pc uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error)

                              Disassemble function containing pc

                              func (*RPCClient) DisassembleRange

                              func (c *RPCClient) DisassembleRange(scope api.EvalScope, startPC, endPC uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error)

                                Disassemble code between startPC and endPC

                                func (*RPCClient) Disconnect

                                func (c *RPCClient) Disconnect(cont bool) error

                                func (*RPCClient) EvalVariable

                                func (c *RPCClient) EvalVariable(scope api.EvalScope, expr string, cfg api.LoadConfig) (*api.Variable, error)

                                func (*RPCClient) ExamineMemory

                                func (c *RPCClient) ExamineMemory(address uint64, count int) ([]byte, bool, error)

                                func (*RPCClient) FindLocation

                                func (c *RPCClient) FindLocation(scope api.EvalScope, loc string, findInstructions bool, substitutePathRules [][2]string) ([]api.Location, error)

                                func (*RPCClient) FunctionReturnLocations

                                func (c *RPCClient) FunctionReturnLocations(fnName string) ([]uint64, error)

                                func (*RPCClient) GetBreakpoint

                                func (c *RPCClient) GetBreakpoint(id int) (*api.Breakpoint, error)

                                func (*RPCClient) GetBreakpointByName

                                func (c *RPCClient) GetBreakpointByName(name string) (*api.Breakpoint, error)

                                func (*RPCClient) GetState

                                func (c *RPCClient) GetState() (*api.DebuggerState, error)

                                func (*RPCClient) GetStateNonBlocking

                                func (c *RPCClient) GetStateNonBlocking() (*api.DebuggerState, error)

                                func (*RPCClient) GetThread

                                func (c *RPCClient) GetThread(id int) (*api.Thread, error)

                                func (*RPCClient) Halt

                                func (c *RPCClient) Halt() (*api.DebuggerState, error)

                                func (*RPCClient) IsMulticlient

                                func (c *RPCClient) IsMulticlient() bool

                                func (*RPCClient) LastModified

                                func (c *RPCClient) LastModified() time.Time

                                func (*RPCClient) ListBreakpoints

                                func (c *RPCClient) ListBreakpoints() ([]*api.Breakpoint, error)

                                func (*RPCClient) ListCheckpoints

                                func (c *RPCClient) ListCheckpoints() ([]api.Checkpoint, error)

                                  ListCheckpoints gets all checkpoints.

                                  func (*RPCClient) ListDynamicLibraries

                                  func (c *RPCClient) ListDynamicLibraries() ([]api.Image, error)

                                  func (*RPCClient) ListFunctionArgs

                                  func (c *RPCClient) ListFunctionArgs(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error)

                                  func (*RPCClient) ListFunctions

                                  func (c *RPCClient) ListFunctions(filter string) ([]string, error)

                                  func (*RPCClient) ListGoroutines

                                  func (c *RPCClient) ListGoroutines(start, count int) ([]*api.Goroutine, int, error)

                                  func (*RPCClient) ListLocalVariables

                                  func (c *RPCClient) ListLocalVariables(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error)

                                  func (*RPCClient) ListPackageVariables

                                  func (c *RPCClient) ListPackageVariables(filter string, cfg api.LoadConfig) ([]api.Variable, error)

                                  func (*RPCClient) ListScopeRegisters

                                  func (c *RPCClient) ListScopeRegisters(scope api.EvalScope, includeFp bool) (api.Registers, error)

                                  func (*RPCClient) ListSources

                                  func (c *RPCClient) ListSources(filter string) ([]string, error)

                                  func (*RPCClient) ListThreadRegisters

                                  func (c *RPCClient) ListThreadRegisters(threadID int, includeFp bool) (api.Registers, error)

                                  func (*RPCClient) ListThreads

                                  func (c *RPCClient) ListThreads() ([]*api.Thread, error)

                                  func (*RPCClient) ListTypes

                                  func (c *RPCClient) ListTypes(filter string) ([]string, error)

                                  func (*RPCClient) Next

                                  func (c *RPCClient) Next() (*api.DebuggerState, error)

                                  func (*RPCClient) ProcessPid

                                  func (c *RPCClient) ProcessPid() int

                                  func (*RPCClient) Recorded

                                  func (c *RPCClient) Recorded() bool

                                    Recorded returns true if the debugger target is a recording.

                                    func (*RPCClient) Restart

                                    func (c *RPCClient) Restart(rebuild bool) ([]api.DiscardedBreakpoint, error)

                                    func (*RPCClient) RestartFrom

                                    func (c *RPCClient) RestartFrom(rerecord bool, pos string, resetArgs bool, newArgs []string, newRedirects [3]string, rebuild bool) ([]api.DiscardedBreakpoint, error)

                                    func (*RPCClient) ReverseNext

                                    func (c *RPCClient) ReverseNext() (*api.DebuggerState, error)

                                    func (*RPCClient) ReverseStep

                                    func (c *RPCClient) ReverseStep() (*api.DebuggerState, error)

                                    func (*RPCClient) ReverseStepInstruction

                                    func (c *RPCClient) ReverseStepInstruction() (*api.DebuggerState, error)

                                    func (*RPCClient) ReverseStepOut

                                    func (c *RPCClient) ReverseStepOut() (*api.DebuggerState, error)

                                    func (*RPCClient) Rewind

                                    func (c *RPCClient) Rewind() <-chan *api.DebuggerState

                                    func (*RPCClient) SetReturnValuesLoadConfig

                                    func (c *RPCClient) SetReturnValuesLoadConfig(cfg *api.LoadConfig)

                                    func (*RPCClient) SetVariable

                                    func (c *RPCClient) SetVariable(scope api.EvalScope, symbol, value string) error

                                    func (*RPCClient) Stacktrace

                                    func (c *RPCClient) Stacktrace(goroutineId, depth int, opts api.StacktraceOptions, cfg *api.LoadConfig) ([]api.Stackframe, error)

                                    func (*RPCClient) Step

                                    func (c *RPCClient) Step() (*api.DebuggerState, error)

                                    func (*RPCClient) StepInstruction

                                    func (c *RPCClient) StepInstruction() (*api.DebuggerState, error)

                                    func (*RPCClient) StepOut

                                    func (c *RPCClient) StepOut() (*api.DebuggerState, error)

                                    func (*RPCClient) StopRecording

                                    func (c *RPCClient) StopRecording() error

                                    func (*RPCClient) SwitchGoroutine

                                    func (c *RPCClient) SwitchGoroutine(goroutineID int) (*api.DebuggerState, error)

                                    func (*RPCClient) SwitchThread

                                    func (c *RPCClient) SwitchThread(threadID int) (*api.DebuggerState, error)

                                    func (*RPCClient) TraceDirectory

                                    func (c *RPCClient) TraceDirectory() (string, error)

                                      TraceDirectory returns the path to the trace directory for a recording.

                                      type RPCServer

                                      type RPCServer struct {
                                      	// contains filtered or unexported fields
                                      }

                                      func NewServer

                                      func NewServer(config *service.Config, debugger *debugger.Debugger) *RPCServer

                                      func (*RPCServer) AmendBreakpoint

                                      func (s *RPCServer) AmendBreakpoint(arg AmendBreakpointIn, out *AmendBreakpointOut) error

                                        AmendBreakpoint allows user to update an existing breakpoint for example to change the information retrieved when the breakpoint is hit or to change, add or remove the break condition.

                                        arg.Breakpoint.ID must be a valid breakpoint ID

                                        func (*RPCServer) Ancestors

                                        func (s *RPCServer) Ancestors(arg AncestorsIn, out *AncestorsOut) error

                                          Ancestors returns the stacktraces for the ancestors of a goroutine.

                                          func (*RPCServer) AttachedToExistingProcess

                                          func (c *RPCServer) AttachedToExistingProcess(arg AttachedToExistingProcessIn, out *AttachedToExistingProcessOut) error

                                            AttachedToExistingProcess returns whether we attached to a running process or not

                                            func (*RPCServer) CancelNext

                                            func (s *RPCServer) CancelNext(arg CancelNextIn, out *CancelNextOut) error

                                            func (*RPCServer) Checkpoint

                                            func (s *RPCServer) Checkpoint(arg CheckpointIn, out *CheckpointOut) error

                                            func (*RPCServer) ClearBreakpoint

                                            func (s *RPCServer) ClearBreakpoint(arg ClearBreakpointIn, out *ClearBreakpointOut) error

                                              ClearBreakpoint deletes a breakpoint by Name (if Name is not an empty string) or by ID.

                                              func (*RPCServer) ClearCheckpoint

                                              func (s *RPCServer) ClearCheckpoint(arg ClearCheckpointIn, out *ClearCheckpointOut) error

                                              func (*RPCServer) Command

                                              func (s *RPCServer) Command(command api.DebuggerCommand, cb service.RPCCallback)

                                                Command interrupts, continues and steps through the program.

                                                func (*RPCServer) CreateBreakpoint

                                                func (s *RPCServer) CreateBreakpoint(arg CreateBreakpointIn, out *CreateBreakpointOut) error

                                                  CreateBreakpoint creates a new breakpoint.

                                                  - If arg.Breakpoint.File is not an empty string the breakpoint will be created on the specified file:line location

                                                  - If arg.Breakpoint.FunctionName is not an empty string the breakpoint will be created on the specified function:line location.

                                                  - If arg.Breakpoint.Addrs is filled it will create a logical breakpoint corresponding to all specified addresses.

                                                  - Otherwise the value specified by arg.Breakpoint.Addr will be used.

                                                  func (*RPCServer) Detach

                                                  func (s *RPCServer) Detach(arg DetachIn, out *DetachOut) error

                                                    Detach detaches the debugger, optionally killing the process.

                                                    func (*RPCServer) Disassemble

                                                    func (c *RPCServer) Disassemble(arg DisassembleIn, out *DisassembleOut) error

                                                      Disassemble code.

                                                      If both StartPC and EndPC are non-zero the specified range will be disassembled, otherwise the function containing StartPC will be disassembled.

                                                      Scope is used to mark the instruction the specified goroutine is stopped at.

                                                      Disassemble will also try to calculate the destination address of an absolute indirect CALL if it happens to be the instruction the selected goroutine is stopped at.

                                                      func (*RPCServer) Eval

                                                      func (s *RPCServer) Eval(arg EvalIn, out *EvalOut) error

                                                        EvalVariable returns a variable in the specified context.

                                                        See https://github.com/go-delve/delve/wiki/Expressions for a description of acceptable values of arg.Expr.

                                                        func (*RPCServer) ExamineMemory

                                                        func (s *RPCServer) ExamineMemory(arg ExamineMemoryIn, out *ExaminedMemoryOut) error

                                                        func (*RPCServer) FindLocation

                                                        func (c *RPCServer) FindLocation(arg FindLocationIn, out *FindLocationOut) error

                                                          FindLocation returns concrete location information described by a location expression.

                                                          loc ::= <filename>:<line> | <function>[:<line>] | /<regex>/ | (+|-)<offset> | <line> | *<address>
                                                          * <filename> can be the full path of a file or just a suffix
                                                          * <function> ::= <package>.<receiver type>.<name> | <package>.(*<receiver type>).<name> | <receiver type>.<name> | <package>.<name> | (*<receiver type>).<name> | <name>
                                                          * <function> must be unambiguous
                                                          * /<regex>/ will return a location for each function matched by regex
                                                          * +<offset> returns a location for the line that is <offset> lines after the current line
                                                          * -<offset> returns a location for the line that is <offset> lines before the current line
                                                          * <line> returns a location for a line in the current file
                                                          * *<address> returns the location corresponding to the specified address
                                                          

                                                          NOTE: this function does not actually set breakpoints.

                                                          func (*RPCServer) FunctionReturnLocations

                                                          func (s *RPCServer) FunctionReturnLocations(in FunctionReturnLocationsIn, out *FunctionReturnLocationsOut) error

                                                            FunctionReturnLocations is the implements the client call of the same name. Look at client documentation for more information.

                                                            func (*RPCServer) GetBreakpoint

                                                            func (s *RPCServer) GetBreakpoint(arg GetBreakpointIn, out *GetBreakpointOut) error

                                                              GetBreakpoint gets a breakpoint by Name (if Name is not an empty string) or by ID.

                                                              func (*RPCServer) GetThread

                                                              func (s *RPCServer) GetThread(arg GetThreadIn, out *GetThreadOut) error

                                                                GetThread gets a thread by its ID.

                                                                func (*RPCServer) IsMulticlient

                                                                func (s *RPCServer) IsMulticlient(arg IsMulticlientIn, out *IsMulticlientOut) error

                                                                func (*RPCServer) LastModified

                                                                func (s *RPCServer) LastModified(arg LastModifiedIn, out *LastModifiedOut) error

                                                                func (*RPCServer) ListBreakpoints

                                                                func (s *RPCServer) ListBreakpoints(arg ListBreakpointsIn, out *ListBreakpointsOut) error

                                                                  ListBreakpoints gets all breakpoints.

                                                                  func (*RPCServer) ListCheckpoints

                                                                  func (s *RPCServer) ListCheckpoints(arg ListCheckpointsIn, out *ListCheckpointsOut) error

                                                                  func (*RPCServer) ListDynamicLibraries

                                                                  func (s *RPCServer) ListDynamicLibraries(in ListDynamicLibrariesIn, out *ListDynamicLibrariesOut) error

                                                                  func (*RPCServer) ListFunctionArgs

                                                                  func (s *RPCServer) ListFunctionArgs(arg ListFunctionArgsIn, out *ListFunctionArgsOut) error

                                                                    ListFunctionArgs lists all arguments to the current function

                                                                    func (*RPCServer) ListFunctions

                                                                    func (s *RPCServer) ListFunctions(arg ListFunctionsIn, out *ListFunctionsOut) error

                                                                      ListFunctions lists all functions in the process matching filter.

                                                                      func (*RPCServer) ListGoroutines

                                                                      func (s *RPCServer) ListGoroutines(arg ListGoroutinesIn, out *ListGoroutinesOut) error

                                                                        ListGoroutines lists all goroutines. If Count is specified ListGoroutines will return at the first Count goroutines and an index in Nextg, that can be passed as the Start parameter, to get more goroutines from ListGoroutines. Passing a value of Start that wasn't returned by ListGoroutines will skip an undefined number of goroutines.

                                                                        func (*RPCServer) ListLocalVars

                                                                        func (s *RPCServer) ListLocalVars(arg ListLocalVarsIn, out *ListLocalVarsOut) error

                                                                          ListLocalVars lists all local variables in scope.

                                                                          func (*RPCServer) ListPackageVars

                                                                          func (s *RPCServer) ListPackageVars(arg ListPackageVarsIn, out *ListPackageVarsOut) error

                                                                            ListPackageVars lists all package variables in the context of the current thread.

                                                                            func (*RPCServer) ListPackagesBuildInfo

                                                                            func (s *RPCServer) ListPackagesBuildInfo(in ListPackagesBuildInfoIn, out *ListPackagesBuildInfoOut) error

                                                                              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. Note that the directory path is a best guess and may be wrong is a tool other than cmd/go is used to perform the build.

                                                                              func (*RPCServer) ListRegisters

                                                                              func (s *RPCServer) ListRegisters(arg ListRegistersIn, out *ListRegistersOut) error

                                                                                ListRegisters lists registers and their values. If ListRegistersIn.Scope is not nil the registers of that eval scope will be returned, otherwise ListRegistersIn.ThreadID will be used.

                                                                                func (*RPCServer) ListSources

                                                                                func (s *RPCServer) ListSources(arg ListSourcesIn, out *ListSourcesOut) error

                                                                                  ListSources lists all source files in the process matching filter.

                                                                                  func (*RPCServer) ListThreads

                                                                                  func (s *RPCServer) ListThreads(arg ListThreadsIn, out *ListThreadsOut) (err error)

                                                                                    ListThreads lists all threads.

                                                                                    func (*RPCServer) ListTypes

                                                                                    func (s *RPCServer) ListTypes(arg ListTypesIn, out *ListTypesOut) error

                                                                                      ListTypes lists all types in the process matching filter.

                                                                                      func (*RPCServer) ProcessPid

                                                                                      func (s *RPCServer) ProcessPid(arg ProcessPidIn, out *ProcessPidOut) error

                                                                                        ProcessPid returns the pid of the process we are debugging.

                                                                                        func (*RPCServer) Recorded

                                                                                        func (s *RPCServer) Recorded(arg RecordedIn, out *RecordedOut) error

                                                                                        func (*RPCServer) Restart

                                                                                        func (s *RPCServer) Restart(arg RestartIn, cb service.RPCCallback)

                                                                                          Restart restarts program.

                                                                                          func (*RPCServer) Set

                                                                                          func (s *RPCServer) Set(arg SetIn, out *SetOut) error

                                                                                            Set sets the value of a variable. Only numerical types and pointers are currently supported.

                                                                                            func (*RPCServer) Stacktrace

                                                                                            func (s *RPCServer) Stacktrace(arg StacktraceIn, out *StacktraceOut) error

                                                                                              Stacktrace returns stacktrace of goroutine Id up to the specified Depth.

                                                                                              If Full is set it will also the variable of all local variables and function arguments of all stack frames.

                                                                                              func (*RPCServer) State

                                                                                              func (s *RPCServer) State(arg StateIn, cb service.RPCCallback)

                                                                                                State returns the current debugger state.

                                                                                                func (*RPCServer) StopRecording

                                                                                                func (s *RPCServer) StopRecording(arg StopRecordingIn, cb service.RPCCallback)

                                                                                                type RecordedIn

                                                                                                type RecordedIn struct {
                                                                                                }

                                                                                                type RecordedOut

                                                                                                type RecordedOut struct {
                                                                                                	Recorded       bool
                                                                                                	TraceDirectory string
                                                                                                }

                                                                                                type RestartIn

                                                                                                type RestartIn struct {
                                                                                                	// Position to restart from, if it starts with 'c' it's a checkpoint ID,
                                                                                                	// otherwise it's an event number. Only valid for recorded targets.
                                                                                                	Position string
                                                                                                
                                                                                                	// ResetArgs tell whether NewArgs and NewRedirects should take effect.
                                                                                                	ResetArgs bool
                                                                                                	// NewArgs are arguments to launch a new process.  They replace only the
                                                                                                	// argv[1] and later. Argv[0] cannot be changed.
                                                                                                	NewArgs []string
                                                                                                
                                                                                                	// When Rerecord is set the target will be rerecorded
                                                                                                	Rerecord bool
                                                                                                
                                                                                                	// When Rebuild is set the process will be build again
                                                                                                	Rebuild bool
                                                                                                
                                                                                                	NewRedirects [3]string
                                                                                                }

                                                                                                type RestartOut

                                                                                                type RestartOut struct {
                                                                                                	DiscardedBreakpoints []api.DiscardedBreakpoint
                                                                                                }

                                                                                                type SetIn

                                                                                                type SetIn struct {
                                                                                                	Scope  api.EvalScope
                                                                                                	Symbol string
                                                                                                	Value  string
                                                                                                }

                                                                                                type SetOut

                                                                                                type SetOut struct {
                                                                                                }

                                                                                                type StacktraceIn

                                                                                                type StacktraceIn struct {
                                                                                                	Id     int
                                                                                                	Depth  int
                                                                                                	Full   bool
                                                                                                	Defers bool // read deferred functions (equivalent to passing StacktraceReadDefers in Opts)
                                                                                                	Opts   api.StacktraceOptions
                                                                                                	Cfg    *api.LoadConfig
                                                                                                }

                                                                                                type StacktraceOut

                                                                                                type StacktraceOut struct {
                                                                                                	Locations []api.Stackframe
                                                                                                }

                                                                                                type StateIn

                                                                                                type StateIn struct {
                                                                                                	// If NonBlocking is true State will return immediately even if the target process is running.
                                                                                                	NonBlocking bool
                                                                                                }

                                                                                                type StateOut

                                                                                                type StateOut struct {
                                                                                                	State *api.DebuggerState
                                                                                                }

                                                                                                type StopRecordingIn

                                                                                                type StopRecordingIn struct {
                                                                                                }

                                                                                                type StopRecordingOut

                                                                                                type StopRecordingOut struct {
                                                                                                }