PenaDevops/delve
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Minor post-refactoring cleanup (#808)

Browse Source 
* proc/native: remove unused utility methods

* proc: turn FindFileLocation, FindFunctionLocation, FirstPCAfterPrologue methods into function
This commit is contained in:
Alessandro Arzilli 2017-04-28 19:15:39 +02:00 committed by Derek Parker
parent 24b20099aa
commit a731eb661f
11 changed files with 48 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
pkg/proc/core/core.go
View File

@ -1,7 +1,6 @@
package core
import (
"debug/gosym"
"errors"
"fmt"
"go/ast"
@ -277,18 +276,6 @@ func (p *Process) Exited() bool {
return false
}
func (p *Process) FindFileLocation(fileName string, lineNumber int) (uint64, error) {
return proc.FindFileLocation(p.CurrentThread(), p.breakpoints, &p.bi, fileName, lineNumber)
}
func (p *Process) FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error) {
return proc.FirstPCAfterPrologue(p.CurrentThread(), p.breakpoints, &p.bi, fn, sameline)
}
func (p *Process) FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error) {
return proc.FindFunctionLocation(p.CurrentThread(), p.breakpoints, &p.bi, funcName, firstLine, lineOffset)
}
func (p *Process) AllGCache() *[]*proc.G {
return &p.allGCache
}

5
pkg/proc/disasm_amd64.go
View File

@ -142,7 +142,10 @@ func init() {
// FirstPCAfterPrologue returns the address of the first instruction after the prologue for function fn
// If sameline is set FirstPCAfterPrologue will always return an address associated with the same line as fn.Entry
func FirstPCAfterPrologue(mem MemoryReadWriter, breakpoints map[uint64]*Breakpoint, bi *BinaryInfo, fn *gosym.Func, sameline bool) (uint64, error) {
func FirstPCAfterPrologue(p Process, fn *gosym.Func, sameline bool) (uint64, error) {
var mem MemoryReadWriter = p.CurrentThread()
breakpoints := p.Breakpoints()
bi := p.BinInfo()
text, err := disassemble(mem, nil, breakpoints, bi, fn.Entry, fn.End)
if err != nil {
return fn.Entry, err

15
pkg/proc/gdbserial/gdbserver.go
View File

@ -62,7 +62,6 @@
package gdbserial
import (
"debug/gosym"
"encoding/binary"
"errors"
"fmt"
@ -259,7 +258,7 @@ func Connect(addr string, path string, pid int, attempts int) (*Process, error)
p.bi.Arch.SetGStructOffset(ver, isextld)
p.selectedGoroutine, _ = proc.GetG(p.CurrentThread())
panicpc, err := p.FindFunctionLocation("runtime.startpanic", true, 0)
panicpc, err := proc.FindFunctionLocation(p, "runtime.startpanic", true, 0)
if err == nil {
bp, err := p.SetBreakpoint(panicpc, proc.UserBreakpoint, nil)
if err == nil {
@ -417,18 +416,6 @@ func (p *Process) Running() bool {
return p.conn.running
}
func (p *Process) FindFileLocation(fileName string, lineNumber int) (uint64, error) {
return proc.FindFileLocation(p.CurrentThread(), p.breakpoints, &p.bi, fileName, lineNumber)
}
func (p *Process) FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error) {
return proc.FirstPCAfterPrologue(p.CurrentThread(), p.breakpoints, &p.bi, fn, sameline)
}
func (p *Process) FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error) {
return proc.FindFunctionLocation(p.CurrentThread(), p.breakpoints, &p.bi, funcName, firstLine, lineOffset)
}
func (p *Process) FindThread(threadID int) (proc.Thread, bool) {
thread, ok := p.threads[threadID]
return thread, ok

25
pkg/proc/interface.go
View File

@ -1,7 +1,6 @@
package proc
import (
"debug/gosym"
"go/ast"
)
@ -22,30 +21,6 @@ type Info interface {
ThreadInfo
GoroutineInfo
// FindFileLocation returns the address of the first instruction belonging
// to line lineNumber in file fileName.
FindFileLocation(fileName string, lineNumber int) (uint64, error)
// FirstPCAfterPrologue returns the first instruction address after fn's
// prologue.
// If sameline is true and the first instruction after the prologue belongs
// to a different source line the entry point will be returned instead.
FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error)
// FindFunctionLocation finds address of a function's line
//
// If firstLine == true is passed FindFunctionLocation will attempt to find
// the first line of the function.
//
// If lineOffset is passed FindFunctionLocation will return the address of
// that line.
//
// Pass lineOffset == 0 and firstLine == false if you want the address for
// the function's entry point. Note that setting breakpoints at that
// address will cause surprising behavior:
// https://github.com/derekparker/delve/issues/170
FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error)
}
// ThreadInfo is an interface for getting information on active threads

68
pkg/proc/native/proc.go
View File

@ -1,7 +1,6 @@
package native
import (
"debug/gosym"
"errors"
"fmt"
"go/ast"
@ -165,23 +164,6 @@ func (dbp *Process) LoadInformation(path string) error {
return nil
}
func (dbp *Process) FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error) {
return proc.FindFunctionLocation(dbp.currentThread, dbp.breakpoints, &dbp.bi, funcName, firstLine, lineOffset)
}
func (dbp *Process) FindFileLocation(fileName string, lineno int) (uint64, error) {
return proc.FindFileLocation(dbp.currentThread, dbp.breakpoints, &dbp.bi, fileName, lineno)
}
func (dbp *Process) FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error) {
return proc.FirstPCAfterPrologue(dbp.currentThread, dbp.breakpoints, &dbp.bi, fn, sameline)
}
// CurrentLocation returns the location of the current thread.
func (dbp *Process) CurrentLocation() (*proc.Location, error) {
return dbp.currentThread.Location()
}
// RequestManualStop sets the `halt` flag and
// sends SIGSTOP to all threads.
func (dbp *Process) RequestManualStop() error {
@ -259,11 +241,6 @@ func (dbp *Process) ClearBreakpoint(addr uint64) (*proc.Breakpoint, error) {
return bp, nil
}
// Status returns the status of the current main thread context.
func (dbp *Process) Status() *WaitStatus {
return dbp.currentThread.Status
}
func (dbp *Process) ContinueOnce() (proc.Thread, error) {
if dbp.exited {
return nil, &proc.ProcessExitedError{}
@ -365,33 +342,6 @@ func (dbp *Process) Halt() (err error) {
return nil
}
// Registers obtains register values from the
// "current" thread of the traced process.
func (dbp *Process) Registers() (proc.Registers, error) {
return dbp.currentThread.Registers(false)
}
// PC returns the PC of the current thread.
func (dbp *Process) PC() (uint64, error) {
return dbp.currentThread.PC()
}
// CurrentBreakpoint returns the breakpoint the current thread
// is stopped at.
func (dbp *Process) CurrentBreakpoint() *proc.Breakpoint {
return dbp.currentThread.CurrentBreakpoint
}
// FindBreakpointByID finds the breakpoint for the given ID.
func (dbp *Process) FindBreakpointByID(id int) (*proc.Breakpoint, bool) {
for _, bp := range dbp.breakpoints {
if bp.ID == id {
return bp, true
}
}
return nil, false
}
// FindBreakpoint finds the breakpoint for the given pc.
func (dbp *Process) FindBreakpoint(pc uint64) (*proc.Breakpoint, bool) {
// Check to see if address is past the breakpoint, (i.e. breakpoint was hit).
@ -446,7 +396,7 @@ func initializeDebugProcess(dbp *Process, path string, attach bool) (*Process, e
// the offset of g struct inside TLS
dbp.selectedGoroutine, _ = proc.GetG(dbp.currentThread)
panicpc, err := dbp.FindFunctionLocation("runtime.startpanic", true, 0)
panicpc, err := proc.FindFunctionLocation(dbp, "runtime.startpanic", true, 0)
if err == nil {
bp, err := dbp.SetBreakpoint(panicpc, proc.UserBreakpoint, nil)
if err == nil {
@ -507,19 +457,3 @@ func (dbp *Process) writeSoftwareBreakpoint(thread *Thread, addr uint64) error {
func (dbp *Process) AllGCache() *[]*proc.G {
return &dbp.allGCache
}
/*
// EvalPackageVariable will evaluate the package level variable
// specified by 'name'.
func (dbp *Process) EvalPackageVariable(name string, cfg proc.LoadConfig) (*proc.Variable, error) {
scope := &proc.EvalScope{0, 0, dbp.currentThread, nil, dbp.BinInfo()}
v, err := scope.packageVarAddr(name)
if err != nil {
return nil, err
}
v.loadValue(cfg)
return v, nil
}
*/

1
pkg/proc/native/threads.go
View File

@ -189,7 +189,6 @@ func (t *Thread) Registers(floatingPoint bool) (proc.Registers, error) {
return registers(t, floatingPoint)
}
// PC returns the current PC for this thread.
func (t *Thread) PC() (uint64, error) {
regs, err := t.Registers(false)
if err != nil {

13
pkg/proc/proc.go
View File

@ -34,13 +34,13 @@ func (pe ProcessExitedError) Error() string {
// FindFileLocation returns the PC for a given file:line.
// Assumes that `file` is normailzed to lower case and '/' on Windows.
func FindFileLocation(mem MemoryReadWriter, breakpoints map[uint64]*Breakpoint, bi *BinaryInfo, fileName string, lineno int) (uint64, error) {
pc, fn, err := bi.goSymTable.LineToPC(fileName, lineno)
func FindFileLocation(p Process, fileName string, lineno int) (uint64, error) {
pc, fn, err := p.BinInfo().goSymTable.LineToPC(fileName, lineno)
if err != nil {
return 0, err
}
if fn.Entry == pc {
pc, _ = FirstPCAfterPrologue(mem, breakpoints, bi, fn, true)
pc, _ = FirstPCAfterPrologue(p, fn, true)
}
return pc, nil
}
@ -51,14 +51,15 @@ func FindFileLocation(mem MemoryReadWriter, breakpoints map[uint64]*Breakpoint,
// Pass lineOffset == 0 and firstLine == false if you want the address for the function's entry point
// Note that setting breakpoints at that address will cause surprising behavior:
// https://github.com/derekparker/delve/issues/170
func FindFunctionLocation(mem MemoryReadWriter, breakpoints map[uint64]*Breakpoint, bi *BinaryInfo, funcName string, firstLine bool, lineOffset int) (uint64, error) {
func FindFunctionLocation(p Process, funcName string, firstLine bool, lineOffset int) (uint64, error) {
bi := p.BinInfo()
origfn := bi.goSymTable.LookupFunc(funcName)
if origfn == nil {
return 0, fmt.Errorf("Could not find function %s\n", funcName)
}
if firstLine {
return FirstPCAfterPrologue(mem, breakpoints, bi, origfn, false)
return FirstPCAfterPrologue(p, origfn, false)
} else if lineOffset > 0 {
filename, lineno, _ := bi.goSymTable.PCToLine(origfn.Entry)
breakAddr, _, err := bi.goSymTable.LineToPC(filename, lineno+lineOffset)
@ -272,7 +273,7 @@ func StepOut(dbp Process) error {
deferPCEntry := selg.DeferPC()
if deferPCEntry != 0 {
_, _, deferfn := dbp.BinInfo().PCToLine(deferPCEntry)
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
deferpc, err = FirstPCAfterPrologue(dbp, deferfn, false)
if err != nil {
return err
}

44
pkg/proc/proc_test.go
View File

@ -168,7 +168,7 @@ func TestExitAfterContinue(t *testing.T) {
}
func setFunctionBreakpoint(p proc.Process, fname string) (*proc.Breakpoint, error) {
addr, err := p.FindFunctionLocation(fname, true, 0)
addr, err := proc.FindFunctionLocation(p, fname, true, 0)
if err != nil {
return nil, err
}
@ -176,7 +176,7 @@ func setFunctionBreakpoint(p proc.Process, fname string) (*proc.Breakpoint, erro
}
func setFileBreakpoint(p proc.Process, t *testing.T, fixture protest.Fixture, lineno int) *proc.Breakpoint {
addr, err := p.FindFileLocation(fixture.Source, lineno)
addr, err := proc.FindFileLocation(p, fixture.Source, lineno)
if err != nil {
t.Fatalf("FindFileLocation: %v", err)
}
@ -235,7 +235,7 @@ func TestHalt(t *testing.T) {
func TestStep(t *testing.T) {
withTestProcess("testprog", t, func(p proc.Process, fixture protest.Fixture) {
helloworldaddr, err := p.FindFunctionLocation("main.helloworld", false, 0)
helloworldaddr, err := proc.FindFunctionLocation(p, "main.helloworld", false, 0)
assertNoError(err, t, "FindFunctionLocation")
_, err = p.SetBreakpoint(helloworldaddr, proc.UserBreakpoint, nil)
@ -257,7 +257,7 @@ func TestStep(t *testing.T) {
func TestBreakpoint(t *testing.T) {
withTestProcess("testprog", t, func(p proc.Process, fixture protest.Fixture) {
helloworldaddr, err := p.FindFunctionLocation("main.helloworld", false, 0)
helloworldaddr, err := proc.FindFunctionLocation(p, "main.helloworld", false, 0)
assertNoError(err, t, "FindFunctionLocation")
bp, err := p.SetBreakpoint(helloworldaddr, proc.UserBreakpoint, nil)
@ -281,7 +281,7 @@ func TestBreakpoint(t *testing.T) {
func TestBreakpointInSeperateGoRoutine(t *testing.T) {
withTestProcess("testthreads", t, func(p proc.Process, fixture protest.Fixture) {
fnentry, err := p.FindFunctionLocation("main.anotherthread", false, 0)
fnentry, err := proc.FindFunctionLocation(p, "main.anotherthread", false, 0)
assertNoError(err, t, "FindFunctionLocation")
_, err = p.SetBreakpoint(fnentry, proc.UserBreakpoint, nil)
@ -311,7 +311,7 @@ func TestBreakpointWithNonExistantFunction(t *testing.T) {
func TestClearBreakpointBreakpoint(t *testing.T) {
withTestProcess("testprog", t, func(p proc.Process, fixture protest.Fixture) {
fnentry, err := p.FindFunctionLocation("main.sleepytime", false, 0)
fnentry, err := proc.FindFunctionLocation(p, "main.sleepytime", false, 0)
assertNoError(err, t, "FindFunctionLocation")
bp, err := p.SetBreakpoint(fnentry, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
@ -362,7 +362,7 @@ func testseq(program string, contFunc contFunc, testcases []nextTest, initialLoc
bp, err = setFunctionBreakpoint(p, initialLocation)
} else {
var pc uint64
pc, err = p.FindFileLocation(fixture.Source, testcases[0].begin)
pc, err = proc.FindFileLocation(p, fixture.Source, testcases[0].begin)
assertNoError(err, t, "FindFileLocation()")
bp, err = p.SetBreakpoint(pc, proc.UserBreakpoint, nil)
}
@ -655,7 +655,7 @@ func TestFindReturnAddress(t *testing.T) {
func TestFindReturnAddressTopOfStackFn(t *testing.T) {
withTestProcess("testreturnaddress", t, func(p proc.Process, fixture protest.Fixture) {
fnName := "runtime.rt0_go"
fnentry, err := p.FindFunctionLocation(fnName, false, 0)
fnentry, err := proc.FindFunctionLocation(p, fnName, false, 0)
assertNoError(err, t, "FindFunctionLocation")
if _, err := p.SetBreakpoint(fnentry, proc.UserBreakpoint, nil); err != nil {
t.Fatal(err)
@ -676,7 +676,7 @@ func TestSwitchThread(t *testing.T) {
if err == nil {
t.Fatal("Expected error for invalid thread id")
}
pc, err := p.FindFunctionLocation("main.main", true, 0)
pc, err := proc.FindFunctionLocation(p, "main.main", true, 0)
if err != nil {
t.Fatal(err)
}
@ -721,7 +721,7 @@ func TestCGONext(t *testing.T) {
}
withTestProcess("cgotest", t, func(p proc.Process, fixture protest.Fixture) {
pc, err := p.FindFunctionLocation("main.main", true, 0)
pc, err := proc.FindFunctionLocation(p, "main.main", true, 0)
if err != nil {
t.Fatal(err)
}
@ -1022,7 +1022,7 @@ func TestParseVersionString(t *testing.T) {
func TestBreakpointOnFunctionEntry(t *testing.T) {
withTestProcess("testprog", t, func(p proc.Process, fixture protest.Fixture) {
addr, err := p.FindFunctionLocation("main.main", false, 0)
addr, err := proc.FindFunctionLocation(p, "main.main", false, 0)
assertNoError(err, t, "FindFunctionLocation()")
_, err = p.SetBreakpoint(addr, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
@ -1690,9 +1690,9 @@ func TestIssue332_Part2(t *testing.T) {
regs, err := p.CurrentThread().Registers(false)
assertNoError(err, t, "Registers()")
pc := regs.PC()
pcAfterPrologue, err := p.FindFunctionLocation("main.changeMe", true, -1)
pcAfterPrologue, err := proc.FindFunctionLocation(p, "main.changeMe", true, -1)
assertNoError(err, t, "FindFunctionLocation()")
pcEntry, err := p.FindFunctionLocation("main.changeMe", false, 0)
pcEntry, err := proc.FindFunctionLocation(p, "main.changeMe", false, 0)
if pcAfterPrologue == pcEntry {
t.Fatalf("main.changeMe and main.changeMe:0 are the same (%x)", pcAfterPrologue)
}
@ -1712,7 +1712,7 @@ func TestIssue332_Part2(t *testing.T) {
func TestIssue396(t *testing.T) {
withTestProcess("callme", t, func(p proc.Process, fixture protest.Fixture) {
_, err := p.FindFunctionLocation("main.init", true, -1)
_, err := proc.FindFunctionLocation(p, "main.init", true, -1)
assertNoError(err, t, "FindFunctionLocation()")
})
}
@ -1765,7 +1765,7 @@ func TestIssue149(t *testing.T) {
}
// setting breakpoint on break statement
withTestProcess("break", t, func(p proc.Process, fixture protest.Fixture) {
_, err := p.FindFileLocation(fixture.Source, 8)
_, err := proc.FindFileLocation(p, fixture.Source, 8)
assertNoError(err, t, "FindFileLocation()")
})
}
@ -1991,7 +1991,7 @@ func TestIssue573(t *testing.T) {
// calls to runtime.duffzero and runtime.duffcopy jump directly into the middle
// of the function and the internal breakpoint set by StepInto may be missed.
withTestProcess("issue573", t, func(p proc.Process, fixture protest.Fixture) {
fentry, _ := p.FindFunctionLocation("main.foo", false, 0)
fentry, _ := proc.FindFunctionLocation(p, "main.foo", false, 0)
_, err := p.SetBreakpoint(fentry, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
assertNoError(proc.Continue(p), t, "Continue()")
@ -2003,9 +2003,9 @@ func TestIssue573(t *testing.T) {
func TestTestvariables2Prologue(t *testing.T) {
withTestProcess("testvariables2", t, func(p proc.Process, fixture protest.Fixture) {
addrEntry, err := p.FindFunctionLocation("main.main", false, 0)
addrEntry, err := proc.FindFunctionLocation(p, "main.main", false, 0)
assertNoError(err, t, "FindFunctionLocation - entrypoint")
addrPrologue, err := p.FindFunctionLocation("main.main", true, 0)
addrPrologue, err := proc.FindFunctionLocation(p, "main.main", true, 0)
assertNoError(err, t, "FindFunctionLocation - postprologue")
if addrEntry == addrPrologue {
t.Fatalf("Prologue detection failed on testvariables2.go/main.main")
@ -2146,7 +2146,7 @@ func TestStepOut(t *testing.T) {
func TestStepConcurrentDirect(t *testing.T) {
withTestProcess("teststepconcurrent", t, func(p proc.Process, fixture protest.Fixture) {
pc, err := p.FindFileLocation(fixture.Source, 37)
pc, err := proc.FindFileLocation(p, fixture.Source, 37)
assertNoError(err, t, "FindFileLocation()")
bp, err := p.SetBreakpoint(pc, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
@ -2220,7 +2220,7 @@ func nextInProgress(p proc.Process) bool {
func TestStepConcurrentPtr(t *testing.T) {
withTestProcess("teststepconcurrent", t, func(p proc.Process, fixture protest.Fixture) {
pc, err := p.FindFileLocation(fixture.Source, 24)
pc, err := proc.FindFileLocation(p, fixture.Source, 24)
assertNoError(err, t, "FindFileLocation()")
_, err = p.SetBreakpoint(pc, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
@ -2299,7 +2299,7 @@ func TestStepConcurrentPtr(t *testing.T) {
func TestStepOutDefer(t *testing.T) {
withTestProcess("testnextdefer", t, func(p proc.Process, fixture protest.Fixture) {
pc, err := p.FindFileLocation(fixture.Source, 9)
pc, err := proc.FindFileLocation(p, fixture.Source, 9)
assertNoError(err, t, "FindFileLocation()")
bp, err := p.SetBreakpoint(pc, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")
@ -2342,7 +2342,7 @@ const maxInstructionLength uint64 = 15
func TestStepOnCallPtrInstr(t *testing.T) {
withTestProcess("teststepprog", t, func(p proc.Process, fixture protest.Fixture) {
pc, err := p.FindFileLocation(fixture.Source, 10)
pc, err := proc.FindFileLocation(p, fixture.Source, 10)
assertNoError(err, t, "FindFileLocation()")
_, err = p.SetBreakpoint(pc, proc.UserBreakpoint, nil)
assertNoError(err, t, "SetBreakpoint()")

4
pkg/proc/threads.go
View File

@ -158,7 +158,7 @@ func next(dbp Process, stepInto bool) error {
if deferPCEntry != 0 {
_, _, deferfn := dbp.BinInfo().PCToLine(deferPCEntry)
var err error
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
deferpc, err = FirstPCAfterPrologue(dbp, deferfn, false)
if err != nil {
return err
}
@ -236,7 +236,7 @@ func setStepIntoBreakpoint(dbp Process, text []AsmInstruction, cond ast.Expr) er
// those extra checks should be done here.
// Set a breakpoint after the function's prologue
pc, _ := dbp.FirstPCAfterPrologue(fn, false)
pc, _ := FirstPCAfterPrologue(dbp, fn, false)
if _, err := dbp.SetBreakpoint(pc, NextBreakpoint, cond); err != nil {
if _, ok := err.(BreakpointExistsError); !ok {
return err

8
service/debugger/debugger.go
View File

@ -203,7 +203,7 @@ func (d *Debugger) Restart() ([]api.DiscardedBreakpoint, error) {
continue
}
if len(oldBp.File) > 0 {
oldBp.Addr, err = p.FindFileLocation(oldBp.File, oldBp.Line)
oldBp.Addr, err = proc.FindFileLocation(p, oldBp.File, oldBp.Line)
if err != nil {
discarded = append(discarded, api.DiscardedBreakpoint{oldBp, err.Error()})
continue
@ -298,12 +298,12 @@ func (d *Debugger) CreateBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoin
}
}
}
addr, err = d.target.FindFileLocation(fileName, requestedBp.Line)
addr, err = proc.FindFileLocation(d.target, fileName, requestedBp.Line)
case len(requestedBp.FunctionName) > 0:
if requestedBp.Line >= 0 {
addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, false, requestedBp.Line)
addr, err = proc.FindFunctionLocation(d.target, requestedBp.FunctionName, false, requestedBp.Line)
} else {
addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, true, 0)
addr, err = proc.FindFunctionLocation(d.target, requestedBp.FunctionName, true, 0)
}
default:
addr = requestedBp.Addr

14
service/debugger/locations.go
View File

@ -250,7 +250,7 @@ func (loc *RegexLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr st
}
r := make([]api.Location, 0, len(matches))
for i := range matches {
addr, err := d.target.FindFunctionLocation(matches[i], true, 0)
addr, err := proc.FindFunctionLocation(d.target, matches[i], true, 0)
if err == nil {
r = append(r, api.Location{PC: addr})
}
@ -279,7 +279,7 @@ func (loc *AddrLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr str
return []api.Location{{PC: addr}}, nil
case reflect.Func:
_, _, fn := d.target.BinInfo().PCToLine(uint64(v.Base))
pc, err := d.target.FirstPCAfterPrologue(fn, false)
pc, err := proc.FirstPCAfterPrologue(d.target, fn, false)
if err != nil {
return nil, err
}
@ -366,12 +366,12 @@ func (loc *NormalLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr s
if loc.LineOffset < 0 {
return nil, fmt.Errorf("Malformed breakpoint location, no line offset specified")
}
addr, err = d.target.FindFileLocation(candidates[0], loc.LineOffset)
addr, err = proc.FindFileLocation(d.target, candidates[0], loc.LineOffset)
} else {
if loc.LineOffset < 0 {
addr, err = d.target.FindFunctionLocation(candidates[0], true, 0)
addr, err = proc.FindFunctionLocation(d.target, candidates[0], true, 0)
} else {
addr, err = d.target.FindFunctionLocation(candidates[0], false, loc.LineOffset)
addr, err = proc.FindFunctionLocation(d.target, candidates[0], false, loc.LineOffset)
}
}
if err != nil {
@ -394,7 +394,7 @@ func (loc *OffsetLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr s
if fn == nil {
return nil, fmt.Errorf("could not determine current location")
}
addr, err := d.target.FindFileLocation(file, line+loc.Offset)
addr, err := proc.FindFileLocation(d.target, file, line+loc.Offset)
return []api.Location{{PC: addr}}, err
}
@ -406,6 +406,6 @@ func (loc *LineLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr str
if fn == nil {
return nil, fmt.Errorf("could not determine current location")
}
addr, err := d.target.FindFileLocation(file, loc.Line)
addr, err := proc.FindFileLocation(d.target, file, loc.Line)
return []api.Location{{PC: addr}}, err
}