Skip to content

D
delve

pubx / delve

通知 0
Star 0
Fork 0
D
delve

体验新版 GitCode，发现更多精彩内容 >>

提交 a731eb66 编写于 作者: A Alessandro Arzilli 提交者： Derek Parker
浏览文件
操作

Minor post-refactoring cleanup (#808) 

* proc/native: remove unused utility methods

* proc: turn FindFileLocation, FindFunctionLocation, FirstPCAfterPrologue methods into function
上级 24b20099
隐藏空白更改
内联 并排
Showing with 48 addition and 162 deletion
pkg/proc/core/core.go
浏览文件 @ a731eb66
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
}
......
pkg/proc/disasm_amd64.go
浏览文件 @ a731eb66
......@@ -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
......
pkg/proc/gdbserial/gdbserver.go
浏览文件 @ a731eb66
......@@ -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
......
pkg/proc/interface.go
浏览文件 @ a731eb66
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
......
pkg/proc/native/proc.go
浏览文件 @ a731eb66
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
}
*/
pkg/proc/native/threads.go
浏览文件 @ a731eb66
......@@ -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 {
......
pkg/proc/proc.go
浏览文件 @ a731eb66
......@@ -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
}
......
pkg/proc/proc_test.go
浏览文件 @ a731eb66
......@@ -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()")
......
pkg/proc/threads.go
浏览文件 @ a731eb66
......@@ -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
......
service/debugger/debugger.go
浏览文件 @ a731eb66
......@@ -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
......
service/debugger/locations.go
浏览文件 @ a731eb66
......@@ -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
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或