Update vendor folder (Delve support)

2025-06-26 08:50:19 +00:00 · 2017-03-19 23:45:54 +01:00
parent f9939bc286
commit 7811c335e9
146 changed files with 50012 additions and 0 deletions
--- a/vendor/github.com/derekparker/delve/service/rpc2/client.go
+++ b/vendor/github.com/derekparker/delve/service/rpc2/client.go
@ -0,0 +1,308 @@
+package rpc2
+
+import (
+	"fmt"
+	"log"
+	"net/rpc"
+	"net/rpc/jsonrpc"
+	"time"
+
+	"github.com/derekparker/delve/service"
+	"github.com/derekparker/delve/service/api"
+)
+
+// Client is a RPC service.Client.
+type RPCClient struct {
+	addr       string
+	processPid int
+	client     *rpc.Client
+}
+
+// Ensure the implementation satisfies the interface.
+var _ service.Client = &RPCClient{}
+
+// NewClient creates a new RPCClient.
+func NewClient(addr string) *RPCClient {
+	client, err := jsonrpc.Dial("tcp", addr)
+	if err != nil {
+		log.Fatal("dialing:", err)
+	}
+	c := &RPCClient{addr: addr, client: client}
+	c.call("SetApiVersion", api.SetAPIVersionIn{2}, &api.SetAPIVersionOut{})
+	return c
+}
+
+func (c *RPCClient) ProcessPid() int {
+	out := new(ProcessPidOut)
+	c.call("ProcessPid", ProcessPidIn{}, out)
+	return out.Pid
+}
+
+func (c *RPCClient) LastModified() time.Time {
+	out := new(LastModifiedOut)
+	c.call("LastModified", LastModifiedIn{}, out)
+	return out.Time
+}
+
+func (c *RPCClient) Detach(kill bool) error {
+	out := new(DetachOut)
+	return c.call("Detach", DetachIn{kill}, out)
+}
+
+func (c *RPCClient) Restart() ([]api.DiscardedBreakpoint, error) {
+	out := new(RestartOut)
+	err := c.call("Restart", RestartIn{}, out)
+	return out.DiscardedBreakpoints, err
+}
+
+func (c *RPCClient) GetState() (*api.DebuggerState, error) {
+	var out StateOut
+	err := c.call("State", StateIn{}, &out)
+	return out.State, err
+}
+
+func (c *RPCClient) Continue() <-chan *api.DebuggerState {
+	ch := make(chan *api.DebuggerState)
+	go func() {
+		for {
+			out := new(CommandOut)
+			err := c.call("Command", &api.DebuggerCommand{Name: api.Continue}, &out)
+			state := out.State
+			if err != nil {
+				state.Err = err
+			}
+			if state.Exited {
+				// Error types apparantly cannot be marshalled by Go correctly. Must reset error here.
+				state.Err = fmt.Errorf("Process %d has exited with status %d", c.ProcessPid(), state.ExitStatus)
+			}
+			ch <- &state
+			if err != nil || state.Exited {
+				close(ch)
+				return
+			}
+
+			isbreakpoint := false
+			istracepoint := true
+			for i := range state.Threads {
+				if state.Threads[i].Breakpoint != nil {
+					isbreakpoint = true
+					istracepoint = istracepoint && state.Threads[i].Breakpoint.Tracepoint
+				}
+			}
+
+			if !isbreakpoint || !istracepoint {
+				close(ch)
+				return
+			}
+		}
+	}()
+	return ch
+}
+
+func (c *RPCClient) Next() (*api.DebuggerState, error) {
+	var out CommandOut
+	err := c.call("Command", api.DebuggerCommand{Name: api.Next}, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) Step() (*api.DebuggerState, error) {
+	var out CommandOut
+	err := c.call("Command", api.DebuggerCommand{Name: api.Step}, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) StepOut() (*api.DebuggerState, error) {
+	var out CommandOut
+	err := c.call("Command", &api.DebuggerCommand{Name: api.StepOut}, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) StepInstruction() (*api.DebuggerState, error) {
+	var out CommandOut
+	err := c.call("Command", api.DebuggerCommand{Name: api.StepInstruction}, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) SwitchThread(threadID int) (*api.DebuggerState, error) {
+	var out CommandOut
+	cmd := api.DebuggerCommand{
+		Name:     api.SwitchThread,
+		ThreadID: threadID,
+	}
+	err := c.call("Command", cmd, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) SwitchGoroutine(goroutineID int) (*api.DebuggerState, error) {
+	var out CommandOut
+	cmd := api.DebuggerCommand{
+		Name:        api.SwitchGoroutine,
+		GoroutineID: goroutineID,
+	}
+	err := c.call("Command", cmd, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) Halt() (*api.DebuggerState, error) {
+	var out CommandOut
+	err := c.call("Command", api.DebuggerCommand{Name: api.Halt}, &out)
+	return &out.State, err
+}
+
+func (c *RPCClient) GetBreakpoint(id int) (*api.Breakpoint, error) {
+	var out GetBreakpointOut
+	err := c.call("GetBreakpoint", GetBreakpointIn{id, ""}, &out)
+	return &out.Breakpoint, err
+}
+
+func (c *RPCClient) GetBreakpointByName(name string) (*api.Breakpoint, error) {
+	var out GetBreakpointOut
+	err := c.call("GetBreakpoint", GetBreakpointIn{0, name}, &out)
+	return &out.Breakpoint, err
+}
+
+func (c *RPCClient) CreateBreakpoint(breakPoint *api.Breakpoint) (*api.Breakpoint, error) {
+	var out CreateBreakpointOut
+	err := c.call("CreateBreakpoint", CreateBreakpointIn{*breakPoint}, &out)
+	return &out.Breakpoint, err
+}
+
+func (c *RPCClient) ListBreakpoints() ([]*api.Breakpoint, error) {
+	var out ListBreakpointsOut
+	err := c.call("ListBreakpoints", ListBreakpointsIn{}, &out)
+	return out.Breakpoints, err
+}
+
+func (c *RPCClient) ClearBreakpoint(id int) (*api.Breakpoint, error) {
+	var out ClearBreakpointOut
+	err := c.call("ClearBreakpoint", ClearBreakpointIn{id, ""}, &out)
+	return out.Breakpoint, err
+}
+
+func (c *RPCClient) ClearBreakpointByName(name string) (*api.Breakpoint, error) {
+	var out ClearBreakpointOut
+	err := c.call("ClearBreakpoint", ClearBreakpointIn{0, name}, &out)
+	return out.Breakpoint, err
+}
+
+func (c *RPCClient) AmendBreakpoint(bp *api.Breakpoint) error {
+	out := new(AmendBreakpointOut)
+	err := c.call("AmendBreakpoint", AmendBreakpointIn{*bp}, out)
+	return err
+}
+
+func (c *RPCClient) CancelNext() error {
+	var out CancelNextOut
+	return c.call("CancelNext", CancelNextIn{}, &out)
+}
+
+func (c *RPCClient) ListThreads() ([]*api.Thread, error) {
+	var out ListThreadsOut
+	err := c.call("ListThreads", ListThreadsIn{}, &out)
+	return out.Threads, err
+}
+
+func (c *RPCClient) GetThread(id int) (*api.Thread, error) {
+	var out GetThreadOut
+	err := c.call("GetThread", GetThreadIn{id}, &out)
+	return out.Thread, err
+}
+
+func (c *RPCClient) EvalVariable(scope api.EvalScope, expr string, cfg api.LoadConfig) (*api.Variable, error) {
+	var out EvalOut
+	err := c.call("Eval", EvalIn{scope, expr, &cfg}, &out)
+	return out.Variable, err
+}
+
+func (c *RPCClient) SetVariable(scope api.EvalScope, symbol, value string) error {
+	out := new(SetOut)
+	return c.call("Set", SetIn{scope, symbol, value}, out)
+}
+
+func (c *RPCClient) ListSources(filter string) ([]string, error) {
+	sources := new(ListSourcesOut)
+	err := c.call("ListSources", ListSourcesIn{filter}, sources)
+	return sources.Sources, err
+}
+
+func (c *RPCClient) ListFunctions(filter string) ([]string, error) {
+	funcs := new(ListFunctionsOut)
+	err := c.call("ListFunctions", ListFunctionsIn{filter}, funcs)
+	return funcs.Funcs, err
+}
+
+func (c *RPCClient) ListTypes(filter string) ([]string, error) {
+	types := new(ListTypesOut)
+	err := c.call("ListTypes", ListTypesIn{filter}, types)
+	return types.Types, err
+}
+
+func (c *RPCClient) ListPackageVariables(filter string, cfg api.LoadConfig) ([]api.Variable, error) {
+	var out ListPackageVarsOut
+	err := c.call("ListPackageVars", ListPackageVarsIn{filter, cfg}, &out)
+	return out.Variables, err
+}
+
+func (c *RPCClient) ListLocalVariables(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error) {
+	var out ListLocalVarsOut
+	err := c.call("ListLocalVars", ListLocalVarsIn{scope, cfg}, &out)
+	return out.Variables, err
+}
+
+func (c *RPCClient) ListRegisters(threadID int, includeFp bool) (api.Registers, error) {
+	out := new(ListRegistersOut)
+	err := c.call("ListRegisters", ListRegistersIn{ThreadID: threadID, IncludeFp: includeFp}, out)
+	return out.Regs, err
+}
+
+func (c *RPCClient) ListFunctionArgs(scope api.EvalScope, cfg api.LoadConfig) ([]api.Variable, error) {
+	var out ListFunctionArgsOut
+	err := c.call("ListFunctionArgs", ListFunctionArgsIn{scope, cfg}, &out)
+	return out.Args, err
+}
+
+func (c *RPCClient) ListGoroutines() ([]*api.Goroutine, error) {
+	var out ListGoroutinesOut
+	err := c.call("ListGoroutines", ListGoroutinesIn{}, &out)
+	return out.Goroutines, err
+}
+
+func (c *RPCClient) Stacktrace(goroutineId, depth int, cfg *api.LoadConfig) ([]api.Stackframe, error) {
+	var out StacktraceOut
+	err := c.call("Stacktrace", StacktraceIn{goroutineId, depth, false, cfg}, &out)
+	return out.Locations, err
+}
+
+func (c *RPCClient) AttachedToExistingProcess() bool {
+	out := new(AttachedToExistingProcessOut)
+	c.call("AttachedToExistingProcess", AttachedToExistingProcessIn{}, out)
+	return out.Answer
+}
+
+func (c *RPCClient) FindLocation(scope api.EvalScope, loc string) ([]api.Location, error) {
+	var out FindLocationOut
+	err := c.call("FindLocation", FindLocationIn{scope, loc}, &out)
+	return out.Locations, err
+}
+
+// Disassemble code between startPC and endPC
+func (c *RPCClient) DisassembleRange(scope api.EvalScope, startPC, endPC uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error) {
+	var out DisassembleOut
+	err := c.call("Disassemble", DisassembleIn{scope, startPC, endPC, flavour}, &out)
+	return out.Disassemble, err
+}
+
+// Disassemble function containing pc
+func (c *RPCClient) DisassemblePC(scope api.EvalScope, pc uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error) {
+	var out DisassembleOut
+	err := c.call("Disassemble", DisassembleIn{scope, pc, 0, flavour}, &out)
+	return out.Disassemble, err
+}
+
+func (c *RPCClient) url(path string) string {
+	return fmt.Sprintf("http://%s%s", c.addr, path)
+}
+
+func (c *RPCClient) call(method string, args, reply interface{}) error {
+	return c.client.Call("RPCServer."+method, args, reply)
+}
--- a/vendor/github.com/derekparker/delve/service/rpc2/server.go
+++ b/vendor/github.com/derekparker/delve/service/rpc2/server.go
@ -0,0 +1,575 @@
+package rpc2
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/derekparker/delve/service"
+	"github.com/derekparker/delve/service/api"
+	"github.com/derekparker/delve/service/debugger"
+)
+
+type RPCServer struct {
+	// config is all the information necessary to start the debugger and server.
+	config *service.Config
+	// debugger is a debugger service.
+	debugger *debugger.Debugger
+}
+
+func NewServer(config *service.Config, debugger *debugger.Debugger) *RPCServer {
+	return &RPCServer{config, debugger}
+}
+
+type ProcessPidIn struct {
+}
+
+type ProcessPidOut struct {
+	Pid int
+}
+
+// ProcessPid returns the pid of the process we are debugging.
+func (s *RPCServer) ProcessPid(arg ProcessPidIn, out *ProcessPidOut) error {
+	out.Pid = s.debugger.ProcessPid()
+	return nil
+}
+
+type LastModifiedIn struct {
+}
+
+type LastModifiedOut struct {
+	Time time.Time
+}
+
+func (s *RPCServer) LastModified(arg LastModifiedIn, out *LastModifiedOut) error {
+	out.Time = s.debugger.LastModified()
+	return nil
+}
+
+type DetachIn struct {
+	Kill bool
+}
+
+type DetachOut struct {
+}
+
+// Detach detaches the debugger, optionally killing the process.
+func (s *RPCServer) Detach(arg DetachIn, out *DetachOut) error {
+	return s.debugger.Detach(arg.Kill)
+}
+
+type RestartIn struct {
+}
+
+type RestartOut struct {
+	DiscardedBreakpoints []api.DiscardedBreakpoint
+}
+
+// Restart restarts program.
+func (s *RPCServer) Restart(arg RestartIn, out *RestartOut) error {
+	if s.config.AttachPid != 0 {
+		return errors.New("cannot restart process Delve did not create")
+	}
+	var err error
+	out.DiscardedBreakpoints, err = s.debugger.Restart()
+	return err
+}
+
+type StateIn struct {
+}
+
+type StateOut struct {
+	State *api.DebuggerState
+}
+
+// State returns the current debugger state.
+func (s *RPCServer) State(arg StateIn, out *StateOut) error {
+	st, err := s.debugger.State()
+	if err != nil {
+		return err
+	}
+	out.State = st
+	return nil
+}
+
+type CommandOut struct {
+	State api.DebuggerState
+}
+
+// Command interrupts, continues and steps through the program.
+func (s *RPCServer) Command(command api.DebuggerCommand, cb service.RPCCallback) {
+	st, err := s.debugger.Command(&command)
+	if err != nil {
+		cb.Return(nil, err)
+		return
+	}
+	var out CommandOut
+	out.State = *st
+	cb.Return(out, nil)
+	return
+}
+
+type GetBreakpointIn struct {
+	Id   int
+	Name string
+}
+
+type GetBreakpointOut struct {
+	Breakpoint api.Breakpoint
+}
+
+// GetBreakpoint gets a breakpoint by Name (if Name is not an empty string) or by ID.
+func (s *RPCServer) GetBreakpoint(arg GetBreakpointIn, out *GetBreakpointOut) error {
+	var bp *api.Breakpoint
+	if arg.Name != "" {
+		bp = s.debugger.FindBreakpointByName(arg.Name)
+		if bp == nil {
+			return fmt.Errorf("no breakpoint with name %s", arg.Name)
+		}
+	} else {
+		bp = s.debugger.FindBreakpoint(arg.Id)
+		if bp == nil {
+			return fmt.Errorf("no breakpoint with id %d", arg.Id)
+		}
+	}
+	out.Breakpoint = *bp
+	return nil
+}
+
+type StacktraceIn struct {
+	Id    int
+	Depth int
+	Full  bool
+	Cfg   *api.LoadConfig
+}
+
+type StacktraceOut struct {
+	Locations []api.Stackframe
+}
+
+// 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 (s *RPCServer) Stacktrace(arg StacktraceIn, out *StacktraceOut) error {
+	cfg := arg.Cfg
+	if cfg == nil && arg.Full {
+		cfg = &api.LoadConfig{true, 1, 64, 64, -1}
+	}
+	locs, err := s.debugger.Stacktrace(arg.Id, arg.Depth, api.LoadConfigToProc(cfg))
+	if err != nil {
+		return err
+	}
+	out.Locations = locs
+	return nil
+}
+
+type ListBreakpointsIn struct {
+}
+
+type ListBreakpointsOut struct {
+	Breakpoints []*api.Breakpoint
+}
+
+// ListBreakpoints gets all breakpoints.
+func (s *RPCServer) ListBreakpoints(arg ListBreakpointsIn, out *ListBreakpointsOut) error {
+	out.Breakpoints = s.debugger.Breakpoints()
+	return nil
+}
+
+type CreateBreakpointIn struct {
+	Breakpoint api.Breakpoint
+}
+
+type CreateBreakpointOut struct {
+	Breakpoint api.Breakpoint
+}
+
+// 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. Note that setting a breakpoint on a function's entry point
+// (line == 0) can have surprising consequences, it is advisable to
+// use line = -1 instead which will skip the prologue.
+//
+// - Otherwise the value specified by arg.Breakpoint.Addr will be used.
+func (s *RPCServer) CreateBreakpoint(arg CreateBreakpointIn, out *CreateBreakpointOut) error {
+	createdbp, err := s.debugger.CreateBreakpoint(&arg.Breakpoint)
+	if err != nil {
+		return err
+	}
+	out.Breakpoint = *createdbp
+	return nil
+}
+
+type ClearBreakpointIn struct {
+	Id   int
+	Name string
+}
+
+type ClearBreakpointOut struct {
+	Breakpoint *api.Breakpoint
+}
+
+// ClearBreakpoint deletes a breakpoint by Name (if Name is not an
+// empty string) or by ID.
+func (s *RPCServer) ClearBreakpoint(arg ClearBreakpointIn, out *ClearBreakpointOut) error {
+	var bp *api.Breakpoint
+	if arg.Name != "" {
+		bp = s.debugger.FindBreakpointByName(arg.Name)
+		if bp == nil {
+			return fmt.Errorf("no breakpoint with name %s", arg.Name)
+		}
+	} else {
+		bp = s.debugger.FindBreakpoint(arg.Id)
+		if bp == nil {
+			return fmt.Errorf("no breakpoint with id %d", arg.Id)
+		}
+	}
+	deleted, err := s.debugger.ClearBreakpoint(bp)
+	if err != nil {
+		return err
+	}
+	out.Breakpoint = deleted
+	return nil
+}
+
+type AmendBreakpointIn struct {
+	Breakpoint api.Breakpoint
+}
+
+type AmendBreakpointOut struct {
+}
+
+// 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 (s *RPCServer) AmendBreakpoint(arg AmendBreakpointIn, out *AmendBreakpointOut) error {
+	return s.debugger.AmendBreakpoint(&arg.Breakpoint)
+}
+
+type CancelNextIn struct {
+}
+
+type CancelNextOut struct {
+}
+
+func (s *RPCServer) CancelNext(arg CancelNextIn, out *CancelNextOut) error {
+	return s.debugger.CancelNext()
+}
+
+type ListThreadsIn struct {
+}
+
+type ListThreadsOut struct {
+	Threads []*api.Thread
+}
+
+// ListThreads lists all threads.
+func (s *RPCServer) ListThreads(arg ListThreadsIn, out *ListThreadsOut) (err error) {
+	out.Threads, err = s.debugger.Threads()
+	return err
+}
+
+type GetThreadIn struct {
+	Id int
+}
+
+type GetThreadOut struct {
+	Thread *api.Thread
+}
+
+// GetThread gets a thread by its ID.
+func (s *RPCServer) GetThread(arg GetThreadIn, out *GetThreadOut) error {
+	t, err := s.debugger.FindThread(arg.Id)
+	if err != nil {
+		return err
+	}
+	if t == nil {
+		return fmt.Errorf("no thread with id %d", arg.Id)
+	}
+	out.Thread = t
+	return nil
+}
+
+type ListPackageVarsIn struct {
+	Filter string
+	Cfg    api.LoadConfig
+}
+
+type ListPackageVarsOut struct {
+	Variables []api.Variable
+}
+
+// ListPackageVars lists all package variables in the context of the current thread.
+func (s *RPCServer) ListPackageVars(arg ListPackageVarsIn, out *ListPackageVarsOut) error {
+	state, err := s.debugger.State()
+	if err != nil {
+		return err
+	}
+
+	current := state.CurrentThread
+	if current == nil {
+		return fmt.Errorf("no current thread")
+	}
+
+	vars, err := s.debugger.PackageVariables(current.ID, arg.Filter, *api.LoadConfigToProc(&arg.Cfg))
+	if err != nil {
+		return err
+	}
+	out.Variables = vars
+	return nil
+}
+
+type ListRegistersIn struct {
+	ThreadID  int
+	IncludeFp bool
+}
+
+type ListRegistersOut struct {
+	Registers string
+	Regs      api.Registers
+}
+
+// ListRegisters lists registers and their values.
+func (s *RPCServer) ListRegisters(arg ListRegistersIn, out *ListRegistersOut) error {
+	if arg.ThreadID == 0 {
+		state, err := s.debugger.State()
+		if err != nil {
+			return err
+		}
+		arg.ThreadID = state.CurrentThread.ID
+	}
+
+	regs, err := s.debugger.Registers(arg.ThreadID, arg.IncludeFp)
+	if err != nil {
+		return err
+	}
+	out.Regs = regs
+	out.Registers = out.Regs.String()
+
+	return nil
+}
+
+type ListLocalVarsIn struct {
+	Scope api.EvalScope
+	Cfg   api.LoadConfig
+}
+
+type ListLocalVarsOut struct {
+	Variables []api.Variable
+}
+
+// ListLocalVars lists all local variables in scope.
+func (s *RPCServer) ListLocalVars(arg ListLocalVarsIn, out *ListLocalVarsOut) error {
+	vars, err := s.debugger.LocalVariables(arg.Scope, *api.LoadConfigToProc(&arg.Cfg))
+	if err != nil {
+		return err
+	}
+	out.Variables = vars
+	return nil
+}
+
+type ListFunctionArgsIn struct {
+	Scope api.EvalScope
+	Cfg   api.LoadConfig
+}
+
+type ListFunctionArgsOut struct {
+	Args []api.Variable
+}
+
+// ListFunctionArgs lists all arguments to the current function
+func (s *RPCServer) ListFunctionArgs(arg ListFunctionArgsIn, out *ListFunctionArgsOut) error {
+	vars, err := s.debugger.FunctionArguments(arg.Scope, *api.LoadConfigToProc(&arg.Cfg))
+	if err != nil {
+		return err
+	}
+	out.Args = vars
+	return nil
+}
+
+type EvalIn struct {
+	Scope api.EvalScope
+	Expr  string
+	Cfg   *api.LoadConfig
+}
+
+type EvalOut struct {
+	Variable *api.Variable
+}
+
+// EvalVariable returns a variable in the specified context.
+//
+// See https://github.com/derekparker/delve/wiki/Expressions for
+// a description of acceptable values of arg.Expr.
+func (s *RPCServer) Eval(arg EvalIn, out *EvalOut) error {
+	cfg := arg.Cfg
+	if cfg == nil {
+		cfg = &api.LoadConfig{true, 1, 64, 64, -1}
+	}
+	v, err := s.debugger.EvalVariableInScope(arg.Scope, arg.Expr, *api.LoadConfigToProc(cfg))
+	if err != nil {
+		return err
+	}
+	out.Variable = v
+	return nil
+}
+
+type SetIn struct {
+	Scope  api.EvalScope
+	Symbol string
+	Value  string
+}
+
+type SetOut struct {
+}
+
+// Set sets the value of a variable. Only numerical types and
+// pointers are currently supported.
+func (s *RPCServer) Set(arg SetIn, out *SetOut) error {
+	return s.debugger.SetVariableInScope(arg.Scope, arg.Symbol, arg.Value)
+}
+
+type ListSourcesIn struct {
+	Filter string
+}
+
+type ListSourcesOut struct {
+	Sources []string
+}
+
+// ListSources lists all source files in the process matching filter.
+func (s *RPCServer) ListSources(arg ListSourcesIn, out *ListSourcesOut) error {
+	ss, err := s.debugger.Sources(arg.Filter)
+	if err != nil {
+		return err
+	}
+	out.Sources = ss
+	return nil
+}
+
+type ListFunctionsIn struct {
+	Filter string
+}
+
+type ListFunctionsOut struct {
+	Funcs []string
+}
+
+// ListFunctions lists all functions in the process matching filter.
+func (s *RPCServer) ListFunctions(arg ListFunctionsIn, out *ListFunctionsOut) error {
+	fns, err := s.debugger.Functions(arg.Filter)
+	if err != nil {
+		return err
+	}
+	out.Funcs = fns
+	return nil
+}
+
+type ListTypesIn struct {
+	Filter string
+}
+
+type ListTypesOut struct {
+	Types []string
+}
+
+// ListTypes lists all types in the process matching filter.
+func (s *RPCServer) ListTypes(arg ListTypesIn, out *ListTypesOut) error {
+	tps, err := s.debugger.Types(arg.Filter)
+	if err != nil {
+		return err
+	}
+	out.Types = tps
+	return nil
+}
+
+type ListGoroutinesIn struct {
+}
+
+type ListGoroutinesOut struct {
+	Goroutines []*api.Goroutine
+}
+
+// ListGoroutines lists all goroutines.
+func (s *RPCServer) ListGoroutines(arg ListGoroutinesIn, out *ListGoroutinesOut) error {
+	gs, err := s.debugger.Goroutines()
+	if err != nil {
+		return err
+	}
+	out.Goroutines = gs
+	return nil
+}
+
+type AttachedToExistingProcessIn struct {
+}
+
+type AttachedToExistingProcessOut struct {
+	Answer bool
+}
+
+// AttachedToExistingProcess returns whether we attached to a running process or not
+func (c *RPCServer) AttachedToExistingProcess(arg AttachedToExistingProcessIn, out *AttachedToExistingProcessOut) error {
+	if c.config.AttachPid != 0 {
+		out.Answer = true
+	}
+	return nil
+}
+
+type FindLocationIn struct {
+	Scope api.EvalScope
+	Loc   string
+}
+
+type FindLocationOut struct {
+	Locations []api.Location
+}
+
+// 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 (c *RPCServer) FindLocation(arg FindLocationIn, out *FindLocationOut) error {
+	var err error
+	out.Locations, err = c.debugger.FindLocation(arg.Scope, arg.Loc)
+	return err
+}
+
+type DisassembleIn struct {
+	Scope          api.EvalScope
+	StartPC, EndPC uint64
+	Flavour        api.AssemblyFlavour
+}
+
+type DisassembleOut struct {
+	Disassemble api.AsmInstructions
+}
+
+// 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 gorutine 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 (c *RPCServer) Disassemble(arg DisassembleIn, out *DisassembleOut) error {
+	var err error
+	out.Disassemble, err = c.debugger.Disassemble(arg.Scope, arg.StartPC, arg.EndPC, arg.Flavour)
+	return err
+}