From a731eb661ff830758689fb0910e0431b2f8b2f4f Mon Sep 17 00:00:00 2001 From: Alessandro Arzilli Date: Fri, 28 Apr 2017 19:15:39 +0200 Subject: [PATCH] Minor post-refactoring cleanup (#808) * proc/native: remove unused utility methods * proc: turn FindFileLocation, FindFunctionLocation, FirstPCAfterPrologue methods into function --- pkg/proc/core/core.go | 13 ------- pkg/proc/disasm_amd64.go | 5 ++- pkg/proc/gdbserial/gdbserver.go | 15 +------- pkg/proc/interface.go | 25 ------------ pkg/proc/native/proc.go | 68 +-------------------------------- pkg/proc/native/threads.go | 1 - pkg/proc/proc.go | 13 ++++--- pkg/proc/proc_test.go | 44 ++++++++++----------- pkg/proc/threads.go | 4 +- service/debugger/debugger.go | 8 ++-- service/debugger/locations.go | 14 +++---- 11 files changed, 48 insertions(+), 162 deletions(-) diff --git a/pkg/proc/core/core.go b/pkg/proc/core/core.go index 3afe4ada..bd388bfe 100644 --- a/pkg/proc/core/core.go +++ b/pkg/proc/core/core.go @@ -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 } diff --git a/pkg/proc/disasm_amd64.go b/pkg/proc/disasm_amd64.go index ca45cc29..2f9dbada 100644 --- a/pkg/proc/disasm_amd64.go +++ b/pkg/proc/disasm_amd64.go @@ -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 diff --git a/pkg/proc/gdbserial/gdbserver.go b/pkg/proc/gdbserial/gdbserver.go index 07dfe173..6ddc33d4 100644 --- a/pkg/proc/gdbserial/gdbserver.go +++ b/pkg/proc/gdbserial/gdbserver.go @@ -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 diff --git a/pkg/proc/interface.go b/pkg/proc/interface.go index 6774ae5d..aba30620 100644 --- a/pkg/proc/interface.go +++ b/pkg/proc/interface.go @@ -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 diff --git a/pkg/proc/native/proc.go b/pkg/proc/native/proc.go index 1795e01b..500072ec 100644 --- a/pkg/proc/native/proc.go +++ b/pkg/proc/native/proc.go @@ -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 -} -*/ diff --git a/pkg/proc/native/threads.go b/pkg/proc/native/threads.go index e4469bcd..70723323 100644 --- a/pkg/proc/native/threads.go +++ b/pkg/proc/native/threads.go @@ -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 { diff --git a/pkg/proc/proc.go b/pkg/proc/proc.go index 88dbe6a0..f37deab1 100644 --- a/pkg/proc/proc.go +++ b/pkg/proc/proc.go @@ -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 } diff --git a/pkg/proc/proc_test.go b/pkg/proc/proc_test.go index 1b21ae5b..b828e88e 100644 --- a/pkg/proc/proc_test.go +++ b/pkg/proc/proc_test.go @@ -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()") diff --git a/pkg/proc/threads.go b/pkg/proc/threads.go index 65596197..0dd91280 100644 --- a/pkg/proc/threads.go +++ b/pkg/proc/threads.go @@ -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 diff --git a/service/debugger/debugger.go b/service/debugger/debugger.go index 6d9c92ee..a8d237c0 100644 --- a/service/debugger/debugger.go +++ b/service/debugger/debugger.go @@ -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 diff --git a/service/debugger/locations.go b/service/debugger/locations.go index ba1e95f8..15316b63 100644 --- a/service/debugger/locations.go +++ b/service/debugger/locations.go @@ -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 }