Update vendor folder (Delve support)

vendor/github.com/derekparker/delve/service/debugger/debugger.go

@@ -0,0 +1,835 @@
+package debugger
+
+import (
+	"debug/gosym"
+	"errors"
+	"fmt"
+	"go/parser"
+	"log"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/derekparker/delve/pkg/proc"
+	"github.com/derekparker/delve/pkg/target"
+	"github.com/derekparker/delve/service/api"
+)
+
+// 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.
+type Debugger struct {
+	config *Config
+	// TODO(DO NOT MERGE WITHOUT) rename to targetMutex
+	processMutex sync.Mutex
+	target       target.Interface
+}
+
+// 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 Config struct {
+	// ProcessArgs are the arguments to launch a new process.
+	ProcessArgs []string
+	// 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
+}
+
+// New creates a new Debugger.
+func New(config *Config) (*Debugger, error) {
+	d := &Debugger{
+		config: config,
+	}
+
+	// Create the process by either attaching or launching.
+	if d.config.AttachPid > 0 {
+		log.Printf("attaching to pid %d", d.config.AttachPid)
+		p, err := proc.Attach(d.config.AttachPid)
+		if err != nil {
+			return nil, attachErrorMessage(d.config.AttachPid, err)
+		}
+		d.target = p
+	} else {
+		log.Printf("launching process with args: %v", d.config.ProcessArgs)
+		p, err := proc.Launch(d.config.ProcessArgs, d.config.WorkingDir)
+		if err != nil {
+			if err != proc.NotExecutableErr && err != proc.UnsupportedArchErr {
+				err = fmt.Errorf("could not launch process: %s", err)
+			}
+			return nil, err
+		}
+		d.target = p
+	}
+	return d, nil
+}
+
+// ProcessPid returns the PID of the process
+// the debugger is debugging.
+func (d *Debugger) ProcessPid() int {
+	return d.target.Pid()
+}
+
+// LastModified returns the time that the process' executable was last
+// modified.
+func (d *Debugger) LastModified() time.Time {
+	return d.target.LastModified()
+}
+
+// Detach detaches from the target process.
+// If `kill` is true we will kill the process after
+// detaching.
+func (d *Debugger) Detach(kill bool) error {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	return d.detach(kill)
+}
+
+func (d *Debugger) detach(kill bool) error {
+	if d.config.AttachPid != 0 {
+		return d.target.Detach(kill)
+	}
+	return d.target.Kill()
+}
+
+// Restart will restart the target process, first killing
+// and then exec'ing it again.
+func (d *Debugger) Restart() ([]api.DiscardedBreakpoint, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	if !d.target.Exited() {
+		if d.target.Running() {
+			d.target.Halt()
+		}
+		// Ensure the process is in a PTRACE_STOP.
+		if err := stopProcess(d.ProcessPid()); err != nil {
+			return nil, err
+		}
+		if err := d.detach(true); err != nil {
+			return nil, err
+		}
+	}
+	p, err := proc.Launch(d.config.ProcessArgs, d.config.WorkingDir)
+	if err != nil {
+		return nil, fmt.Errorf("could not launch process: %s", err)
+	}
+	discarded := []api.DiscardedBreakpoint{}
+	for _, oldBp := range d.breakpoints() {
+		if oldBp.ID < 0 {
+			continue
+		}
+		if len(oldBp.File) > 0 {
+			oldBp.Addr, err = p.FindFileLocation(oldBp.File, oldBp.Line)
+			if err != nil {
+				discarded = append(discarded, api.DiscardedBreakpoint{oldBp, err.Error()})
+				continue
+			}
+		}
+		newBp, err := p.SetBreakpoint(oldBp.Addr, proc.UserBreakpoint, nil)
+		if err != nil {
+			return nil, err
+		}
+		if err := copyBreakpointInfo(newBp, oldBp); err != nil {
+			return nil, err
+		}
+	}
+	d.target = p
+	return discarded, nil
+}
+
+// State returns the current state of the debugger.
+func (d *Debugger) State() (*api.DebuggerState, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+	return d.state()
+}
+
+func (d *Debugger) state() (*api.DebuggerState, error) {
+	if d.target.Exited() {
+		return nil, proc.ProcessExitedError{Pid: d.ProcessPid()}
+	}
+
+	var (
+		state     *api.DebuggerState
+		goroutine *api.Goroutine
+	)
+
+	if d.target.SelectedGoroutine() != nil {
+		goroutine = api.ConvertGoroutine(d.target.SelectedGoroutine())
+	}
+
+	state = &api.DebuggerState{
+		SelectedGoroutine: goroutine,
+		Exited:            d.target.Exited(),
+	}
+
+	for i := range d.target.Threads() {
+		th := api.ConvertThread(d.target.Threads()[i])
+		state.Threads = append(state.Threads, th)
+		if i == d.target.CurrentThread().ID {
+			state.CurrentThread = th
+		}
+	}
+
+	for _, bp := range d.target.Breakpoints() {
+		if bp.Internal() {
+			state.NextInProgress = true
+			break
+		}
+	}
+
+	return state, nil
+}
+
+// CreateBreakpoint creates a breakpoint.
+func (d *Debugger) CreateBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoint, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	var (
+		createdBp *api.Breakpoint
+		addr      uint64
+		err       error
+	)
+
+	if requestedBp.Name != "" {
+		if err = api.ValidBreakpointName(requestedBp.Name); err != nil {
+			return nil, err
+		}
+		if d.findBreakpointByName(requestedBp.Name) != nil {
+			return nil, errors.New("breakpoint name already exists")
+		}
+	}
+
+	switch {
+	case len(requestedBp.File) > 0:
+		fileName := requestedBp.File
+		if runtime.GOOS == "windows" {
+			// Accept fileName which is case-insensitive and slash-insensitive match
+			fileNameNormalized := strings.ToLower(filepath.ToSlash(fileName))
+			for symFile := range d.target.Sources() {
+				if fileNameNormalized == strings.ToLower(filepath.ToSlash(symFile)) {
+					fileName = symFile
+					break
+				}
+			}
+		}
+		addr, err = d.target.FindFileLocation(fileName, requestedBp.Line)
+	case len(requestedBp.FunctionName) > 0:
+		if requestedBp.Line >= 0 {
+			addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, false, requestedBp.Line)
+		} else {
+			addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, true, 0)
+		}
+	default:
+		addr = requestedBp.Addr
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	bp, err := d.target.SetBreakpoint(addr, proc.UserBreakpoint, nil)
+	if err != nil {
+		return nil, err
+	}
+	if err := copyBreakpointInfo(bp, requestedBp); err != nil {
+		if _, err1 := d.target.ClearBreakpoint(bp.Addr); err1 != nil {
+			err = fmt.Errorf("error while creating breakpoint: %v, additionally the breakpoint could not be properly rolled back: %v", err, err1)
+		}
+		return nil, err
+	}
+	createdBp = api.ConvertBreakpoint(bp)
+	log.Printf("created breakpoint: %#v", createdBp)
+	return createdBp, nil
+}
+
+func (d *Debugger) AmendBreakpoint(amend *api.Breakpoint) error {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	original := d.findBreakpoint(amend.ID)
+	if original == nil {
+		return fmt.Errorf("no breakpoint with ID %d", amend.ID)
+	}
+	if err := api.ValidBreakpointName(amend.Name); err != nil {
+		return err
+	}
+	return copyBreakpointInfo(original, amend)
+}
+
+func (d *Debugger) CancelNext() error {
+	return d.target.ClearInternalBreakpoints()
+}
+
+func copyBreakpointInfo(bp *proc.Breakpoint, requested *api.Breakpoint) (err error) {
+	bp.Name = requested.Name
+	bp.Tracepoint = requested.Tracepoint
+	bp.Goroutine = requested.Goroutine
+	bp.Stacktrace = requested.Stacktrace
+	bp.Variables = requested.Variables
+	bp.LoadArgs = api.LoadConfigToProc(requested.LoadArgs)
+	bp.LoadLocals = api.LoadConfigToProc(requested.LoadLocals)
+	bp.Cond = nil
+	if requested.Cond != "" {
+		bp.Cond, err = parser.ParseExpr(requested.Cond)
+	}
+	return err
+}
+
+// ClearBreakpoint clears a breakpoint.
+func (d *Debugger) ClearBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoint, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	var clearedBp *api.Breakpoint
+	bp, err := d.target.ClearBreakpoint(requestedBp.Addr)
+	if err != nil {
+		return nil, fmt.Errorf("Can't clear breakpoint @%x: %s", requestedBp.Addr, err)
+	}
+	clearedBp = api.ConvertBreakpoint(bp)
+	log.Printf("cleared breakpoint: %#v", clearedBp)
+	return clearedBp, err
+}
+
+// Breakpoints returns the list of current breakpoints.
+func (d *Debugger) Breakpoints() []*api.Breakpoint {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+	return d.breakpoints()
+}
+
+func (d *Debugger) breakpoints() []*api.Breakpoint {
+	bps := []*api.Breakpoint{}
+	for _, bp := range d.target.Breakpoints() {
+		if bp.Internal() {
+			continue
+		}
+		bps = append(bps, api.ConvertBreakpoint(bp))
+	}
+	return bps
+}
+
+// FindBreakpoint returns the breakpoint specified by 'id'.
+func (d *Debugger) FindBreakpoint(id int) *api.Breakpoint {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	bp := d.findBreakpoint(id)
+	if bp == nil {
+		return nil
+	}
+	return api.ConvertBreakpoint(bp)
+}
+
+func (d *Debugger) findBreakpoint(id int) *proc.Breakpoint {
+	for _, bp := range d.target.Breakpoints() {
+		if bp.ID == id {
+			return bp
+		}
+	}
+	return nil
+}
+
+// FindBreakpointByName returns the breakpoint specified by 'name'
+func (d *Debugger) FindBreakpointByName(name string) *api.Breakpoint {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+	return d.findBreakpointByName(name)
+}
+
+func (d *Debugger) findBreakpointByName(name string) *api.Breakpoint {
+	for _, bp := range d.breakpoints() {
+		if bp.Name == name {
+			return bp
+		}
+	}
+	return nil
+}
+
+// Threads returns the threads of the target process.
+func (d *Debugger) Threads() ([]*api.Thread, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	if d.target.Exited() {
+		return nil, &proc.ProcessExitedError{}
+	}
+	threads := []*api.Thread{}
+	for _, th := range d.target.Threads() {
+		threads = append(threads, api.ConvertThread(th))
+	}
+	return threads, nil
+}
+
+// FindThread returns the thread for the given 'id'.
+func (d *Debugger) FindThread(id int) (*api.Thread, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	if d.target.Exited() {
+		return nil, &proc.ProcessExitedError{}
+	}
+
+	for _, th := range d.target.Threads() {
+		if th.ID == id {
+			return api.ConvertThread(th), nil
+		}
+	}
+	return nil, nil
+}
+
+// Command handles commands which control the debugger lifecycle
+func (d *Debugger) Command(command *api.DebuggerCommand) (*api.DebuggerState, error) {
+	var err error
+
+	if command.Name == api.Halt {
+		// RequestManualStop does not invoke any ptrace syscalls, so it's safe to
+		// access the process directly.
+		log.Print("halting")
+		err = d.target.RequestManualStop()
+	}
+
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	switch command.Name {
+	case api.Continue:
+		log.Print("continuing")
+		err = d.target.Continue()
+		if err != nil {
+			if exitedErr, exited := err.(proc.ProcessExitedError); exited {
+				state := &api.DebuggerState{}
+				state.Exited = true
+				state.ExitStatus = exitedErr.Status
+				state.Err = errors.New(exitedErr.Error())
+				return state, nil
+			}
+			return nil, err
+		}
+		state, stateErr := d.state()
+		if stateErr != nil {
+			return state, stateErr
+		}
+		err = d.collectBreakpointInformation(state)
+		return state, err
+
+	case api.Next:
+		log.Print("nexting")
+		err = d.target.Next()
+	case api.Step:
+		log.Print("stepping")
+		err = d.target.Step()
+	case api.StepInstruction:
+		log.Print("single stepping")
+		err = d.target.StepInstruction()
+	case api.StepOut:
+		log.Print("step out")
+		err = d.target.StepOut()
+	case api.SwitchThread:
+		log.Printf("switching to thread %d", command.ThreadID)
+		err = d.target.SwitchThread(command.ThreadID)
+	case api.SwitchGoroutine:
+		log.Printf("switching to goroutine %d", command.GoroutineID)
+		err = d.target.SwitchGoroutine(command.GoroutineID)
+	case api.Halt:
+		// RequestManualStop already called
+	}
+	if err != nil {
+		return nil, err
+	}
+	return d.state()
+}
+
+func (d *Debugger) collectBreakpointInformation(state *api.DebuggerState) error {
+	if state == nil {
+		return nil
+	}
+
+	for i := range state.Threads {
+		if state.Threads[i].Breakpoint == nil {
+			continue
+		}
+
+		bp := state.Threads[i].Breakpoint
+		bpi := &api.BreakpointInfo{}
+		state.Threads[i].BreakpointInfo = bpi
+
+		if bp.Goroutine {
+			g, err := d.target.CurrentThread().GetG()
+			if err != nil {
+				return err
+			}
+			bpi.Goroutine = api.ConvertGoroutine(g)
+		}
+
+		if bp.Stacktrace > 0 {
+			rawlocs, err := d.target.CurrentThread().Stacktrace(bp.Stacktrace)
+			if err != nil {
+				return err
+			}
+			bpi.Stacktrace, err = d.convertStacktrace(rawlocs, nil)
+			if err != nil {
+				return err
+			}
+		}
+
+		s, err := d.target.Threads()[state.Threads[i].ID].Scope()
+		if err != nil {
+			return err
+		}
+
+		if len(bp.Variables) > 0 {
+			bpi.Variables = make([]api.Variable, len(bp.Variables))
+		}
+		for i := range bp.Variables {
+			v, err := s.EvalVariable(bp.Variables[i], proc.LoadConfig{true, 1, 64, 64, -1})
+			if err != nil {
+				return err
+			}
+			bpi.Variables[i] = *api.ConvertVar(v)
+		}
+		if bp.LoadArgs != nil {
+			if vars, err := s.FunctionArguments(*api.LoadConfigToProc(bp.LoadArgs)); err == nil {
+				bpi.Arguments = convertVars(vars)
+			}
+		}
+		if bp.LoadLocals != nil {
+			if locals, err := s.LocalVariables(*api.LoadConfigToProc(bp.LoadLocals)); err == nil {
+				bpi.Locals = convertVars(locals)
+			}
+		}
+	}
+
+	return nil
+}
+
+// Sources returns a list of the source files for target binary.
+func (d *Debugger) Sources(filter string) ([]string, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	regex, err := regexp.Compile(filter)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter argument: %s", err.Error())
+	}
+
+	files := []string{}
+	for f := range d.target.Sources() {
+		if regex.Match([]byte(f)) {
+			files = append(files, f)
+		}
+	}
+	return files, nil
+}
+
+// Functions returns a list of functions in the target process.
+func (d *Debugger) Functions(filter string) ([]string, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	return regexFilterFuncs(filter, d.target.Funcs())
+}
+
+func (d *Debugger) Types(filter string) ([]string, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	regex, err := regexp.Compile(filter)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter argument: %s", err.Error())
+	}
+
+	types, err := d.target.Types()
+	if err != nil {
+		return nil, err
+	}
+
+	r := make([]string, 0, len(types))
+	for _, typ := range types {
+		if regex.Match([]byte(typ)) {
+			r = append(r, typ)
+		}
+	}
+
+	return r, nil
+}
+
+func regexFilterFuncs(filter string, allFuncs []gosym.Func) ([]string, error) {
+	regex, err := regexp.Compile(filter)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter argument: %s", err.Error())
+	}
+
+	funcs := []string{}
+	for _, f := range allFuncs {
+		if f.Sym != nil && regex.Match([]byte(f.Name)) {
+			funcs = append(funcs, f.Name)
+		}
+	}
+	return funcs, nil
+}
+
+// PackageVariables returns a list of package variables for the thread,
+// optionally regexp filtered using regexp described in 'filter'.
+func (d *Debugger) PackageVariables(threadID int, filter string, cfg proc.LoadConfig) ([]api.Variable, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	regex, err := regexp.Compile(filter)
+	if err != nil {
+		return nil, fmt.Errorf("invalid filter argument: %s", err.Error())
+	}
+
+	vars := []api.Variable{}
+	thread, found := d.target.Threads()[threadID]
+	if !found {
+		return nil, fmt.Errorf("couldn't find thread %d", threadID)
+	}
+	scope, err := thread.Scope()
+	if err != nil {
+		return nil, err
+	}
+	pv, err := scope.PackageVariables(cfg)
+	if err != nil {
+		return nil, err
+	}
+	for _, v := range pv {
+		if regex.Match([]byte(v.Name)) {
+			vars = append(vars, *api.ConvertVar(v))
+		}
+	}
+	return vars, err
+}
+
+// Registers returns string representation of the CPU registers.
+func (d *Debugger) Registers(threadID int, floatingPoint bool) (api.Registers, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	thread, found := d.target.Threads()[threadID]
+	if !found {
+		return nil, fmt.Errorf("couldn't find thread %d", threadID)
+	}
+	regs, err := thread.Registers(floatingPoint)
+	if err != nil {
+		return nil, err
+	}
+	return api.ConvertRegisters(regs.Slice()), err
+}
+
+func convertVars(pv []*proc.Variable) []api.Variable {
+	vars := make([]api.Variable, 0, len(pv))
+	for _, v := range pv {
+		vars = append(vars, *api.ConvertVar(v))
+	}
+	return vars
+}
+
+// LocalVariables returns a list of the local variables.
+func (d *Debugger) LocalVariables(scope api.EvalScope, cfg proc.LoadConfig) ([]api.Variable, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
+	if err != nil {
+		return nil, err
+	}
+	pv, err := s.LocalVariables(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return convertVars(pv), err
+}
+
+// FunctionArguments returns the arguments to the current function.
+func (d *Debugger) FunctionArguments(scope api.EvalScope, cfg proc.LoadConfig) ([]api.Variable, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
+	if err != nil {
+		return nil, err
+	}
+	pv, err := s.FunctionArguments(cfg)
+	if err != nil {
+		return nil, err
+	}
+	return convertVars(pv), nil
+}
+
+// EvalVariableInScope will attempt to evaluate the variable represented by 'symbol'
+// in the scope provided.
+func (d *Debugger) EvalVariableInScope(scope api.EvalScope, symbol string, cfg proc.LoadConfig) (*api.Variable, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
+	if err != nil {
+		return nil, err
+	}
+	v, err := s.EvalVariable(symbol, cfg)
+	if err != nil {
+		return nil, err
+	}
+	return api.ConvertVar(v), err
+}
+
+// SetVariableInScope will set the value of the variable represented by
+// 'symbol' to the value given, in the given scope.
+func (d *Debugger) SetVariableInScope(scope api.EvalScope, symbol, value string) error {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
+	if err != nil {
+		return err
+	}
+	return s.SetVariable(symbol, value)
+}
+
+// Goroutines will return a list of goroutines in the target process.
+func (d *Debugger) Goroutines() ([]*api.Goroutine, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	goroutines := []*api.Goroutine{}
+	gs, err := d.target.GoroutinesInfo()
+	if err != nil {
+		return nil, err
+	}
+	for _, g := range gs {
+		goroutines = append(goroutines, api.ConvertGoroutine(g))
+	}
+	return goroutines, err
+}
+
+// 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 (d *Debugger) Stacktrace(goroutineID, depth int, cfg *proc.LoadConfig) ([]api.Stackframe, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	var rawlocs []proc.Stackframe
+
+	g, err := d.target.FindGoroutine(goroutineID)
+	if err != nil {
+		return nil, err
+	}
+
+	if g == nil {
+		rawlocs, err = d.target.CurrentThread().Stacktrace(depth)
+	} else {
+		rawlocs, err = g.Stacktrace(depth)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return d.convertStacktrace(rawlocs, cfg)
+}
+
+func (d *Debugger) convertStacktrace(rawlocs []proc.Stackframe, cfg *proc.LoadConfig) ([]api.Stackframe, error) {
+	locations := make([]api.Stackframe, 0, len(rawlocs))
+	for i := range rawlocs {
+		frame := api.Stackframe{Location: api.ConvertLocation(rawlocs[i].Call)}
+		if cfg != nil && rawlocs[i].Current.Fn != nil {
+			var err error
+			scope := rawlocs[i].Scope(d.target.CurrentThread())
+			locals, err := scope.LocalVariables(*cfg)
+			if err != nil {
+				return nil, err
+			}
+			arguments, err := scope.FunctionArguments(*cfg)
+			if err != nil {
+				return nil, err
+			}
+
+			frame.Locals = convertVars(locals)
+			frame.Arguments = convertVars(arguments)
+		}
+		locations = append(locations, frame)
+	}
+
+	return locations, nil
+}
+
+// FindLocation will find the location specified by 'locStr'.
+func (d *Debugger) FindLocation(scope api.EvalScope, locStr string) ([]api.Location, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	loc, err := parseLocationSpec(locStr)
+	if err != nil {
+		return nil, err
+	}
+
+	s, _ := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
+
+	locs, err := loc.Find(d, s, locStr)
+	for i := range locs {
+		file, line, fn := d.target.PCToLine(locs[i].PC)
+		locs[i].File = file
+		locs[i].Line = line
+		locs[i].Function = api.ConvertFunction(fn)
+	}
+	return locs, err
+}
+
+// Disassembles code between startPC and endPC
+// if endPC == 0 it will find the function containing startPC and disassemble the whole function
+func (d *Debugger) Disassemble(scope api.EvalScope, startPC, endPC uint64, flavour api.AssemblyFlavour) (api.AsmInstructions, error) {
+	d.processMutex.Lock()
+	defer d.processMutex.Unlock()
+
+	if endPC == 0 {
+		_, _, fn := d.target.PCToLine(startPC)
+		if fn == nil {
+			return nil, fmt.Errorf("Address 0x%x does not belong to any function", startPC)
+		}
+		startPC = fn.Entry
+		endPC = fn.End
+	}
+
+	currentGoroutine := true
+	thread := d.target.CurrentThread()
+
+	if s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame); err == nil {
+		thread = s.Thread
+		if scope.GoroutineID != -1 {
+			g, _ := s.Thread.GetG()
+			if g == nil || g.ID != scope.GoroutineID {
+				currentGoroutine = false
+			}
+		}
+	}
+
+	insts, err := thread.Disassemble(startPC, endPC, currentGoroutine)
+	if err != nil {
+		return nil, err
+	}
+	disass := make(api.AsmInstructions, len(insts))
+
+	for i := range insts {
+		disass[i] = api.ConvertAsmInstruction(insts[i], insts[i].Text(proc.AssemblyFlavour(flavour)))
+	}
+
+	return disass, nil
+}