lbsadmin/bee
1
0
Fork 0
mirror of https://github.com/beego/bee.git synced 2024-11-22 05:00:54 +00:00
Code Issues Releases Activity

Merge pull request #392 from beego/hotfix-dlv-support

Browse Source 
Use conditional build for Delve support
This commit is contained in:
astaxie 2017-04-07 22:45:59 +08:00 committed by GitHub
commit 52a37a86a9
73 changed files with 718 additions and 1066 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -13,7 +13,7 @@ install:
script:
- go vet $(go list ./... | grep -v /vendor/)
- structcheck $(go list ./... | grep -v /vendor/)
- gosimple -ignore "github.com/beego/bee/cmd/commands/run/*.go:S1024" $(go list ./... | grep -v /vendor/)
- gosimple -ignore "$(cat gosimple.ignore)" $(go list ./... | grep -v /vendor/)
- staticcheck $(go list ./... | grep -v /vendor/)
- unused $(go list ./... | grep -v /vendor/)
- unconvert $(go list ./... | grep -v /vendor/)

119
cmd/commands/dlv/dlv.go
View File

@ -14,122 +14,3 @@
// Package dlv ...
package dlv
import (
"flag"
"fmt"
"net"
"os"
"path/filepath"
"github.com/beego/bee/cmd/commands"
"github.com/beego/bee/cmd/commands/version"
beeLogger "github.com/beego/bee/logger"
"github.com/beego/bee/utils"
"github.com/derekparker/delve/pkg/terminal"
"github.com/derekparker/delve/service"
"github.com/derekparker/delve/service/rpc2"
"github.com/derekparker/delve/service/rpccommon"
)
var cmdDlv = &commands.Command{
CustomFlags: true,
UsageLine: "dlv [-package=\"\"] [-port=8181]",
Short: "Start a debugging session using Delve",
Long: `dlv command start a debugging session using debugging tool Delve.
To debug your application using Delve, use: {{"$ bee dlv" | bold}}
For more information on Delve: https://github.com/derekparker/delve
`,
PreRun: func(cmd *commands.Command, args []string) { version.ShowShortVersionBanner() },
Run: runDlv,
}
var (
packageName string
port int
)
func init() {
fs := flag.NewFlagSet("dlv", flag.ContinueOnError)
fs.IntVar(&port, "port", 8181, "Port to listen to for clients")
fs.StringVar(&packageName, "package", "", "The package to debug (Must have a main package)")
cmdDlv.Flag = *fs
commands.AvailableCommands = append(commands.AvailableCommands, cmdDlv)
}
func runDlv(cmd *commands.Command, args []string) int {
if err := cmd.Flag.Parse(args); err != nil {
beeLogger.Log.Fatalf("Error parsing flags: %v", err.Error())
}
debugname := "debug"
addr := fmt.Sprintf("127.0.0.1:%d", port)
return runDelve(addr, debugname)
}
// runDelve runs the Delve debugger server
func runDelve(addr, debugname string) int {
beeLogger.Log.Info("Starting Delve Debugger...")
err := gobuild(debugname, packageName)
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
fp, err := filepath.Abs("./" + debugname)
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
defer os.Remove(fp)
abs, err := filepath.Abs(debugname)
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
// Create and start the debugger server
listener, err := net.Listen("tcp", addr)
if err != nil {
beeLogger.Log.Fatalf("Could not start listener: %s", err)
}
defer listener.Close()
server := rpccommon.NewServer(&service.Config{
Listener: listener,
AcceptMulti: true,
AttachPid: 0,
APIVersion: 2,
WorkingDir: "./",
ProcessArgs: []string{abs},
}, false)
if err := server.Run(); err != nil {
beeLogger.Log.Fatalf("Could not start debugger server: %v", err)
}
// Start the Delve client REPL
client := rpc2.NewClient(addr)
term := terminal.New(client, nil)
status, err := term.Run()
if err != nil {
beeLogger.Log.Fatalf("Could not start Delve REPL: %v", err)
}
defer term.Close()
// Stop and kill the debugger server once
// user quits the REPL
if err := server.Stop(true); err != nil {
beeLogger.Log.Fatalf("Could not stop Delve server: %v", err)
}
return status
}
// gobuild runs the "go build" command on the specified package
func gobuild(debugname, pkg string) error {
args := []string{"-gcflags", "-N -l", "-o", debugname}
args = append(args, utils.SplitQuotedFields("-ldflags='-linkmode internal'")...)
args = append(args, pkg)
return utils.GoCommand("build", args...)
}

245
cmd/commands/dlv/dlv_amd64.go Normal file
View File

@ -0,0 +1,245 @@
// Copyright 2017 bee authors
//
// Licensed under the Apache License, Version 2.0 (the "License"): you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
// Package dlv ...
package dlv
import (
"flag"
"fmt"
"net"
"os"
"path/filepath"
"strings"
"time"
"github.com/beego/bee/cmd/commands"
"github.com/beego/bee/cmd/commands/version"
beeLogger "github.com/beego/bee/logger"
"github.com/beego/bee/utils"
"github.com/derekparker/delve/service"
"github.com/derekparker/delve/service/rpc2"
"github.com/derekparker/delve/service/rpccommon"
"github.com/derekparker/delve/terminal"
"github.com/fsnotify/fsnotify"
)
var cmdDlv = &commands.Command{
CustomFlags: true,
UsageLine: "dlv [-package=\"\"] [-port=8181] [-verbose=false]",
Short: "Start a debugging session using Delve",
Long: `dlv command start a debugging session using debugging tool Delve.
To debug your application using Delve, use: {{"$ bee dlv" | bold}}
For more information on Delve: https://github.com/derekparker/delve
`,
PreRun: func(cmd *commands.Command, args []string) { version.ShowShortVersionBanner() },
Run: runDlv,
}
var (
packageName string
verbose bool
port int
)
func init() {
fs := flag.NewFlagSet("dlv", flag.ContinueOnError)
fs.StringVar(&packageName, "package", "", "The package to debug (Must have a main package)")
fs.BoolVar(&verbose, "verbose", false, "Enable verbose mode")
fs.IntVar(&port, "port", 8181, "Port to listen to for clients")
cmdDlv.Flag = *fs
commands.AvailableCommands = append(commands.AvailableCommands, cmdDlv)
}
func runDlv(cmd *commands.Command, args []string) int {
if err := cmd.Flag.Parse(args); err != nil {
beeLogger.Log.Fatalf("Error while parsing flags: %v", err.Error())
}
var (
addr = fmt.Sprintf("127.0.0.1:%d", port)
paths = make([]string, 0)
notifyChan = make(chan int)
)
if err := loadPathsToWatch(&paths); err != nil {
beeLogger.Log.Fatalf("Error while loading paths to watch: %v", err.Error())
}
go startWatcher(paths, notifyChan)
return startDelveDebugger(addr, notifyChan)
}
// buildDebug builds a debug binary in the current working directory
func buildDebug() (string, error) {
args := []string{"-gcflags", "-N -l", "-o", "debug"}
args = append(args, utils.SplitQuotedFields("-ldflags='-linkmode internal'")...)
args = append(args, packageName)
if err := utils.GoCommand("build", args...); err != nil {
return "", err
}
fp, err := filepath.Abs("./debug")
if err != nil {
return "", err
}
return fp, nil
}
// loadPathsToWatch loads the paths that needs to be watched for changes
func loadPathsToWatch(paths *[]string) error {
directory, err := os.Getwd()
if err != nil {
return err
}
filepath.Walk(directory, func(path string, info os.FileInfo, _ error) error {
if strings.HasSuffix(info.Name(), "docs") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "swagger") {
return filepath.SkipDir
}
if strings.HasSuffix(info.Name(), "vendor") {
return filepath.SkipDir
}
if filepath.Ext(info.Name()) == ".go" {
*paths = append(*paths, path)
}
return nil
})
return nil
}
// startDelveDebugger starts the Delve debugger server
func startDelveDebugger(addr string, ch chan int) int {
beeLogger.Log.Info("Starting Delve Debugger...")
fp, err := buildDebug()
if err != nil {
beeLogger.Log.Fatalf("Error while building debug binary: %v", err)
}
defer os.Remove(fp)
abs, err := filepath.Abs("./debug")
if err != nil {
beeLogger.Log.Fatalf("%v", err)
}
// Create and start the debugger server
listener, err := net.Listen("tcp", addr)
if err != nil {
beeLogger.Log.Fatalf("Could not start listener: %s", err)
}
defer listener.Close()
server := rpccommon.NewServer(&service.Config{
Listener: listener,
AcceptMulti: true,
AttachPid: 0,
APIVersion: 2,
WorkingDir: ".",
ProcessArgs: []string{abs},
}, false)
if err := server.Run(); err != nil {
beeLogger.Log.Fatalf("Could not start debugger server: %v", err)
}
// Start the Delve client REPL
client := rpc2.NewClient(addr)
// Make sure the client is restarted when new changes are introduced
go func() {
for {
if val := <-ch; val == 0 {
if _, err := client.Restart(); err != nil {
utils.Notify("Error while restarting the client: "+err.Error(), "bee")
} else {
if verbose {
utils.Notify("Delve Debugger Restarted", "bee")
}
}
}
}
}()
// Create the terminal and connect it to the client debugger
term := terminal.New(client, nil)
status, err := term.Run()
if err != nil {
beeLogger.Log.Fatalf("Could not start Delve REPL: %v", err)
}
// Stop and kill the debugger server once user quits the REPL
if err := server.Stop(true); err != nil {
beeLogger.Log.Fatalf("Could not stop Delve server: %v", err)
}
return status
}
var eventsModTime = make(map[string]int64)
// startWatcher starts the fsnotify watcher on the passed paths
func startWatcher(paths []string, ch chan int) {
watcher, err := fsnotify.NewWatcher()
if err != nil {
beeLogger.Log.Fatalf("Could not start the watcher: %v", err)
}
defer watcher.Close()
// Feed the paths to the watcher
for _, path := range paths {
if err := watcher.Add(path); err != nil {
beeLogger.Log.Fatalf("Could not set a watch on path: %v", err)
}
}
for {
select {
case evt := <-watcher.Events:
build := true
if filepath.Ext(evt.Name) != ".go" {
continue
}
mt := utils.GetFileModTime(evt.Name)
if t := eventsModTime[evt.Name]; mt == t {
build = false
}
eventsModTime[evt.Name] = mt
if build {
go func() {
if verbose {
utils.Notify("Rebuilding application with the new changes", "bee")
}
// Wait 1s before re-build until there is no file change
scheduleTime := time.Now().Add(1 * time.Second)
time.Sleep(scheduleTime.Sub(time.Now()))
_, err := buildDebug()
if err != nil {
utils.Notify("Build Failed: "+err.Error(), "bee")
} else {
ch <- 0 // Notify listeners
}
}()
}
case err := <-watcher.Errors:
if err != nil {
ch <- -1
}
}
}
}

21
cmd/commands/run/watch.go
View File

@ -71,7 +71,7 @@ func NewWatcher(paths []string, files []string, isgenerate bool) {
continue
}
mt := getFileModTime(e.Name)
mt := utils.GetFileModTime(e.Name)
if t := eventTime[e.Name]; mt == t {
beeLogger.Log.Hintf(colors.Bold("Skipping: ")+"%s", e.String())
isBuild = false
@ -104,25 +104,6 @@ func NewWatcher(paths []string, files []string, isgenerate bool) {
}
}
// getFileModTime returns unix timestamp of `os.File.ModTime` for the given path.
func getFileModTime(path string) int64 {
path = strings.Replace(path, "\\", "/", -1)
f, err := os.Open(path)
if err != nil {
beeLogger.Log.Errorf("Failed to open file on '%s': %s", path, err)
return time.Now().Unix()
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get file stats: %s", err)
return time.Now().Unix()
}
return fi.ModTime().Unix()
}
// AutoBuild builds the specified set of files
func AutoBuild(files []string, isgenerate bool) {
state.Lock()

2
gosimple.ignore Normal file
View File

@ -0,0 +1,2 @@
github.com/beego/bee/cmd/commands/run/*.go:S1024
github.com/beego/bee/cmd/commands/dlv/*.go:S1024

22
utils/utils.go
View File

@ -26,6 +26,7 @@ import (
"runtime"
"strings"
"text/template"
"time"
"unicode"
beeLogger "github.com/beego/bee/logger"
@ -67,7 +68,7 @@ func IsInGOPATH(thePath string) bool {
thePath = filepath.ToSlash(thePath)
}
for _, gopath := range GetGOPATHs() {
if strings.Contains(thePath, gopath + "/src") {
if strings.Contains(thePath, gopath+"/src") {
return true
}
}
@ -412,3 +413,22 @@ func SplitQuotedFields(in string) []string {
return r
}
// GetFileModTime returns unix timestamp of `os.File.ModTime` for the given path.
func GetFileModTime(path string) int64 {
path = strings.Replace(path, "\\", "/", -1)
f, err := os.Open(path)
if err != nil {
beeLogger.Log.Errorf("Failed to open file on '%s': %s", path, err)
return time.Now().Unix()
}
defer f.Close()
fi, err := f.Stat()
if err != nil {
beeLogger.Log.Errorf("Failed to get file stats: %s", err)
return time.Now().Unix()
}
return fi.ModTime().Unix()
}

0
vendor/github.com/derekparker/delve/pkg/config/config.go → vendor/github.com/derekparker/delve/config/config.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/dwarf/frame/entries.go → vendor/github.com/derekparker/delve/dwarf/frame/entries.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/dwarf/frame/expression_constants.go → vendor/github.com/derekparker/delve/dwarf/frame/expression_constants.go generated vendored
View File

2
vendor/github.com/derekparker/delve/pkg/dwarf/frame/parser.go → vendor/github.com/derekparker/delve/dwarf/frame/parser.go generated vendored
View File

@ -7,7 +7,7 @@ import (
"bytes"
"encoding/binary"
"github.com/derekparker/delve/pkg/dwarf/util"
"github.com/derekparker/delve/dwarf/util"
)
type parsefunc func(*parseContext) parsefunc

2
vendor/github.com/derekparker/delve/pkg/dwarf/frame/table.go → vendor/github.com/derekparker/delve/dwarf/frame/table.go generated vendored
View File

@ -5,7 +5,7 @@ import (
"encoding/binary"
"fmt"
"github.com/derekparker/delve/pkg/dwarf/util"
"github.com/derekparker/delve/dwarf/util"
)
type CurrentFrameAddress struct {

2
vendor/github.com/derekparker/delve/pkg/dwarf/line/line_parser.go → vendor/github.com/derekparker/delve/dwarf/line/line_parser.go generated vendored
View File

@ -4,7 +4,7 @@ import (
"bytes"
"encoding/binary"
"github.com/derekparker/delve/pkg/dwarf/util"
"github.com/derekparker/delve/dwarf/util"
)
type DebugLinePrologue struct {

23
vendor/github.com/derekparker/delve/pkg/dwarf/line/state_machine.go → vendor/github.com/derekparker/delve/dwarf/line/state_machine.go generated vendored
View File

@ -6,7 +6,7 @@ import (
"errors"
"fmt"
"github.com/derekparker/delve/pkg/dwarf/util"
"github.com/derekparker/delve/dwarf/util"
)
type Location struct {
@ -27,11 +27,6 @@ type StateMachine struct {
endSeq bool
lastWasStandard bool
lastDelta int
// valid is true if the current value of the state machine is the address of
// an instruction (using the terminology used by DWARF spec the current
// value of the state machine should be appended to the matrix representing
// the compilation unit)
valid bool
}
type opcodefn func(*StateMachine, *bytes.Buffer)
@ -96,9 +91,7 @@ func (dbl *DebugLines) AllPCsForFileLine(f string, l int) (pcs []uint64) {
}
if sm.line == l && sm.file == f && sm.address != lastAddr {
foundFile = true
if sm.valid {
pcs = append(pcs, sm.address)
}
pcs = append(pcs, sm.address)
line := sm.line
// Keep going until we're on a different line. We only care about
// when a line comes back around (i.e. for loop) so get to next line,
@ -130,9 +123,6 @@ func (dbl *DebugLines) AllPCsBetween(begin, end uint64, filename string) ([]uint
for b, err := buf.ReadByte(); err == nil; b, err = buf.ReadByte() {
findAndExecOpcode(sm, buf, b)
if !sm.valid {
continue
}
if sm.address > end {
break
}
@ -167,10 +157,9 @@ func execSpecialOpcode(sm *StateMachine, instr byte) {
sm.lastDelta = int(sm.dbl.Prologue.LineBase + int8(decoded%sm.dbl.Prologue.LineRange))
sm.line += sm.lastDelta
sm.address += uint64(decoded/sm.dbl.Prologue.LineRange) * uint64(sm.dbl.Prologue.MinInstrLength)
sm.address += uint64(decoded / sm.dbl.Prologue.LineRange)
sm.basicBlock = false
sm.lastWasStandard = false
sm.valid = true
}
func execExtendedOpcode(sm *StateMachine, instr byte, buf *bytes.Buffer) {
@ -181,7 +170,6 @@ func execExtendedOpcode(sm *StateMachine, instr byte, buf *bytes.Buffer) {
panic(fmt.Sprintf("Encountered unknown extended opcode %#v\n", b))
}
sm.lastWasStandard = false
sm.valid = false
fn(sm, buf)
}
@ -192,14 +180,12 @@ func execStandardOpcode(sm *StateMachine, instr byte, buf *bytes.Buffer) {
panic(fmt.Sprintf("Encountered unknown standard opcode %#v\n", instr))
}
sm.lastWasStandard = true
sm.valid = false
fn(sm, buf)
}
func copyfn(sm *StateMachine, buf *bytes.Buffer) {
sm.basicBlock = false
sm.valid = true
}
func advancepc(sm *StateMachine, buf *bytes.Buffer) {
@ -232,7 +218,7 @@ func setbasicblock(sm *StateMachine, buf *bytes.Buffer) {
}
func constaddpc(sm *StateMachine, buf *bytes.Buffer) {
sm.address += uint64((255-sm.dbl.Prologue.OpcodeBase)/sm.dbl.Prologue.LineRange) * uint64(sm.dbl.Prologue.MinInstrLength)
sm.address += (255 / uint64(sm.dbl.Prologue.LineRange))
}
func fixedadvancepc(sm *StateMachine, buf *bytes.Buffer) {
@ -244,7 +230,6 @@ func fixedadvancepc(sm *StateMachine, buf *bytes.Buffer) {
func endsequence(sm *StateMachine, buf *bytes.Buffer) {
sm.endSeq = true
sm.valid = true
}
func setaddress(sm *StateMachine, buf *bytes.Buffer) {

2
vendor/github.com/derekparker/delve/pkg/dwarf/op/op.go → vendor/github.com/derekparker/delve/dwarf/op/op.go generated vendored
View File

@ -6,7 +6,7 @@ import (
"errors"
"fmt"
"github.com/derekparker/delve/pkg/dwarf/util"
"github.com/derekparker/delve/dwarf/util"
)
const (

2
vendor/github.com/derekparker/delve/pkg/dwarf/reader/reader.go → vendor/github.com/derekparker/delve/dwarf/reader/reader.go generated vendored
View File

@ -4,8 +4,8 @@ import (
"errors"
"fmt"
"github.com/derekparker/delve/pkg/dwarf/op"
"golang.org/x/debug/dwarf"
"github.com/derekparker/delve/dwarf/op"
)
type Reader struct {

0
vendor/github.com/derekparker/delve/pkg/dwarf/util/util.go → vendor/github.com/derekparker/delve/dwarf/util/util.go generated vendored
View File

84
vendor/github.com/derekparker/delve/pkg/target/target.go generated vendored
View File

@ -1,84 +0,0 @@
package target
import (
"debug/gosym"
"go/ast"
"time"
"github.com/derekparker/delve/pkg/proc"
)
// Target represents the target of the debugger. This
// target could be a system process, core file, etc.
type Interface interface {
Info
ProcessManipulation
BreakpointManipulation
VariableEval
}
// Info is an interface that provides general information on the target.
type Info interface {
Pid() int
Exited() bool
Running() bool
BinaryInfo
ThreadInfo
GoroutineInfo
}
// BinaryInfo is an interface for accessing information on the binary file
// and the contents of binary sections.
type BinaryInfo interface {
LastModified() time.Time
Sources() map[string]*gosym.Obj
FindFileLocation(fileName string, lineNumber int) (uint64, error)
FindFunctionLocation(funcName string, firstLine bool, lineOffset int) (uint64, error)
Funcs() []gosym.Func
Types() ([]string, error)
PCToLine(uint64) (string, int, *gosym.Func)
FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error)
}
// ThreadInfo is an interface for getting information on active threads
// in the process.
type ThreadInfo interface {
Threads() map[int]*proc.Thread
CurrentThread() *proc.Thread
}
// GoroutineInfo is an interface for getting information on running goroutines.
type GoroutineInfo interface {
GoroutinesInfo() ([]*proc.G, error)
SelectedGoroutine() *proc.G
FindGoroutine(int) (*proc.G, error)
}
// ProcessManipulation is an interface for changing the execution state of a process.
type ProcessManipulation interface {
Continue() error
Next() error
Step() error
StepOut() error
StepInstruction() error
SwitchThread(int) error
SwitchGoroutine(int) error
RequestManualStop() error
Halt() error
Kill() error
Detach(bool) error
}
// BreakpointManipulation is an interface for managing breakpoints.
type BreakpointManipulation interface {
Breakpoints() map[uint64]*proc.Breakpoint
SetBreakpoint(addr uint64, kind proc.BreakpointKind, cond ast.Expr) (*proc.Breakpoint, error)
ClearBreakpoint(addr uint64) (*proc.Breakpoint, error)
ClearInternalBreakpoints() error
}
// VariableEval is an interface for dealing with eval scopes.
type VariableEval interface {
ConvertEvalScope(gid, frame int) (*proc.EvalScope, error)
}

0
vendor/github.com/derekparker/delve/pkg/proc/arch.go → vendor/github.com/derekparker/delve/proc/arch.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/breakpoints.go → vendor/github.com/derekparker/delve/proc/breakpoints.go generated vendored
View File

2
vendor/github.com/derekparker/delve/pkg/proc/disasm.go → vendor/github.com/derekparker/delve/proc/disasm.go generated vendored
View File

@ -41,7 +41,7 @@ func (thread *Thread) Disassemble(startPC, endPC uint64, currentGoroutine bool)
}
for len(mem) > 0 {
bp, atbp := thread.dbp.breakpoints[pc]
bp, atbp := thread.dbp.Breakpoints[pc]
if atbp {
for i := range bp.OriginalData {
mem[i] = bp.OriginalData[i]

3
vendor/github.com/derekparker/delve/pkg/proc/disasm_amd64.go → vendor/github.com/derekparker/delve/proc/disasm_amd64.go generated vendored
View File

@ -3,7 +3,6 @@ package proc
import (
"debug/gosym"
"encoding/binary"
"rsc.io/x86/x86asm"
)
@ -146,7 +145,7 @@ 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 (dbp *Process) FirstPCAfterPrologue(fn *gosym.Func, sameline bool) (uint64, error) {
text, err := dbp.CurrentThread().Disassemble(fn.Entry, fn.End, false)
text, err := dbp.CurrentThread.Disassemble(fn.Entry, fn.End, false)
if err != nil {
return fn.Entry, err
}

0
vendor/github.com/derekparker/delve/pkg/proc/doc.go → vendor/github.com/derekparker/delve/proc/doc.go generated vendored
View File

12
vendor/github.com/derekparker/delve/pkg/proc/eval.go → vendor/github.com/derekparker/delve/proc/eval.go generated vendored
View File

@ -3,7 +3,6 @@ package proc
import (
"bytes"
"encoding/binary"
"errors"
"fmt"
"go/ast"
"go/constant"
@ -12,12 +11,10 @@ import (
"go/token"
"reflect"
"github.com/derekparker/delve/pkg/dwarf/reader"
"github.com/derekparker/delve/dwarf/reader"
"golang.org/x/debug/dwarf"
)
var OperationOnSpecialFloatError = errors.New("operations on non-finite floats not implemented")
// EvalExpression returns the value of the given expression.
func (scope *EvalScope) EvalExpression(expr string, cfg LoadConfig) (*Variable, error) {
t, err := parser.ParseExpr(expr)
@ -691,9 +688,6 @@ func (scope *EvalScope) evalUnary(node *ast.UnaryExpr) (*Variable, error) {
if xv.Unreadable != nil {
return nil, xv.Unreadable
}
if xv.FloatSpecial != 0 {
return nil, OperationOnSpecialFloatError
}
if xv.Value == nil {
return nil, fmt.Errorf("operator %s can not be applied to \"%s\"", node.Op.String(), exprToString(node.X))
}
@ -800,10 +794,6 @@ func (scope *EvalScope) evalBinary(node *ast.BinaryExpr) (*Variable, error) {
return nil, yv.Unreadable
}
if xv.FloatSpecial != 0 || yv.FloatSpecial != 0 {
return nil, OperationOnSpecialFloatError
}
typ, err := negotiateType(node.Op, xv, yv)
if err != nil {
return nil, err

0
vendor/github.com/derekparker/delve/pkg/proc/exc.h → vendor/github.com/derekparker/delve/proc/exc.h generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/exc_user_darwin.c → vendor/github.com/derekparker/delve/proc/exc_user_darwin.c generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/exec_darwin.c → vendor/github.com/derekparker/delve/proc/exec_darwin.c generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/exec_darwin.h → vendor/github.com/derekparker/delve/proc/exec_darwin.h generated vendored
View File

4
vendor/github.com/derekparker/delve/pkg/proc/go_version.go → vendor/github.com/derekparker/delve/proc/go_version.go generated vendored
View File

@ -16,10 +16,6 @@ type GoVersion struct {
RC int
}
var (
GoVer18Beta = GoVersion{1, 8, -1, 0, 0}
)
func ParseVersionString(ver string) (GoVersion, bool) {
var r GoVersion
var err1, err2, err3 error

0
vendor/github.com/derekparker/delve/pkg/proc/mach_exc.defs → vendor/github.com/derekparker/delve/proc/mach_exc.defs generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/mach_exc.h → vendor/github.com/derekparker/delve/proc/mach_exc.h generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/mach_exc_user_darwin.c → vendor/github.com/derekparker/delve/proc/mach_exc_user_darwin.c generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/mem.go → vendor/github.com/derekparker/delve/proc/mem.go generated vendored
View File

20
vendor/github.com/derekparker/delve/pkg/proc/moduledata.go → vendor/github.com/derekparker/delve/proc/moduledata.go generated vendored
View File

@ -13,7 +13,7 @@ type moduleData struct {
func (dbp *Process) loadModuleData() (err error) {
dbp.loadModuleDataOnce.Do(func() {
scope := &EvalScope{Thread: dbp.currentThread, PC: 0, CFA: 0}
scope := &EvalScope{Thread: dbp.CurrentThread, PC: 0, CFA: 0}
var md *Variable
md, err = scope.packageVarAddr("runtime.firstmoduledata")
if err != nil {
@ -84,13 +84,13 @@ func (dbp *Process) resolveTypeOff(typeAddr uintptr, off uintptr) (*Variable, er
return v.newVariable(v.Name, uintptr(addr), rtyp), nil
}
if t, _ := md.typemapVar.mapAccess(newConstant(constant.MakeUint64(uint64(off)), dbp.currentThread)); t != nil {
if t, _ := md.typemapVar.mapAccess(newConstant(constant.MakeUint64(uint64(off)), dbp.CurrentThread)); t != nil {
return t, nil
}
res := md.types + uintptr(off)
return dbp.currentThread.newVariable("", res, rtyp), nil
return dbp.CurrentThread.newVariable("", res, rtyp), nil
}
func (dbp *Process) resolveNameOff(typeAddr uintptr, off uintptr) (name, tag string, pkgpathoff int32, err error) {
@ -119,7 +119,7 @@ func (dbp *Process) resolveNameOff(typeAddr uintptr, off uintptr) (name, tag str
}
func (dbp *Process) reflectOffsMapAccess(off uintptr) (*Variable, error) {
scope := &EvalScope{Thread: dbp.currentThread, PC: 0, CFA: 0}
scope := &EvalScope{Thread: dbp.CurrentThread, PC: 0, CFA: 0}
reflectOffs, err := scope.packageVarAddr("runtime.reflectOffs")
if err != nil {
return nil, err
@ -130,7 +130,7 @@ func (dbp *Process) reflectOffsMapAccess(off uintptr) (*Variable, error) {
return nil, err
}
return reflectOffsm.mapAccess(newConstant(constant.MakeUint64(uint64(off)), dbp.currentThread))
return reflectOffsm.mapAccess(newConstant(constant.MakeUint64(uint64(off)), dbp.CurrentThread))
}
const (
@ -142,7 +142,7 @@ const (
func (dbp *Process) loadName(addr uintptr) (name, tag string, pkgpathoff int32, err error) {
off := addr
namedata, err := dbp.currentThread.readMemory(off, 3)
namedata, err := dbp.CurrentThread.readMemory(off, 3)
off += 3
if err != nil {
return "", "", 0, err
@ -150,7 +150,7 @@ func (dbp *Process) loadName(addr uintptr) (name, tag string, pkgpathoff int32,
namelen := uint16(namedata[1]<<8) | uint16(namedata[2])
rawstr, err := dbp.currentThread.readMemory(off, int(namelen))
rawstr, err := dbp.CurrentThread.readMemory(off, int(namelen))
off += uintptr(namelen)
if err != nil {
return "", "", 0, err
@ -159,14 +159,14 @@ func (dbp *Process) loadName(addr uintptr) (name, tag string, pkgpathoff int32,
name = string(rawstr)
if namedata[0]&nameflagHasTag != 0 {
taglendata, err := dbp.currentThread.readMemory(off, 2)
taglendata, err := dbp.CurrentThread.readMemory(off, 2)
off += 2
if err != nil {
return "", "", 0, err
}
taglen := uint16(taglendata[0]<<8) | uint16(taglendata[1])
rawstr, err := dbp.currentThread.readMemory(off, int(taglen))
rawstr, err := dbp.CurrentThread.readMemory(off, int(taglen))
off += uintptr(taglen)
if err != nil {
return "", "", 0, err
@ -176,7 +176,7 @@ func (dbp *Process) loadName(addr uintptr) (name, tag string, pkgpathoff int32,
}
if namedata[0]&nameflagHasPkg != 0 {
pkgdata, err := dbp.currentThread.readMemory(off, 4)
pkgdata, err := dbp.CurrentThread.readMemory(off, 4)
if err != nil {
return "", "", 0, err
}

228
vendor/github.com/derekparker/delve/pkg/proc/proc.go → vendor/github.com/derekparker/delve/proc/proc.go generated vendored
View File

@ -16,32 +16,32 @@ import (
"sync"
"time"
"github.com/derekparker/delve/pkg/dwarf/frame"
"github.com/derekparker/delve/pkg/dwarf/line"
"github.com/derekparker/delve/pkg/dwarf/reader"
"github.com/derekparker/delve/dwarf/frame"
"github.com/derekparker/delve/dwarf/line"
"github.com/derekparker/delve/dwarf/reader"
"golang.org/x/debug/dwarf"
)
// Process represents all of the information the debugger
// is holding onto regarding the process we are debugging.
type Process struct {
pid int // Process Pid
Pid int // Process Pid
Process *os.Process // Pointer to process struct for the actual process we are debugging
lastModified time.Time // Time the executable of this process was last modified
LastModified time.Time // Time the executable of this process was last modified
// Breakpoint table, holds information on breakpoints.
// Maps instruction address to Breakpoint struct.
breakpoints map[uint64]*Breakpoint
Breakpoints map[uint64]*Breakpoint
// List of threads mapped as such: pid -> *Thread
threads map[int]*Thread
Threads map[int]*Thread
// Active thread
currentThread *Thread
CurrentThread *Thread
// Goroutine that will be used by default to set breakpoint, eval variables, etc...
// Normally selectedGoroutine is currentThread.GetG, it will not be only if SwitchGoroutine is called with a goroutine that isn't attached to a thread
selectedGoroutine *G
// Normally SelectedGoroutine is CurrentThread.GetG, it will not be only if SwitchGoroutine is called with a goroutine that isn't attached to a thread
SelectedGoroutine *G
// Maps package names to package paths, needed to lookup types inside DWARF info
packageMap map[string]string
@ -61,18 +61,12 @@ type Process struct {
ptraceChan chan func()
ptraceDoneChan chan interface{}
types map[string]dwarf.Offset
functions []functionDebugInfo
loadModuleDataOnce sync.Once
moduleData []moduleData
nameOfRuntimeType map[uintptr]nameOfRuntimeTypeEntry
}
type functionDebugInfo struct {
lowpc, highpc uint64
offset dwarf.Offset
}
var NotExecutableErr = errors.New("not an executable file")
// New returns an initialized Process struct. Before returning,
@ -81,9 +75,9 @@ var NotExecutableErr = errors.New("not an executable file")
// `handlePtraceFuncs`.
func New(pid int) *Process {
dbp := &Process{
pid: pid,
threads: make(map[int]*Thread),
breakpoints: make(map[uint64]*Breakpoint),
Pid: pid,
Threads: make(map[int]*Thread),
Breakpoints: make(map[uint64]*Breakpoint),
firstStart: true,
os: new(OSProcessDetails),
ptraceChan: make(chan func()),
@ -112,9 +106,6 @@ func (pe ProcessExitedError) Error() string {
// Detach from the process being debugged, optionally killing it.
func (dbp *Process) Detach(kill bool) (err error) {
if dbp.exited {
return nil
}
if dbp.Running() {
if err = dbp.Halt(); err != nil {
return
@ -122,7 +113,7 @@ func (dbp *Process) Detach(kill bool) (err error) {
}
if !kill {
// Clean up any breakpoints we've set.
for _, bp := range dbp.breakpoints {
for _, bp := range dbp.Breakpoints {
if bp != nil {
_, err := dbp.ClearBreakpoint(bp.Addr)
if err != nil {
@ -132,12 +123,12 @@ func (dbp *Process) Detach(kill bool) (err error) {
}
}
dbp.execPtraceFunc(func() {
err = PtraceDetach(dbp.pid, 0)
err = PtraceDetach(dbp.Pid, 0)
if err != nil {
return
}
if kill {
err = killProcess(dbp.pid)
err = killProcess(dbp.Pid)
}
})
return
@ -152,7 +143,7 @@ func (dbp *Process) Exited() bool {
// Running returns whether the debugged
// process is currently executing.
func (dbp *Process) Running() bool {
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if th.running {
return true
}
@ -160,30 +151,6 @@ func (dbp *Process) Running() bool {
return false
}
func (dbp *Process) LastModified() time.Time {
return dbp.lastModified
}
func (dbp *Process) Pid() int {
return dbp.pid
}
func (dbp *Process) SelectedGoroutine() *G {
return dbp.selectedGoroutine
}
func (dbp *Process) Threads() map[int]*Thread {
return dbp.threads
}
func (dbp *Process) CurrentThread() *Thread {
return dbp.currentThread
}
func (dbp *Process) Breakpoints() map[uint64]*Breakpoint {
return dbp.breakpoints
}
// LoadInformation finds the executable and then uses it
// to parse the following information:
// * Dwarf .debug_frame section
@ -198,7 +165,7 @@ func (dbp *Process) LoadInformation(path string) error {
}
fi, err := os.Stat(path)
if err == nil {
dbp.lastModified = fi.ModTime()
dbp.LastModified = fi.ModTime()
}
wg.Add(5)
@ -206,7 +173,7 @@ func (dbp *Process) LoadInformation(path string) error {
go dbp.parseDebugFrame(exe, &wg)
go dbp.obtainGoSymbols(exe, &wg)
go dbp.parseDebugLineInfo(exe, &wg)
go dbp.loadDebugInfoMaps(&wg)
go dbp.loadTypeMap(&wg)
wg.Wait()
return nil
@ -250,7 +217,7 @@ func (dbp *Process) FindFunctionLocation(funcName string, firstLine bool, lineOf
// CurrentLocation returns the location of the current thread.
func (dbp *Process) CurrentLocation() (*Location, error) {
return dbp.currentThread.Location()
return dbp.CurrentThread.Location()
}
// RequestManualStop sets the `halt` flag and
@ -267,7 +234,7 @@ func (dbp *Process) RequestManualStop() error {
// break point table. Setting a break point must be thread specific due to
// ptrace actions needing the thread to be in a signal-delivery-stop.
func (dbp *Process) SetBreakpoint(addr uint64, kind BreakpointKind, cond ast.Expr) (*Breakpoint, error) {
tid := dbp.currentThread.ID
tid := dbp.CurrentThread.ID
if bp, ok := dbp.FindBreakpoint(addr); ok {
return nil, BreakpointExistsError{bp.File, bp.Line, bp.Addr}
@ -296,7 +263,7 @@ func (dbp *Process) SetBreakpoint(addr uint64, kind BreakpointKind, cond ast.Exp
newBreakpoint.ID = dbp.breakpointIDCounter
}
thread := dbp.threads[tid]
thread := dbp.Threads[tid]
originalData, err := thread.readMemory(uintptr(addr), dbp.arch.BreakpointSize())
if err != nil {
return nil, err
@ -305,7 +272,7 @@ func (dbp *Process) SetBreakpoint(addr uint64, kind BreakpointKind, cond ast.Exp
return nil, err
}
newBreakpoint.OriginalData = originalData
dbp.breakpoints[addr] = newBreakpoint
dbp.Breakpoints[addr] = newBreakpoint
return newBreakpoint, nil
}
@ -320,18 +287,18 @@ func (dbp *Process) ClearBreakpoint(addr uint64) (*Breakpoint, error) {
return nil, NoBreakpointError{addr: addr}
}
if _, err := bp.Clear(dbp.currentThread); err != nil {
if _, err := bp.Clear(dbp.CurrentThread); err != nil {
return nil, err
}
delete(dbp.breakpoints, addr)
delete(dbp.Breakpoints, addr)
return bp, nil
}
// Status returns the status of the current main thread context.
func (dbp *Process) Status() *WaitStatus {
return dbp.currentThread.Status
return dbp.CurrentThread.Status
}
// Next continues execution until the next source line.
@ -339,8 +306,8 @@ func (dbp *Process) Next() (err error) {
if dbp.exited {
return &ProcessExitedError{}
}
for i := range dbp.breakpoints {
if dbp.breakpoints[i].Internal() {
for i := range dbp.Breakpoints {
if dbp.Breakpoints[i].Internal() {
return fmt.Errorf("next while nexting")
}
}
@ -370,7 +337,7 @@ func (dbp *Process) Continue() error {
}
dbp.allGCache = nil
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
th.clearBreakpointState()
}
@ -389,42 +356,34 @@ func (dbp *Process) Continue() error {
}
switch {
case dbp.currentThread.CurrentBreakpoint == nil:
case dbp.CurrentThread.CurrentBreakpoint == nil:
// runtime.Breakpoint or manual stop
if dbp.currentThread.onRuntimeBreakpoint() {
// Single-step current thread until we exit runtime.breakpoint and
// runtime.Breakpoint.
// On go < 1.8 it was sufficient to single-step twice on go1.8 a change
// to the compiler requires 4 steps.
for {
if err = dbp.currentThread.StepInstruction(); err != nil {
if dbp.CurrentThread.onRuntimeBreakpoint() {
for i := 0; i < 2; i++ {
if err = dbp.CurrentThread.StepInstruction(); err != nil {
return err
}
loc, err := dbp.currentThread.Location()
if err != nil || loc.Fn == nil || (loc.Fn.Name != "runtime.breakpoint" && loc.Fn.Name != "runtime.Breakpoint") {
break
}
}
}
return dbp.conditionErrors()
case dbp.currentThread.onTriggeredInternalBreakpoint():
if dbp.currentThread.CurrentBreakpoint.Kind == StepBreakpoint {
case dbp.CurrentThread.onTriggeredInternalBreakpoint():
if dbp.CurrentThread.CurrentBreakpoint.Kind == StepBreakpoint {
// See description of proc.(*Process).next for the meaning of StepBreakpoints
if err := dbp.conditionErrors(); err != nil {
return err
}
pc, err := dbp.currentThread.PC()
pc, err := dbp.CurrentThread.PC()
if err != nil {
return err
}
text, err := dbp.currentThread.Disassemble(pc, pc+maxInstructionLength, true)
text, err := dbp.CurrentThread.Disassemble(pc, pc+maxInstructionLength, true)
if err != nil {
return err
}
// here we either set a breakpoint into the destination of the CALL
// instruction or we determined that the called function is hidden,
// either way we need to resume execution
if err = dbp.setStepIntoBreakpoint(text, sameGoroutineCondition(dbp.selectedGoroutine)); err != nil {
if err = dbp.setStepIntoBreakpoint(text, sameGoroutineCondition(dbp.SelectedGoroutine)); err != nil {
return err
}
} else {
@ -433,8 +392,8 @@ func (dbp *Process) Continue() error {
}
return dbp.conditionErrors()
}
case dbp.currentThread.onTriggeredBreakpoint():
onNextGoroutine, err := dbp.currentThread.onNextGoroutine()
case dbp.CurrentThread.onTriggeredBreakpoint():
onNextGoroutine, err := dbp.CurrentThread.onNextGoroutine()
if err != nil {
return err
}
@ -453,7 +412,7 @@ func (dbp *Process) Continue() error {
func (dbp *Process) conditionErrors() error {
var condErr error
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if th.CurrentBreakpoint != nil && th.BreakpointConditionError != nil {
if condErr == nil {
condErr = th.BreakpointConditionError
@ -465,12 +424,12 @@ func (dbp *Process) conditionErrors() error {
return condErr
}
// pick a new dbp.currentThread, with the following priority:
// pick a new dbp.CurrentThread, with the following priority:
// - a thread with onTriggeredInternalBreakpoint() == true
// - a thread with onTriggeredBreakpoint() == true (prioritizing trapthread)
// - trapthread
func (dbp *Process) pickCurrentThread(trapthread *Thread) error {
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if th.onTriggeredInternalBreakpoint() {
return dbp.SwitchThread(th.ID)
}
@ -478,7 +437,7 @@ func (dbp *Process) pickCurrentThread(trapthread *Thread) error {
if trapthread.onTriggeredBreakpoint() {
return dbp.SwitchThread(trapthread.ID)
}
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if th.onTriggeredBreakpoint() {
return dbp.SwitchThread(th.ID)
}
@ -492,8 +451,8 @@ func (dbp *Process) Step() (err error) {
if dbp.exited {
return &ProcessExitedError{}
}
for i := range dbp.breakpoints {
if dbp.breakpoints[i].Internal() {
for i := range dbp.Breakpoints {
if dbp.Breakpoints[i].Internal() {
return fmt.Errorf("next while nexting")
}
}
@ -533,12 +492,12 @@ func sameGoroutineCondition(g *G) ast.Expr {
// asssociated with the selected goroutine. All other
// threads will remain stopped.
func (dbp *Process) StepInstruction() (err error) {
if dbp.selectedGoroutine == nil {
if dbp.SelectedGoroutine == nil {
return errors.New("cannot single step: no selected goroutine")
}
if dbp.selectedGoroutine.thread == nil {
if dbp.SelectedGoroutine.thread == nil {
// Step called on parked goroutine
if _, err := dbp.SetBreakpoint(dbp.selectedGoroutine.PC, NextBreakpoint, sameGoroutineCondition(dbp.selectedGoroutine)); err != nil {
if _, err := dbp.SetBreakpoint(dbp.SelectedGoroutine.PC, NextBreakpoint, sameGoroutineCondition(dbp.SelectedGoroutine)); err != nil {
return err
}
return dbp.Continue()
@ -547,20 +506,20 @@ func (dbp *Process) StepInstruction() (err error) {
if dbp.exited {
return &ProcessExitedError{}
}
dbp.selectedGoroutine.thread.clearBreakpointState()
err = dbp.selectedGoroutine.thread.StepInstruction()
dbp.SelectedGoroutine.thread.clearBreakpointState()
err = dbp.SelectedGoroutine.thread.StepInstruction()
if err != nil {
return err
}
return dbp.selectedGoroutine.thread.SetCurrentBreakpoint()
return dbp.SelectedGoroutine.thread.SetCurrentBreakpoint()
}
// StepOut will continue until the current goroutine exits the
// function currently being executed or a deferred function is executed
func (dbp *Process) StepOut() error {
cond := sameGoroutineCondition(dbp.selectedGoroutine)
cond := sameGoroutineCondition(dbp.SelectedGoroutine)
topframe, err := topframe(dbp.selectedGoroutine, dbp.currentThread)
topframe, err := topframe(dbp.SelectedGoroutine, dbp.CurrentThread)
if err != nil {
return err
}
@ -569,16 +528,13 @@ func (dbp *Process) StepOut() error {
var deferpc uint64 = 0
if filepath.Ext(topframe.Current.File) == ".go" {
if dbp.selectedGoroutine != nil {
deferPCEntry := dbp.selectedGoroutine.DeferPC()
if deferPCEntry != 0 {
_, _, deferfn := dbp.goSymTable.PCToLine(deferPCEntry)
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
if err != nil {
return err
}
pcs = append(pcs, deferpc)
if dbp.SelectedGoroutine != nil && dbp.SelectedGoroutine.DeferPC != 0 {
_, _, deferfn := dbp.goSymTable.PCToLine(dbp.SelectedGoroutine.DeferPC)
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
if err != nil {
return err
}
pcs = append(pcs, deferpc)
}
}
@ -616,9 +572,9 @@ func (dbp *Process) SwitchThread(tid int) error {
if dbp.exited {
return &ProcessExitedError{}
}
if th, ok := dbp.threads[tid]; ok {
dbp.currentThread = th
dbp.selectedGoroutine, _ = dbp.currentThread.GetG()
if th, ok := dbp.Threads[tid]; ok {
dbp.CurrentThread = th
dbp.SelectedGoroutine, _ = dbp.CurrentThread.GetG()
return nil
}
return fmt.Errorf("thread %d does not exist", tid)
@ -635,13 +591,13 @@ func (dbp *Process) SwitchGoroutine(gid int) error {
return err
}
if g == nil {
// user specified -1 and selectedGoroutine is nil
// user specified -1 and SelectedGoroutine is nil
return nil
}
if g.thread != nil {
return dbp.SwitchThread(g.thread.ID)
}
dbp.selectedGoroutine = g
dbp.SelectedGoroutine = g
return nil
}
@ -661,13 +617,13 @@ func (dbp *Process) GoroutinesInfo() ([]*G, error) {
rdr = dbp.DwarfReader()
)
for i := range dbp.threads {
if dbp.threads[i].blocked() {
for i := range dbp.Threads {
if dbp.Threads[i].blocked() {
continue
}
g, _ := dbp.threads[i].GetG()
g, _ := dbp.Threads[i].GetG()
if g != nil {
threadg[g.ID] = dbp.threads[i]
threadg[g.ID] = dbp.Threads[i]
}
}
@ -675,7 +631,7 @@ func (dbp *Process) GoroutinesInfo() ([]*G, error) {
if err != nil {
return nil, err
}
allglenBytes, err := dbp.currentThread.readMemory(uintptr(addr), 8)
allglenBytes, err := dbp.CurrentThread.readMemory(uintptr(addr), 8)
if err != nil {
return nil, err
}
@ -690,11 +646,11 @@ func (dbp *Process) GoroutinesInfo() ([]*G, error) {
return nil, err
}
}
faddr, err := dbp.currentThread.readMemory(uintptr(allgentryaddr), dbp.arch.PtrSize())
faddr, err := dbp.CurrentThread.readMemory(uintptr(allgentryaddr), dbp.arch.PtrSize())
allgptr := binary.LittleEndian.Uint64(faddr)
for i := uint64(0); i < allglen; i++ {
gvar, err := dbp.currentThread.newGVariable(uintptr(allgptr+(i*uint64(dbp.arch.PtrSize()))), true)
gvar, err := dbp.CurrentThread.newGVariable(uintptr(allgptr+(i*uint64(dbp.arch.PtrSize()))), true)
if err != nil {
return nil, err
}
@ -728,7 +684,7 @@ func (dbp *Process) Halt() (err error) {
if dbp.exited {
return &ProcessExitedError{}
}
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if err := th.Halt(); err != nil {
return err
}
@ -739,18 +695,18 @@ func (dbp *Process) Halt() (err error) {
// Registers obtains register values from the
// "current" thread of the traced process.
func (dbp *Process) Registers() (Registers, error) {
return dbp.currentThread.Registers(false)
return dbp.CurrentThread.Registers(false)
}
// PC returns the PC of the current thread.
func (dbp *Process) PC() (uint64, error) {
return dbp.currentThread.PC()
return dbp.CurrentThread.PC()
}
// CurrentBreakpoint returns the breakpoint the current thread
// is stopped at.
func (dbp *Process) CurrentBreakpoint() *Breakpoint {
return dbp.currentThread.CurrentBreakpoint
return dbp.CurrentThread.CurrentBreakpoint
}
// DwarfReader returns a reader for the dwarf data
@ -784,7 +740,7 @@ func (dbp *Process) PCToLine(pc uint64) (string, int, *gosym.Func) {
// FindBreakpointByID finds the breakpoint for the given ID.
func (dbp *Process) FindBreakpointByID(id int) (*Breakpoint, bool) {
for _, bp := range dbp.breakpoints {
for _, bp := range dbp.Breakpoints {
if bp.ID == id {
return bp, true
}
@ -795,11 +751,11 @@ func (dbp *Process) FindBreakpointByID(id int) (*Breakpoint, bool) {
// FindBreakpoint finds the breakpoint for the given pc.
func (dbp *Process) FindBreakpoint(pc uint64) (*Breakpoint, bool) {
// Check to see if address is past the breakpoint, (i.e. breakpoint was hit).
if bp, ok := dbp.breakpoints[pc-uint64(dbp.arch.BreakpointSize())]; ok {
if bp, ok := dbp.Breakpoints[pc-uint64(dbp.arch.BreakpointSize())]; ok {
return bp, true
}
// Directly use addr to lookup breakpoint.
if bp, ok := dbp.breakpoints[pc]; ok {
if bp, ok := dbp.Breakpoints[pc]; ok {
return bp, true
}
return nil, false
@ -809,17 +765,17 @@ func (dbp *Process) FindBreakpoint(pc uint64) (*Breakpoint, bool) {
func initializeDebugProcess(dbp *Process, path string, attach bool) (*Process, error) {
if attach {
var err error
dbp.execPtraceFunc(func() { err = PtraceAttach(dbp.pid) })
dbp.execPtraceFunc(func() { err = PtraceAttach(dbp.Pid) })
if err != nil {
return nil, err
}
_, _, err = dbp.wait(dbp.pid, 0)
_, _, err = dbp.wait(dbp.Pid, 0)
if err != nil {
return nil, err
}
}
proc, err := os.FindProcess(dbp.pid)
proc, err := os.FindProcess(dbp.Pid)
if err != nil {
return nil, err
}
@ -840,11 +796,11 @@ func initializeDebugProcess(dbp *Process, path string, attach bool) (*Process, e
}
dbp.arch.SetGStructOffset(ver, isextld)
// selectedGoroutine can not be set correctly by the call to updateThreadList
// because without calling SetGStructOffset we can not read the G struct of currentThread
// SelectedGoroutine can not be set correctly by the call to updateThreadList
// because without calling SetGStructOffset we can not read the G struct of CurrentThread
// but without calling updateThreadList we can not examine memory to determine
// the offset of g struct inside TLS
dbp.selectedGoroutine, _ = dbp.currentThread.GetG()
dbp.SelectedGoroutine, _ = dbp.CurrentThread.GetG()
panicpc, err := dbp.FindFunctionLocation("runtime.startpanic", true, 0)
if err == nil {
@ -860,7 +816,7 @@ func initializeDebugProcess(dbp *Process, path string, attach bool) (*Process, e
}
func (dbp *Process) ClearInternalBreakpoints() error {
for _, bp := range dbp.breakpoints {
for _, bp := range dbp.Breakpoints {
if !bp.Internal() {
continue
}
@ -868,9 +824,9 @@ func (dbp *Process) ClearInternalBreakpoints() error {
return err
}
}
for i := range dbp.threads {
if dbp.threads[i].CurrentBreakpoint != nil && dbp.threads[i].CurrentBreakpoint.Internal() {
dbp.threads[i].CurrentBreakpoint = nil
for i := range dbp.Threads {
if dbp.Threads[i].CurrentBreakpoint != nil && dbp.Threads[i].CurrentBreakpoint.Internal() {
dbp.Threads[i].CurrentBreakpoint = nil
}
}
return nil
@ -928,7 +884,7 @@ func (dbp *Process) getGoInformation() (ver GoVersion, isextld bool, err error)
// specified by `gid`.
func (dbp *Process) FindGoroutine(gid int) (*G, error) {
if gid == -1 {
return dbp.selectedGoroutine, nil
return dbp.SelectedGoroutine, nil
}
gs, err := dbp.GoroutinesInfo()
@ -954,13 +910,13 @@ func (dbp *Process) ConvertEvalScope(gid, frame int) (*EvalScope, error) {
return nil, err
}
if g == nil {
return dbp.currentThread.Scope()
return dbp.CurrentThread.Scope()
}
var out EvalScope
if g.thread == nil {
out.Thread = dbp.currentThread
out.Thread = dbp.CurrentThread
} else {
out.Thread = g.thread
}

0
vendor/github.com/derekparker/delve/pkg/proc/proc_darwin.c → vendor/github.com/derekparker/delve/proc/proc_darwin.c generated vendored
View File

52
vendor/github.com/derekparker/delve/pkg/proc/proc_darwin.go → vendor/github.com/derekparker/delve/proc/proc_darwin.go generated vendored
View File

@ -17,8 +17,8 @@ import (
"golang.org/x/debug/macho"
"github.com/derekparker/delve/pkg/dwarf/frame"
"github.com/derekparker/delve/pkg/dwarf/line"
"github.com/derekparker/delve/dwarf/frame"
"github.com/derekparker/delve/dwarf/line"
sys "golang.org/x/sys/unix"
)
@ -77,7 +77,7 @@ func Launch(cmd []string, wd string) (*Process, error) {
if pid <= 0 {
return nil, fmt.Errorf("could not fork/exec")
}
dbp.pid = pid
dbp.Pid = pid
for i := range argvSlice {
C.free(unsafe.Pointer(argvSlice[i]))
}
@ -86,7 +86,7 @@ func Launch(cmd []string, wd string) (*Process, error) {
// trapWait to wait until the child process calls execve.
for {
err = dbp.updateThreadListForTask(C.get_task_for_pid(C.int(dbp.pid)))
err = dbp.updateThreadListForTask(C.get_task_for_pid(C.int(dbp.Pid)))
if err == nil {
break
}
@ -100,7 +100,7 @@ func Launch(cmd []string, wd string) (*Process, error) {
}
dbp.allGCache = nil
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
th.clearBreakpointState()
}
@ -152,11 +152,11 @@ func (dbp *Process) Kill() (err error) {
if dbp.exited {
return nil
}
err = sys.Kill(-dbp.pid, sys.SIGKILL)
err = sys.Kill(-dbp.Pid, sys.SIGKILL)
if err != nil {
return errors.New("could not deliver signal: " + err.Error())
}
for port := range dbp.threads {
for port := range dbp.Threads {
if C.thread_resume(C.thread_act_t(port)) != C.KERN_SUCCESS {
return errors.New("could not resume task")
}
@ -175,7 +175,7 @@ func (dbp *Process) Kill() (err error) {
func (dbp *Process) requestManualStop() (err error) {
var (
task = C.mach_port_t(dbp.os.task)
thread = C.mach_port_t(dbp.currentThread.os.threadAct)
thread = C.mach_port_t(dbp.CurrentThread.os.threadAct)
exceptionPort = C.mach_port_t(dbp.os.exceptionPort)
)
kret := C.raise_exception(task, thread, exceptionPort, C.EXC_BREAKPOINT)
@ -218,12 +218,12 @@ func (dbp *Process) updateThreadListForTask(task C.task_t) error {
return couldNotGetThreadList
}
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
thread.os.exists = false
}
for _, port := range list {
thread, ok := dbp.threads[int(port)]
thread, ok := dbp.Threads[int(port)]
if !ok {
thread, err = dbp.addThread(int(port), false)
if err != nil {
@ -233,9 +233,9 @@ func (dbp *Process) updateThreadListForTask(task C.task_t) error {
thread.os.exists = true
}
for threadID, thread := range dbp.threads {
for threadID, thread := range dbp.Threads {
if !thread.os.exists {
delete(dbp.threads, threadID)
delete(dbp.Threads, threadID)
}
}
@ -243,7 +243,7 @@ func (dbp *Process) updateThreadListForTask(task C.task_t) error {
}
func (dbp *Process) addThread(port int, attach bool) (*Thread, error) {
if thread, ok := dbp.threads[port]; ok {
if thread, ok := dbp.Threads[port]; ok {
return thread, nil
}
thread := &Thread{
@ -251,9 +251,9 @@ func (dbp *Process) addThread(port int, attach bool) (*Thread, error) {
dbp: dbp,
os: new(OSSpecificDetails),
}
dbp.threads[port] = thread
dbp.Threads[port] = thread
thread.os.threadAct = C.thread_act_t(port)
if dbp.currentThread == nil {
if dbp.CurrentThread == nil {
dbp.SwitchThread(thread.ID)
}
return thread, nil
@ -338,7 +338,7 @@ var UnsupportedArchErr = errors.New("unsupported architecture - only darwin/amd6
func (dbp *Process) findExecutable(path string) (*macho.File, string, error) {
if path == "" {
path = C.GoString(C.find_executable(C.int(dbp.pid)))
path = C.GoString(C.find_executable(C.int(dbp.Pid)))
}
exe, err := macho.Open(path)
if err != nil {
@ -369,16 +369,16 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
continue
}
if !dbp.os.initialized {
if pidtask := C.get_task_for_pid(C.int(dbp.pid)); pidtask != 0 && dbp.os.task != pidtask {
if pidtask := C.get_task_for_pid(C.int(dbp.Pid)); pidtask != 0 && dbp.os.task != pidtask {
continue
}
}
_, status, err := dbp.wait(dbp.pid, 0)
_, status, err := dbp.wait(dbp.Pid, 0)
if err != nil {
return nil, err
}
dbp.postExit()
return nil, ProcessExitedError{Pid: dbp.pid, Status: status.ExitStatus()}
return nil, ProcessExitedError{Pid: dbp.Pid, Status: status.ExitStatus()}
case C.MACH_RCV_INTERRUPTED:
if !dbp.halt {
@ -407,7 +407,7 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
// Since we cannot be notified of new threads on OS X
// this is as good a time as any to check for them.
dbp.updateThreadList()
th, ok := dbp.threads[int(port)]
th, ok := dbp.Threads[int(port)]
if !ok {
if dbp.halt {
dbp.halt = false
@ -427,7 +427,7 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
}
func (dbp *Process) waitForStop() ([]int, error) {
ports := make([]int, 0, len(dbp.threads))
ports := make([]int, 0, len(dbp.Threads))
count := 0
for {
var task C.task_t
@ -455,7 +455,7 @@ func (dbp *Process) setCurrentBreakpoints(trapthread *Thread) error {
}
trapthread.SetCurrentBreakpoint()
for _, port := range ports {
if th, ok := dbp.threads[port]; ok {
if th, ok := dbp.Threads[port]; ok {
err := th.SetCurrentBreakpoint()
if err != nil {
return err
@ -483,17 +483,17 @@ func (dbp *Process) exitGuard(err error) error {
if err != ErrContinueThread {
return err
}
_, status, werr := dbp.wait(dbp.pid, sys.WNOHANG)
_, status, werr := dbp.wait(dbp.Pid, sys.WNOHANG)
if werr == nil && status.Exited() {
dbp.postExit()
return ProcessExitedError{Pid: dbp.pid, Status: status.ExitStatus()}
return ProcessExitedError{Pid: dbp.Pid, Status: status.ExitStatus()}
}
return err
}
func (dbp *Process) resume() error {
// all threads stopped over a breakpoint are made to step over it
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
if thread.CurrentBreakpoint != nil {
if err := thread.StepInstruction(); err != nil {
return err
@ -502,7 +502,7 @@ func (dbp *Process) resume() error {
}
}
// everything is resumed
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
if err := thread.resume(); err != nil {
return dbp.exitGuard(err)
}

0
vendor/github.com/derekparker/delve/pkg/proc/proc_darwin.h → vendor/github.com/derekparker/delve/proc/proc_darwin.h generated vendored
View File

65
vendor/github.com/derekparker/delve/pkg/proc/proc_linux.go → vendor/github.com/derekparker/delve/proc/proc_linux.go generated vendored
View File

@ -18,8 +18,8 @@ import (
sys "golang.org/x/sys/unix"
"github.com/derekparker/delve/pkg/dwarf/frame"
"github.com/derekparker/delve/pkg/dwarf/line"
"github.com/derekparker/delve/dwarf/frame"
"github.com/derekparker/delve/dwarf/line"
"golang.org/x/debug/elf"
)
@ -70,7 +70,7 @@ func Launch(cmd []string, wd string) (*Process, error) {
if err != nil {
return nil, err
}
dbp.pid = proc.Process.Pid
dbp.Pid = proc.Process.Pid
_, _, err = dbp.wait(proc.Process.Pid, 0)
if err != nil {
return nil, fmt.Errorf("waiting for target execve failed: %s", err)
@ -88,13 +88,13 @@ func (dbp *Process) Kill() (err error) {
if dbp.exited {
return nil
}
if !dbp.threads[dbp.pid].Stopped() {
if !dbp.Threads[dbp.Pid].Stopped() {
return errors.New("process must be stopped in order to kill it")
}
if err = sys.Kill(-dbp.pid, sys.SIGKILL); err != nil {
if err = sys.Kill(-dbp.Pid, sys.SIGKILL); err != nil {
return errors.New("could not deliver signal " + err.Error())
}
if _, _, err = dbp.wait(dbp.pid, 0); err != nil {
if _, _, err = dbp.wait(dbp.Pid, 0); err != nil {
return
}
dbp.postExit()
@ -102,13 +102,13 @@ func (dbp *Process) Kill() (err error) {
}
func (dbp *Process) requestManualStop() (err error) {
return sys.Kill(dbp.pid, sys.SIGTRAP)
return sys.Kill(dbp.Pid, sys.SIGTRAP)
}
// Attach to a newly created thread, and store that thread in our list of
// known threads.
func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) {
if thread, ok := dbp.threads[tid]; ok {
if thread, ok := dbp.Threads[tid]; ok {
return thread, nil
}
@ -145,26 +145,26 @@ func (dbp *Process) addThread(tid int, attach bool) (*Thread, error) {
}
}
dbp.threads[tid] = &Thread{
dbp.Threads[tid] = &Thread{
ID: tid,
dbp: dbp,
os: new(OSSpecificDetails),
}
if dbp.currentThread == nil {
if dbp.CurrentThread == nil {
dbp.SwitchThread(tid)
}
return dbp.threads[tid], nil
return dbp.Threads[tid], nil
}
func (dbp *Process) updateThreadList() error {
tids, _ := filepath.Glob(fmt.Sprintf("/proc/%d/task/*", dbp.pid))
tids, _ := filepath.Glob(fmt.Sprintf("/proc/%d/task/*", dbp.Pid))
for _, tidpath := range tids {
tidstr := filepath.Base(tidpath)
tid, err := strconv.Atoi(tidstr)
if err != nil {
return err
}
if _, err := dbp.addThread(tid, tid != dbp.pid); err != nil {
if _, err := dbp.addThread(tid, tid != dbp.Pid); err != nil {
return err
}
}
@ -175,7 +175,7 @@ var UnsupportedArchErr = errors.New("unsupported architecture - only linux/amd64
func (dbp *Process) findExecutable(path string) (*elf.File, string, error) {
if path == "" {
path = fmt.Sprintf("/proc/%d/exe", dbp.pid)
path = fmt.Sprintf("/proc/%d/exe", dbp.Pid)
}
f, err := os.OpenFile(path, 0, os.ModePerm)
if err != nil {
@ -279,16 +279,16 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
if wpid == 0 {
continue
}
th, ok := dbp.threads[wpid]
th, ok := dbp.Threads[wpid]
if ok {
th.Status = (*WaitStatus)(status)
}
if status.Exited() {
if wpid == dbp.pid {
if wpid == dbp.Pid {
dbp.postExit()
return nil, ProcessExitedError{Pid: wpid, Status: status.ExitStatus()}
}
delete(dbp.threads, wpid)
delete(dbp.Threads, wpid)
continue
}
if status.StopSignal() == sys.SIGTRAP && status.TrapCause() == sys.PTRACE_EVENT_CLONE {
@ -314,12 +314,12 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
if err = th.Continue(); err != nil {
if err == sys.ESRCH {
// thread died while we were adding it
delete(dbp.threads, th.ID)
delete(dbp.Threads, th.ID)
continue
}
return nil, fmt.Errorf("could not continue new thread %d %s", cloned, err)
}
if err = dbp.threads[int(wpid)].Continue(); err != nil {
if err = dbp.Threads[int(wpid)].Continue(); err != nil {
if err != sys.ESRCH {
return nil, fmt.Errorf("could not continue existing thread %d %s", wpid, err)
}
@ -343,7 +343,7 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
// TODO(dp) alert user about unexpected signals here.
if err := th.resumeWithSig(int(status.StopSignal())); err != nil {
if err == sys.ESRCH {
return nil, ProcessExitedError{Pid: dbp.pid}
return nil, ProcessExitedError{Pid: dbp.Pid}
}
return nil, err
}
@ -354,19 +354,19 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
func (dbp *Process) loadProcessInformation(wg *sync.WaitGroup) {
defer wg.Done()
comm, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/comm", dbp.pid))
comm, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/comm", dbp.Pid))
if err == nil {
// removes newline character
comm = bytes.TrimSuffix(comm, []byte("\n"))
}
if comm == nil || len(comm) <= 0 {
stat, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/stat", dbp.pid))
stat, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/stat", dbp.Pid))
if err != nil {
fmt.Printf("Could not read proc stat: %v\n", err)
os.Exit(1)
}
expr := fmt.Sprintf("%d\\s*\\((.*)\\)", dbp.pid)
expr := fmt.Sprintf("%d\\s*\\((.*)\\)", dbp.Pid)
rexp, err := regexp.Compile(expr)
if err != nil {
fmt.Printf("Regexp compile error: %v\n", err)
@ -374,7 +374,7 @@ func (dbp *Process) loadProcessInformation(wg *sync.WaitGroup) {
}
match := rexp.FindSubmatch(stat)
if match == nil {
fmt.Printf("No match found using regexp '%s' in /proc/%d/stat\n", expr, dbp.pid)
fmt.Printf("No match found using regexp '%s' in /proc/%d/stat\n", expr, dbp.Pid)
os.Exit(1)
}
comm = match[1]
@ -402,16 +402,9 @@ func status(pid int, comm string) rune {
return state
}
// waitFast is like wait but does not handle process-exit correctly
func (dbp *Process) waitFast(pid int) (int, *sys.WaitStatus, error) {
var s sys.WaitStatus
wpid, err := sys.Wait4(pid, &s, sys.WALL, nil)
return wpid, &s, err
}
func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) {
var s sys.WaitStatus
if (pid != dbp.pid) || (options != 0) {
if (pid != dbp.Pid) || (options != 0) {
wpid, err := sys.Wait4(pid, &s, sys.WALL|options, nil)
return wpid, &s, err
}
@ -442,7 +435,7 @@ func (dbp *Process) wait(pid, options int) (int, *sys.WaitStatus, error) {
}
func (dbp *Process) setCurrentBreakpoints(trapthread *Thread) error {
for _, th := range dbp.threads {
for _, th := range dbp.Threads {
if th.CurrentBreakpoint == nil {
err := th.SetCurrentBreakpoint()
if err != nil {
@ -457,7 +450,7 @@ func (dbp *Process) exitGuard(err error) error {
if err != sys.ESRCH {
return err
}
if status(dbp.pid, dbp.os.comm) == StatusZombie {
if status(dbp.Pid, dbp.os.comm) == StatusZombie {
_, err := dbp.trapWait(-1)
return err
}
@ -467,7 +460,7 @@ func (dbp *Process) exitGuard(err error) error {
func (dbp *Process) resume() error {
// all threads stopped over a breakpoint are made to step over it
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
if thread.CurrentBreakpoint != nil {
if err := thread.StepInstruction(); err != nil {
return err
@ -476,7 +469,7 @@ func (dbp *Process) resume() error {
}
}
// everything is resumed
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
if err := thread.resume(); err != nil && err != sys.ESRCH {
return err
}

71
vendor/github.com/derekparker/delve/pkg/proc/proc_windows.go → vendor/github.com/derekparker/delve/proc/proc_windows.go generated vendored
View File

@ -14,8 +14,8 @@ import (
sys "golang.org/x/sys/windows"
"github.com/derekparker/delve/pkg/dwarf/frame"
"github.com/derekparker/delve/pkg/dwarf/line"
"github.com/derekparker/delve/dwarf/frame"
"github.com/derekparker/delve/dwarf/line"
"golang.org/x/debug/dwarf"
)
@ -113,7 +113,7 @@ func Launch(cmd []string, wd string) (*Process, error) {
sys.CloseHandle(sys.Handle(pi.Process))
sys.CloseHandle(sys.Handle(pi.Thread))
dbp.pid = int(pi.ProcessId)
dbp.Pid = int(pi.ProcessId)
return newDebugProcess(dbp, argv0Go)
}
@ -135,11 +135,11 @@ func newDebugProcess(dbp *Process, exepath string) (*Process, error) {
}
if tid == 0 {
dbp.postExit()
return nil, ProcessExitedError{Pid: dbp.pid, Status: exitCode}
return nil, ProcessExitedError{Pid: dbp.Pid, Status: exitCode}
}
// Suspend all threads so that the call to _ContinueDebugEvent will
// not resume the target.
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
_, err := _SuspendThread(thread.os.hThread)
if err != nil {
return nil, err
@ -147,7 +147,7 @@ func newDebugProcess(dbp *Process, exepath string) (*Process, error) {
}
dbp.execPtraceFunc(func() {
err = _ContinueDebugEvent(uint32(dbp.pid), uint32(dbp.os.breakThread), _DBG_CONTINUE)
err = _ContinueDebugEvent(uint32(dbp.Pid), uint32(dbp.os.breakThread), _DBG_CONTINUE)
})
if err != nil {
return nil, err
@ -209,7 +209,7 @@ func (dbp *Process) Kill() error {
if dbp.exited {
return nil
}
if !dbp.threads[dbp.pid].Stopped() {
if !dbp.Threads[dbp.Pid].Stopped() {
return errors.New("process must be stopped in order to kill it")
}
// TODO: Should not have to ignore failures here,
@ -231,7 +231,7 @@ func (dbp *Process) updateThreadList() error {
}
func (dbp *Process) addThread(hThread syscall.Handle, threadID int, attach, suspendNewThreads bool) (*Thread, error) {
if thread, ok := dbp.threads[threadID]; ok {
if thread, ok := dbp.Threads[threadID]; ok {
return thread, nil
}
thread := &Thread{
@ -240,8 +240,8 @@ func (dbp *Process) addThread(hThread syscall.Handle, threadID int, attach, susp
os: new(OSSpecificDetails),
}
thread.os.hThread = hThread
dbp.threads[threadID] = thread
if dbp.currentThread == nil {
dbp.Threads[threadID] = thread
if dbp.CurrentThread == nil {
dbp.SwitchThread(thread.ID)
}
if suspendNewThreads {
@ -488,7 +488,7 @@ func (dbp *Process) waitForDebugEvent(flags waitForDebugEventFlags) (threadID, e
}
break
case _EXIT_THREAD_DEBUG_EVENT:
delete(dbp.threads, int(debugEvent.ThreadId))
delete(dbp.Threads, int(debugEvent.ThreadId))
break
case _OUTPUT_DEBUG_STRING_EVENT:
//TODO: Handle debug output strings
@ -509,40 +509,11 @@ func (dbp *Process) waitForDebugEvent(flags waitForDebugEventFlags) (threadID, e
break
case _EXCEPTION_DEBUG_EVENT:
exception := (*_EXCEPTION_DEBUG_INFO)(unionPtr)
tid := int(debugEvent.ThreadId)
switch code := exception.ExceptionRecord.ExceptionCode; code {
case _EXCEPTION_BREAKPOINT:
// check if the exception address really is a breakpoint instruction, if
// it isn't we already removed that breakpoint and we can't deal with
// this exception anymore.
atbp := true
if thread, found := dbp.threads[tid]; found {
if data, err := thread.readMemory(exception.ExceptionRecord.ExceptionAddress, dbp.arch.BreakpointSize()); err == nil {
instr := dbp.arch.BreakpointInstruction()
for i := range instr {
if data[i] != instr[i] {
atbp = false
break
}
}
}
if !atbp {
thread.SetPC(uint64(exception.ExceptionRecord.ExceptionAddress))
}
}
if atbp {
dbp.os.breakThread = tid
return tid, 0, nil
} else {
continueStatus = _DBG_CONTINUE
}
case _EXCEPTION_SINGLE_STEP:
if code := exception.ExceptionRecord.ExceptionCode; code == _EXCEPTION_BREAKPOINT || code == _EXCEPTION_SINGLE_STEP {
tid := int(debugEvent.ThreadId)
dbp.os.breakThread = tid
return tid, 0, nil
default:
} else {
continueStatus = _DBG_EXCEPTION_NOT_HANDLED
}
case _EXIT_PROCESS_DEBUG_EVENT:
@ -576,9 +547,9 @@ func (dbp *Process) trapWait(pid int) (*Thread, error) {
}
if tid == 0 {
dbp.postExit()
return nil, ProcessExitedError{Pid: dbp.pid, Status: exitCode}
return nil, ProcessExitedError{Pid: dbp.Pid, Status: exitCode}
}
th := dbp.threads[tid]
th := dbp.Threads[tid]
return th, nil
}
@ -606,7 +577,7 @@ func (dbp *Process) setCurrentBreakpoints(trapthread *Thread) error {
return err
}
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
thread.running = false
_, err := _SuspendThread(thread.os.hThread)
if err != nil {
@ -618,7 +589,7 @@ func (dbp *Process) setCurrentBreakpoints(trapthread *Thread) error {
var err error
var tid int
dbp.execPtraceFunc(func() {
err = _ContinueDebugEvent(uint32(dbp.pid), uint32(dbp.os.breakThread), _DBG_CONTINUE)
err = _ContinueDebugEvent(uint32(dbp.Pid), uint32(dbp.os.breakThread), _DBG_CONTINUE)
if err == nil {
tid, _, _ = dbp.waitForDebugEvent(waitSuspendNewThreads)
}
@ -629,7 +600,7 @@ func (dbp *Process) setCurrentBreakpoints(trapthread *Thread) error {
if tid == 0 {
break
}
err = dbp.threads[tid].SetCurrentBreakpoint()
err = dbp.Threads[tid].SetCurrentBreakpoint()
if err != nil {
return err
}
@ -643,7 +614,7 @@ func (dbp *Process) exitGuard(err error) error {
}
func (dbp *Process) resume() error {
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
if thread.CurrentBreakpoint != nil {
if err := thread.StepInstruction(); err != nil {
return err
@ -652,7 +623,7 @@ func (dbp *Process) resume() error {
}
}
for _, thread := range dbp.threads {
for _, thread := range dbp.Threads {
thread.running = true
_, err := _ResumeThread(thread.os.hThread)
if err != nil {

0
vendor/github.com/derekparker/delve/pkg/proc/ptrace_darwin.go → vendor/github.com/derekparker/delve/proc/ptrace_darwin.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/ptrace_linux.go → vendor/github.com/derekparker/delve/proc/ptrace_linux.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/ptrace_windows.go → vendor/github.com/derekparker/delve/proc/ptrace_windows.go generated vendored
View File

1
vendor/github.com/derekparker/delve/pkg/proc/registers.go → vendor/github.com/derekparker/delve/proc/registers.go generated vendored
View File

@ -17,7 +17,6 @@ import (
type Registers interface {
PC() uint64
SP() uint64
BP() uint64
CX() uint64
TLS() uint64
Get(int) (uint64, error)

6
vendor/github.com/derekparker/delve/pkg/proc/registers_darwin_amd64.go → vendor/github.com/derekparker/delve/proc/registers_darwin_amd64.go generated vendored
View File

@ -88,10 +88,6 @@ func (r *Regs) SP() uint64 {
return r.rsp
}
func (r *Regs) BP() uint64 {
return r.rbp
}
// CX returns the value of the RCX register.
func (r *Regs) CX() uint64 {
return r.rcx
@ -134,7 +130,7 @@ func (r *Regs) Get(n int) (uint64, error) {
case x86asm.AH:
return (r.rax >> 8) & mask8, nil
case x86asm.CH:
return (r.rcx >> 8) & mask8, nil
return (r.rax >> 8) & mask8, nil
case x86asm.DH:
return (r.rdx >> 8) & mask8, nil
case x86asm.BH:

6
vendor/github.com/derekparker/delve/pkg/proc/registers_linux_amd64.go → vendor/github.com/derekparker/delve/proc/registers_linux_amd64.go generated vendored
View File

@ -69,10 +69,6 @@ func (r *Regs) SP() uint64 {
return r.regs.Rsp
}
func (r *Regs) BP() uint64 {
return r.regs.Rbp
}
// CX returns the value of RCX register.
func (r *Regs) CX() uint64 {
return r.regs.Rcx
@ -112,7 +108,7 @@ func (r *Regs) Get(n int) (uint64, error) {
case x86asm.AH:
return (r.regs.Rax >> 8) & mask8, nil
case x86asm.CH:
return (r.regs.Rcx >> 8) & mask8, nil
return (r.regs.Rax >> 8) & mask8, nil
case x86asm.DH:
return (r.regs.Rdx >> 8) & mask8, nil
case x86asm.BH:

6
vendor/github.com/derekparker/delve/pkg/proc/registers_windows_amd64.go → vendor/github.com/derekparker/delve/proc/registers_windows_amd64.go generated vendored
View File

@ -107,10 +107,6 @@ func (r *Regs) SP() uint64 {
return r.rsp
}
func (r *Regs) BP() uint64 {
return r.rbp
}
// CX returns the value of the RCX register.
func (r *Regs) CX() uint64 {
return r.rcx
@ -159,7 +155,7 @@ func (r *Regs) Get(n int) (uint64, error) {
case x86asm.AH:
return (r.rax >> 8) & mask8, nil
case x86asm.CH:
return (r.rcx >> 8) & mask8, nil
return (r.rax >> 8) & mask8, nil
case x86asm.DH:
return (r.rdx >> 8) & mask8, nil
case x86asm.BH:

112
vendor/github.com/derekparker/delve/pkg/proc/stack.go → vendor/github.com/derekparker/delve/proc/stack.go generated vendored
View File

@ -1,17 +1,12 @@
package proc
import (
"encoding/binary"
"errors"
"fmt"
"github.com/derekparker/delve/pkg/dwarf/frame"
"github.com/derekparker/delve/dwarf/frame"
)
// This code is partly adaped from runtime.gentraceback in
// $GOROOT/src/runtime/traceback.go
const runtimeStackBarrier = "runtime.stackBarrier"
// NoReturnAddr is returned when return address
// could not be found during stack trace.
type NoReturnAddr struct {
@ -34,8 +29,6 @@ type Stackframe struct {
FDE *frame.FrameDescriptionEntry
// Return address for this stack frame (as read from the stack frame itself).
Ret uint64
// Address to the memory location containing the return address
addrret uint64
}
// Scope returns a new EvalScope using this frame.
@ -56,18 +49,18 @@ func (t *Thread) ReturnAddress() (uint64, error) {
return locations[1].Current.PC, nil
}
func (t *Thread) stackIterator(stkbar []savedLR, stkbarPos int) (*stackIterator, error) {
func (t *Thread) stackIterator() (*stackIterator, error) {
regs, err := t.Registers(false)
if err != nil {
return nil, err
}
return newStackIterator(t.dbp, regs.PC(), regs.SP(), regs.BP(), stkbar, stkbarPos), nil
return newStackIterator(t.dbp, regs.PC(), regs.SP()), nil
}
// Stacktrace returns the stack trace for thread.
// Note the locations in the array are return addresses not call addresses.
func (t *Thread) Stacktrace(depth int) ([]Stackframe, error) {
it, err := t.stackIterator(nil, -1)
it, err := t.stackIterator()
if err != nil {
return nil, err
}
@ -75,14 +68,10 @@ func (t *Thread) Stacktrace(depth int) ([]Stackframe, error) {
}
func (g *G) stackIterator() (*stackIterator, error) {
stkbar, err := g.stkbar()
if err != nil {
return nil, err
}
if g.thread != nil {
return g.thread.stackIterator(stkbar, g.stkbarPos)
return g.thread.stackIterator()
}
return newStackIterator(g.dbp, g.PC, g.SP, 0, stkbar, g.stkbarPos), nil
return newStackIterator(g.dbp, g.PC, g.SP), nil
}
// Stacktrace returns the stack trace for a goroutine.
@ -113,43 +102,16 @@ func (n NullAddrError) Error() string {
// required to iterate and walk the program
// stack.
type stackIterator struct {
pc, sp, bp uint64
top bool
atend bool
frame Stackframe
dbp *Process
err error
stackBarrierPC uint64
stkbar []savedLR
pc, sp uint64
top bool
atend bool
frame Stackframe
dbp *Process
err error
}
type savedLR struct {
ptr uint64
val uint64
}
func newStackIterator(dbp *Process, pc, sp, bp uint64, stkbar []savedLR, stkbarPos int) *stackIterator {
stackBarrierFunc := dbp.goSymTable.LookupFunc(runtimeStackBarrier) // stack barriers were removed in Go 1.9
var stackBarrierPC uint64
if stackBarrierFunc != nil && stkbar != nil {
stackBarrierPC = stackBarrierFunc.Entry
fn := dbp.goSymTable.PCToFunc(pc)
if fn != nil && fn.Name == runtimeStackBarrier {
// We caught the goroutine as it's executing the stack barrier, we must
// determine whether or not g.stackPos has already been incremented or not.
if len(stkbar) > 0 && stkbar[stkbarPos].ptr < sp {
// runtime.stackBarrier has not incremented stkbarPos.
} else if stkbarPos > 0 && stkbar[stkbarPos-1].ptr < sp {
// runtime.stackBarrier has incremented stkbarPos.
stkbarPos--
} else {
return &stackIterator{err: fmt.Errorf("failed to unwind through stackBarrier at SP %x", sp)}
}
}
stkbar = stkbar[stkbarPos:]
}
return &stackIterator{pc: pc, sp: sp, bp: bp, top: true, dbp: dbp, err: nil, atend: false, stackBarrierPC: stackBarrierPC, stkbar: stkbar}
func newStackIterator(dbp *Process, pc, sp uint64) *stackIterator {
return &stackIterator{pc: pc, sp: sp, top: true, dbp: dbp, err: nil, atend: false}
}
// Next points the iterator to the next stack frame.
@ -157,7 +119,7 @@ func (it *stackIterator) Next() bool {
if it.err != nil || it.atend {
return false
}
it.frame, it.err = it.dbp.frameInfo(it.pc, it.sp, it.bp, it.top)
it.frame, it.err = it.dbp.frameInfo(it.pc, it.sp, it.top)
if it.err != nil {
if _, nofde := it.err.(*frame.NoFDEForPCError); nofde && !it.top {
it.frame = Stackframe{Current: Location{PC: it.pc, File: "?", Line: -1}, Call: Location{PC: it.pc, File: "?", Line: -1}, CFA: 0, Ret: 0}
@ -168,19 +130,19 @@ func (it *stackIterator) Next() bool {
return false
}
if it.frame.Current.Fn == nil {
if it.top {
it.err = fmt.Errorf("PC not associated to any function")
}
return false
}
if it.frame.Ret <= 0 {
it.atend = true
return true
}
if it.stkbar != nil && it.frame.Ret == it.stackBarrierPC && it.frame.addrret == it.stkbar[0].ptr {
// Skip stack barrier frames
it.frame.Ret = it.stkbar[0].val
it.stkbar = it.stkbar[1:]
}
// Look for "top of stack" functions.
if it.frame.Current.Fn != nil && (it.frame.Current.Fn.Name == "runtime.goexit" || it.frame.Current.Fn.Name == "runtime.rt0_go" || it.frame.Current.Fn.Name == "runtime.mcall") {
if it.frame.Current.Fn.Name == "runtime.goexit" || it.frame.Current.Fn.Name == "runtime.rt0_go" || it.frame.Current.Fn.Name == "runtime.mcall" {
it.atend = true
return true
}
@ -188,7 +150,6 @@ func (it *stackIterator) Next() bool {
it.top = false
it.pc = it.frame.Ret
it.sp = uint64(it.frame.CFA)
it.bp, _ = readUintRaw(it.dbp.currentThread, uintptr(it.bp), int64(it.dbp.arch.PtrSize()))
return true
}
@ -205,38 +166,27 @@ func (it *stackIterator) Err() error {
return it.err
}
func (dbp *Process) frameInfo(pc, sp, bp uint64, top bool) (Stackframe, error) {
func (dbp *Process) frameInfo(pc, sp uint64, top bool) (Stackframe, error) {
f, l, fn := dbp.PCToLine(pc)
fde, err := dbp.frameEntries.FDEForPC(pc)
if _, nofde := err.(*frame.NoFDEForPCError); nofde {
if bp == 0 {
return Stackframe{}, err
}
// When no FDE is available attempt to use BP instead
retaddr := uintptr(int(bp) + dbp.arch.PtrSize())
cfa := int64(retaddr) + int64(dbp.arch.PtrSize())
return dbp.newStackframe(pc, cfa, retaddr, nil, top)
if err != nil {
return Stackframe{}, err
}
spoffset, retoffset := fde.ReturnAddressOffset(pc)
cfa := int64(sp) + spoffset
retaddr := uintptr(cfa + retoffset)
return dbp.newStackframe(pc, cfa, retaddr, fde, top)
}
func (dbp *Process) newStackframe(pc uint64, cfa int64, retaddr uintptr, fde *frame.FrameDescriptionEntry, top bool) (Stackframe, error) {
if retaddr == 0 {
return Stackframe{}, NullAddrError{}
}
f, l, fn := dbp.PCToLine(pc)
ret, err := readUintRaw(dbp.currentThread, retaddr, int64(dbp.arch.PtrSize()))
data, err := dbp.CurrentThread.readMemory(retaddr, dbp.arch.PtrSize())
if err != nil {
return Stackframe{}, err
}
r := Stackframe{Current: Location{PC: pc, File: f, Line: l, Fn: fn}, CFA: cfa, FDE: fde, Ret: ret, addrret: uint64(retaddr)}
r := Stackframe{Current: Location{PC: pc, File: f, Line: l, Fn: fn}, CFA: cfa, FDE: fde, Ret: binary.LittleEndian.Uint64(data)}
if !top {
r.Call.File, r.Call.Line, r.Call.Fn = dbp.PCToLine(pc - 1)
r.Call.PC = r.Current.PC
r.Call.PC, _, _ = dbp.goSymTable.LineToPC(r.Call.File, r.Call.Line)
} else {
r.Call = r.Current
}

0
vendor/github.com/derekparker/delve/pkg/proc/syscall_windows.go → vendor/github.com/derekparker/delve/proc/syscall_windows.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/proc/syscall_windows_amd64.go → vendor/github.com/derekparker/delve/proc/syscall_windows_amd64.go generated vendored
View File

38
vendor/github.com/derekparker/delve/pkg/proc/threads.go → vendor/github.com/derekparker/delve/proc/threads.go generated vendored
View File

@ -154,7 +154,7 @@ func topframe(g *G, thread *Thread) (Stackframe, error) {
// Continue will take care of setting a breakpoint to the destination
// once the CALL is reached.
func (dbp *Process) next(stepInto bool) error {
topframe, err := topframe(dbp.selectedGoroutine, dbp.currentThread)
topframe, err := topframe(dbp.SelectedGoroutine, dbp.CurrentThread)
if err != nil {
return err
}
@ -167,10 +167,10 @@ func (dbp *Process) next(stepInto bool) error {
}()
csource := filepath.Ext(topframe.Current.File) != ".go"
thread := dbp.currentThread
thread := dbp.CurrentThread
currentGoroutine := false
if dbp.selectedGoroutine != nil && dbp.selectedGoroutine.thread != nil {
thread = dbp.selectedGoroutine.thread
if dbp.SelectedGoroutine != nil && dbp.SelectedGoroutine.thread != nil {
thread = dbp.SelectedGoroutine.thread
currentGoroutine = true
}
@ -179,7 +179,7 @@ func (dbp *Process) next(stepInto bool) error {
return err
}
cond := sameGoroutineCondition(dbp.selectedGoroutine)
cond := sameGoroutineCondition(dbp.SelectedGoroutine)
if stepInto {
for _, instr := range text {
@ -215,15 +215,12 @@ func (dbp *Process) next(stepInto bool) error {
// Set breakpoint on the most recently deferred function (if any)
var deferpc uint64 = 0
if dbp.selectedGoroutine != nil {
deferPCEntry := dbp.selectedGoroutine.DeferPC()
if deferPCEntry != 0 {
_, _, deferfn := dbp.goSymTable.PCToLine(deferPCEntry)
var err error
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
if err != nil {
return err
}
if dbp.SelectedGoroutine != nil && dbp.SelectedGoroutine.DeferPC != 0 {
_, _, deferfn := dbp.goSymTable.PCToLine(dbp.SelectedGoroutine.DeferPC)
var err error
deferpc, err = dbp.FirstPCAfterPrologue(deferfn, false)
if err != nil {
return err
}
}
if deferpc != 0 && deferpc != topframe.Current.PC {
@ -256,7 +253,7 @@ func (dbp *Process) next(stepInto bool) error {
if !covered {
fn := dbp.goSymTable.PCToFunc(topframe.Ret)
if dbp.selectedGoroutine != nil && fn != nil && fn.Name == "runtime.goexit" {
if dbp.SelectedGoroutine != nil && fn != nil && fn.Name == "runtime.goexit" {
return nil
}
}
@ -342,7 +339,7 @@ func (thread *Thread) getGVariable() (*Variable, error) {
if thread.dbp.arch.GStructOffset() == 0 {
// GetG was called through SwitchThread / updateThreadList during initialization
// thread.dbp.arch isn't setup yet (it needs a current thread to read global variables from)
// thread.dbp.arch isn't setup yet (it needs a CurrentThread to read global variables from)
return nil, fmt.Errorf("g struct offset not initialized")
}
@ -399,9 +396,6 @@ func (thread *Thread) GetG() (g *G, err error) {
g, err = gaddr.parseG()
if err == nil {
g.thread = thread
if loc, err := thread.Location(); err == nil {
g.CurrentLoc = *loc
}
}
return
}
@ -490,9 +484,9 @@ func (thread *Thread) onRuntimeBreakpoint() bool {
// onNextGorutine returns true if this thread is on the goroutine requested by the current 'next' command
func (thread *Thread) onNextGoroutine() (bool, error) {
var bp *Breakpoint
for i := range thread.dbp.breakpoints {
if thread.dbp.breakpoints[i].Internal() {
bp = thread.dbp.breakpoints[i]
for i := range thread.dbp.Breakpoints {
if thread.dbp.Breakpoints[i].Internal() {
bp = thread.dbp.Breakpoints[i]
break
}
}

0
vendor/github.com/derekparker/delve/pkg/proc/threads_darwin.c → vendor/github.com/derekparker/delve/proc/threads_darwin.c generated vendored
View File

9
vendor/github.com/derekparker/delve/pkg/proc/threads_darwin.go → vendor/github.com/derekparker/delve/proc/threads_darwin.go generated vendored
View File

@ -5,9 +5,8 @@ package proc
import "C"
import (
"fmt"
"unsafe"
sys "golang.org/x/sys/unix"
"unsafe"
)
// WaitStatus is a synonym for the platform-specific WaitStatus
@ -36,7 +35,7 @@ func (t *Thread) halt() (err error) {
return
}
if _, ok := t.dbp.threads[t.ID]; ok {
if _, ok := t.dbp.Threads[t.ID]; ok {
err = fmt.Errorf("could not suspend thread %d %s", t.ID, errStr)
return
}
@ -50,7 +49,7 @@ func (t *Thread) singleStep() error {
return fmt.Errorf("could not single step")
}
for {
twthread, err := t.dbp.trapWait(t.dbp.pid)
twthread, err := t.dbp.trapWait(t.dbp.Pid)
if err != nil {
return err
}
@ -70,7 +69,7 @@ func (t *Thread) resume() error {
t.running = true
// TODO(dp) set flag for ptrace stops
var err error
t.dbp.execPtraceFunc(func() { err = PtraceCont(t.dbp.pid, 0) })
t.dbp.execPtraceFunc(func() { err = PtraceCont(t.dbp.Pid, 0) })
if err == nil {
return nil
}

0
vendor/github.com/derekparker/delve/pkg/proc/threads_darwin.h → vendor/github.com/derekparker/delve/proc/threads_darwin.h generated vendored
View File

8
vendor/github.com/derekparker/delve/pkg/proc/threads_linux.go → vendor/github.com/derekparker/delve/proc/threads_linux.go generated vendored
View File

@ -15,7 +15,7 @@ type OSSpecificDetails struct {
}
func (t *Thread) halt() (err error) {
err = sys.Tgkill(t.dbp.pid, t.ID, sys.SIGSTOP)
err = sys.Tgkill(t.dbp.Pid, t.ID, sys.SIGSTOP)
if err != nil {
err = fmt.Errorf("halt err %s on thread %d", err, t.ID)
return
@ -49,17 +49,17 @@ func (t *Thread) singleStep() (err error) {
if err != nil {
return err
}
wpid, status, err := t.dbp.waitFast(t.ID)
wpid, status, err := t.dbp.wait(t.ID, 0)
if err != nil {
return err
}
if (status == nil || status.Exited()) && wpid == t.dbp.pid {
if (status == nil || status.Exited()) && wpid == t.dbp.Pid {
t.dbp.postExit()
rs := 0
if status != nil {
rs = status.ExitStatus()
}
return ProcessExitedError{Pid: t.dbp.pid, Status: rs}
return ProcessExitedError{Pid: t.dbp.Pid, Status: rs}
}
if wpid == t.ID && status.StopSignal() == sys.SIGTRAP {
return nil

8
vendor/github.com/derekparker/delve/pkg/proc/threads_windows.go → vendor/github.com/derekparker/delve/proc/threads_windows.go generated vendored
View File

@ -57,7 +57,7 @@ func (t *Thread) singleStep() error {
}
if tid == 0 {
t.dbp.postExit()
return ProcessExitedError{Pid: t.dbp.pid, Status: exitCode}
return ProcessExitedError{Pid: t.dbp.Pid, Status: exitCode}
}
if t.dbp.os.breakThread == t.ID {
@ -65,7 +65,7 @@ func (t *Thread) singleStep() error {
}
t.dbp.execPtraceFunc(func() {
err = _ContinueDebugEvent(uint32(t.dbp.pid), uint32(t.dbp.os.breakThread), _DBG_CONTINUE)
err = _ContinueDebugEvent(uint32(t.dbp.Pid), uint32(t.dbp.os.breakThread), _DBG_CONTINUE)
})
}
@ -75,7 +75,7 @@ func (t *Thread) singleStep() error {
}
t.dbp.execPtraceFunc(func() {
err = _ContinueDebugEvent(uint32(t.dbp.pid), uint32(t.ID), _DBG_CONTINUE)
err = _ContinueDebugEvent(uint32(t.dbp.Pid), uint32(t.ID), _DBG_CONTINUE)
})
if err != nil {
return err
@ -98,7 +98,7 @@ func (t *Thread) resume() error {
t.dbp.execPtraceFunc(func() {
//TODO: Note that we are ignoring the thread we were asked to continue and are continuing the
//thread that we last broke on.
err = _ContinueDebugEvent(uint32(t.dbp.pid), uint32(t.ID), _DBG_CONTINUE)
err = _ContinueDebugEvent(uint32(t.dbp.Pid), uint32(t.ID), _DBG_CONTINUE)
})
return err
}

74
vendor/github.com/derekparker/delve/pkg/proc/types.go → vendor/github.com/derekparker/delve/proc/types.go generated vendored
View File

@ -8,13 +8,12 @@ import (
"go/constant"
"go/token"
"reflect"
"sort"
"strconv"
"strings"
"sync"
"unsafe"
"github.com/derekparker/delve/pkg/dwarf/reader"
"github.com/derekparker/delve/dwarf/reader"
"golang.org/x/debug/dwarf"
)
@ -119,61 +118,22 @@ func (dbp *Process) loadPackageMap() error {
return nil
}
type sortFunctionsDebugInfoByLowpc []functionDebugInfo
func (v sortFunctionsDebugInfoByLowpc) Len() int { return len(v) }
func (v sortFunctionsDebugInfoByLowpc) Less(i, j int) bool { return v[i].lowpc < v[j].lowpc }
func (v sortFunctionsDebugInfoByLowpc) Swap(i, j int) {
temp := v[i]
v[i] = v[j]
v[j] = temp
}
func (dbp *Process) loadDebugInfoMaps(wg *sync.WaitGroup) {
func (dbp *Process) loadTypeMap(wg *sync.WaitGroup) {
defer wg.Done()
dbp.types = make(map[string]dwarf.Offset)
dbp.functions = []functionDebugInfo{}
reader := dbp.DwarfReader()
for entry, err := reader.Next(); entry != nil; entry, err = reader.Next() {
for entry, err := reader.NextType(); entry != nil; entry, err = reader.NextType() {
if err != nil {
break
}
switch entry.Tag {
case dwarf.TagArrayType, dwarf.TagBaseType, dwarf.TagClassType, dwarf.TagStructType, dwarf.TagUnionType, dwarf.TagConstType, dwarf.TagVolatileType, dwarf.TagRestrictType, dwarf.TagEnumerationType, dwarf.TagPointerType, dwarf.TagSubroutineType, dwarf.TagTypedef, dwarf.TagUnspecifiedType:
name, ok := entry.Val(dwarf.AttrName).(string)
if !ok {
continue
}
if _, exists := dbp.types[name]; !exists {
dbp.types[name] = entry.Offset
}
case dwarf.TagSubprogram:
lowpc, ok := entry.Val(dwarf.AttrLowpc).(uint64)
if !ok {
continue
}
highpc, ok := entry.Val(dwarf.AttrHighpc).(uint64)
if !ok {
continue
}
dbp.functions = append(dbp.functions, functionDebugInfo{lowpc, highpc, entry.Offset})
name, ok := entry.Val(dwarf.AttrName).(string)
if !ok {
continue
}
if _, exists := dbp.types[name]; !exists {
dbp.types[name] = entry.Offset
}
}
sort.Sort(sortFunctionsDebugInfoByLowpc(dbp.functions))
}
func (dbp *Process) findFunctionDebugInfo(pc uint64) (dwarf.Offset, error) {
i := sort.Search(len(dbp.functions), func(i int) bool {
fn := dbp.functions[i]
return pc <= fn.lowpc || (fn.lowpc <= pc && pc < fn.highpc)
})
if i != len(dbp.functions) {
fn := dbp.functions[i]
if fn.lowpc <= pc && pc < fn.highpc {
return fn.offset, nil
}
}
return 0, errors.New("unable to find function context")
}
func (dbp *Process) expandPackagesInType(expr ast.Expr) {
@ -227,10 +187,10 @@ func nameOfRuntimeType(_type *Variable) (typename string, kind int64, err error)
var tflag int64
if tflagField := _type.loadFieldNamed("tflag"); tflagField != nil && tflagField.Value != nil {
if tflagField := _type.toFieldNamed("tflag"); tflagField != nil && tflagField.Value != nil {
tflag, _ = constant.Int64Val(tflagField.Value)
}
if kindField := _type.loadFieldNamed("kind"); kindField != nil && kindField.Value != nil {
if kindField := _type.toFieldNamed("kind"); kindField != nil && kindField.Value != nil {
kind, _ = constant.Int64Val(kindField.Value)
}
@ -267,7 +227,7 @@ func nameOfRuntimeType(_type *Variable) (typename string, kind int64, err error)
// to a runtime.slicetype).
func nameOfNamedRuntimeType(_type *Variable, kind, tflag int64) (typename string, err error) {
var strOff int64
if strField := _type.loadFieldNamed("str"); strField != nil && strField.Value != nil {
if strField := _type.toFieldNamed("str"); strField != nil && strField.Value != nil {
strOff, _ = constant.Int64Val(strField.Value)
} else {
return "", errors.New("could not find str field")
@ -301,7 +261,7 @@ func nameOfNamedRuntimeType(_type *Variable, kind, tflag int64) (typename string
}
if ut := uncommon(_type, tflag); ut != nil {
if pkgPathField := ut.loadFieldNamed("pkgpath"); pkgPathField != nil && pkgPathField.Value != nil {
if pkgPathField := ut.toFieldNamed("pkgpath"); pkgPathField != nil && pkgPathField.Value != nil {
pkgPathOff, _ := constant.Int64Val(pkgPathField.Value)
pkgPath, _, _, err := _type.dbp.resolveNameOff(_type.Addr, uintptr(pkgPathOff))
if err != nil {
@ -324,7 +284,7 @@ func nameOfUnnamedRuntimeType(_type *Variable, kind, tflag int64) (string, error
switch reflect.Kind(kind & kindMask) {
case reflect.Array:
var len int64
if lenField := _type.loadFieldNamed("len"); lenField != nil && lenField.Value != nil {
if lenField := _type.toFieldNamed("len"); lenField != nil && lenField.Value != nil {
len, _ = constant.Int64Val(lenField.Value)
}
elemname, err := fieldToType(_type, "elem")
@ -388,10 +348,10 @@ func nameOfFuncRuntimeType(_type *Variable, tflag int64, anonymous bool) (string
}
var inCount, outCount int64
if inCountField := _type.loadFieldNamed("inCount"); inCountField != nil && inCountField.Value != nil {
if inCountField := _type.toFieldNamed("inCount"); inCountField != nil && inCountField.Value != nil {
inCount, _ = constant.Int64Val(inCountField.Value)
}
if outCountField := _type.loadFieldNamed("outCount"); outCountField != nil && outCountField.Value != nil {
if outCountField := _type.toFieldNamed("outCount"); outCountField != nil && outCountField.Value != nil {
outCount, _ = constant.Int64Val(outCountField.Value)
// only the lowest 15 bits of outCount are used, rest are flags
outCount = outCount & (1<<15 - 1)
@ -489,7 +449,7 @@ func nameOfInterfaceRuntimeType(_type *Variable, kind, tflag int64) (string, err
return "", err
}
var tflag int64
if tflagField := typ.loadFieldNamed("tflag"); tflagField != nil && tflagField.Value != nil {
if tflagField := typ.toFieldNamed("tflag"); tflagField != nil && tflagField.Value != nil {
tflag, _ = constant.Int64Val(tflagField.Value)
}
methodtype, err = nameOfFuncRuntimeType(typ, tflag, false)

217
vendor/github.com/derekparker/delve/pkg/proc/variables.go → vendor/github.com/derekparker/delve/proc/variables.go generated vendored
View File

@ -8,13 +8,12 @@ import (
"go/constant"
"go/parser"
"go/token"
"math"
"reflect"
"strings"
"unsafe"
"github.com/derekparker/delve/pkg/dwarf/op"
"github.com/derekparker/delve/pkg/dwarf/reader"
"github.com/derekparker/delve/dwarf/op"
"github.com/derekparker/delve/dwarf/reader"
"golang.org/x/debug/dwarf"
)
@ -30,15 +29,6 @@ const (
hashMinTopHash = 4 // used by map reading code, indicates minimum value of tophash that isn't empty or evacuated
)
type FloatSpecial uint8
const (
FloatIsNormal FloatSpecial = iota
FloatIsNaN
FloatIsPosInf
FloatIsNegInf
)
// Variable represents a variable. It contains the address, name,
// type and other information parsed from both the Dwarf information
// and the memory of the debugged process.
@ -53,8 +43,7 @@ type Variable struct {
mem memoryReadWriter
dbp *Process
Value constant.Value
FloatSpecial FloatSpecial
Value constant.Value
Len int64
Cap int64
@ -122,17 +111,17 @@ type G struct {
GoPC uint64 // PC of 'go' statement that created this goroutine.
WaitReason string // Reason for goroutine being parked.
Status uint64
stkbarVar *Variable // stkbar field of g struct
stkbarPos int // stkbarPos field of g struct
// Information on goroutine location
CurrentLoc Location
// PC of entry to top-most deferred function.
DeferPC uint64
// Thread that this goroutine is currently allocated to
thread *Thread
variable *Variable
dbp *Process
dbp *Process
}
// EvalScope is the scope for variable evaluation. Contains the thread,
@ -380,31 +369,24 @@ func (gvar *Variable) parseG() (*G, error) {
}
return nil, NoGError{tid: id}
}
for {
if _, isptr := gvar.RealType.(*dwarf.PtrType); !isptr {
break
}
gvar = gvar.maybeDereference()
}
gvar.loadValue(LoadConfig{false, 1, 64, 0, -1})
gvar.loadValue(loadFullValue)
if gvar.Unreadable != nil {
return nil, gvar.Unreadable
}
schedVar := gvar.fieldVariable("sched")
pc, _ := constant.Int64Val(schedVar.fieldVariable("pc").Value)
sp, _ := constant.Int64Val(schedVar.fieldVariable("sp").Value)
id, _ := constant.Int64Val(gvar.fieldVariable("goid").Value)
gopc, _ := constant.Int64Val(gvar.fieldVariable("gopc").Value)
waitReason := constant.StringVal(gvar.fieldVariable("waitreason").Value)
stkbarVar, _ := gvar.structMember("stkbar")
stkbarVarPosFld := gvar.fieldVariable("stkbarPos")
var stkbarPos int64
if stkbarVarPosFld != nil { // stack barriers were removed in Go 1.9
stkbarPos, _ = constant.Int64Val(stkbarVarPosFld.Value)
schedVar := gvar.toFieldNamed("sched")
pc, _ := constant.Int64Val(schedVar.toFieldNamed("pc").Value)
sp, _ := constant.Int64Val(schedVar.toFieldNamed("sp").Value)
id, _ := constant.Int64Val(gvar.toFieldNamed("goid").Value)
gopc, _ := constant.Int64Val(gvar.toFieldNamed("gopc").Value)
waitReason := constant.StringVal(gvar.toFieldNamed("waitreason").Value)
d := gvar.toFieldNamed("_defer")
deferPC := int64(0)
fnvar := d.toFieldNamed("fn")
if fnvar != nil {
fnvalvar := fnvar.toFieldNamed("fn")
deferPC, _ = constant.Int64Val(fnvalvar.Value)
}
status, _ := constant.Int64Val(gvar.fieldVariable("atomicstatus").Value)
status, _ := constant.Int64Val(gvar.toFieldNamed("atomicstatus").Value)
f, l, fn := gvar.dbp.goSymTable.PCToLine(uint64(pc))
g := &G{
ID: int(id),
@ -412,17 +394,15 @@ func (gvar *Variable) parseG() (*G, error) {
PC: uint64(pc),
SP: uint64(sp),
WaitReason: waitReason,
DeferPC: uint64(deferPC),
Status: uint64(status),
CurrentLoc: Location{PC: uint64(pc), File: f, Line: l, Fn: fn},
variable: gvar,
stkbarVar: stkbarVar,
stkbarPos: int(stkbarPos),
dbp: gvar.dbp,
}
return g, nil
}
func (v *Variable) loadFieldNamed(name string) *Variable {
func (v *Variable) toFieldNamed(name string) *Variable {
v, err := v.structMember(name)
if err != nil {
return nil
@ -434,40 +414,6 @@ func (v *Variable) loadFieldNamed(name string) *Variable {
return v
}
func (v *Variable) fieldVariable(name string) *Variable {
for i := range v.Children {
if child := &v.Children[i]; child.Name == name {
return child
}
}
return nil
}
// PC of entry to top-most deferred function.
func (g *G) DeferPC() uint64 {
if g.variable.Unreadable != nil {
return 0
}
d := g.variable.fieldVariable("_defer").maybeDereference()
if d.Addr == 0 {
return 0
}
d.loadValue(LoadConfig{false, 1, 64, 0, -1})
if d.Unreadable != nil {
return 0
}
fnvar := d.fieldVariable("fn").maybeDereference()
if fnvar.Addr == 0 {
return 0
}
fnvar.loadValue(LoadConfig{false, 1, 64, 0, -1})
if fnvar.Unreadable != nil {
return 0
}
deferPC, _ := constant.Int64Val(fnvar.fieldVariable("fn").Value)
return uint64(deferPC)
}
// From $GOROOT/src/runtime/traceback.go:597
// isExportedRuntime reports whether name is an exported runtime function.
// It is only for runtime functions, so ASCII A-Z is fine.
@ -502,31 +448,6 @@ func (g *G) Go() Location {
return Location{PC: g.GoPC, File: f, Line: l, Fn: fn}
}
// Returns the list of saved return addresses used by stack barriers
func (g *G) stkbar() ([]savedLR, error) {
if g.stkbarVar == nil { // stack barriers were removed in Go 1.9
return nil, nil
}
g.stkbarVar.loadValue(LoadConfig{false, 1, 0, int(g.stkbarVar.Len), 3})
if g.stkbarVar.Unreadable != nil {
return nil, fmt.Errorf("unreadable stkbar: %v\n", g.stkbarVar.Unreadable)
}
r := make([]savedLR, len(g.stkbarVar.Children))
for i, child := range g.stkbarVar.Children {
for _, field := range child.Children {
switch field.Name {
case "savedLRPtr":
ptr, _ := constant.Int64Val(field.Value)
r[i].ptr = uint64(ptr)
case "savedLRVal":
val, _ := constant.Int64Val(field.Value)
r[i].val = uint64(val)
}
}
}
return r, nil
}
// EvalVariable returns the value of the given expression (backwards compatibility).
func (scope *EvalScope) EvalVariable(name string, cfg LoadConfig) (*Variable, error) {
return scope.EvalExpression(name, cfg)
@ -581,25 +502,22 @@ func (scope *EvalScope) extractVariableFromEntry(entry *dwarf.Entry, cfg LoadCon
if err != nil {
return nil, err
}
v.loadValue(cfg)
return v, nil
}
func (scope *EvalScope) extractVarInfo(varName string) (*Variable, error) {
reader := scope.DwarfReader()
off, err := scope.Thread.dbp.findFunctionDebugInfo(scope.PC)
_, err := reader.SeekToFunction(scope.PC)
if err != nil {
return nil, err
}
reader.Seek(off)
reader.Next()
for entry, err := reader.NextScopeVariable(); entry != nil; entry, err = reader.NextScopeVariable() {
if err != nil {
return nil, err
}
if entry.Tag == 0 {
break
}
n, ok := entry.Val(dwarf.AttrName).(string)
if !ok {
@ -648,7 +566,6 @@ func (scope *EvalScope) PackageVariables(cfg LoadConfig) ([]*Variable, error) {
if err != nil {
continue
}
val.loadValue(cfg)
vars = append(vars, val)
}
@ -658,7 +575,7 @@ func (scope *EvalScope) PackageVariables(cfg LoadConfig) ([]*Variable, error) {
// EvalPackageVariable will evaluate the package level variable
// specified by 'name'.
func (dbp *Process) EvalPackageVariable(name string, cfg LoadConfig) (*Variable, error) {
scope := &EvalScope{Thread: dbp.currentThread, PC: 0, CFA: 0}
scope := &EvalScope{Thread: dbp.CurrentThread, PC: 0, CFA: 0}
v, err := scope.packageVarAddr(name)
if err != nil {
@ -821,12 +738,7 @@ func (v *Variable) loadValueInternal(recurseLevel int, cfg LoadConfig) {
v.Children = []Variable{*v.maybeDereference()}
if cfg.FollowPointers {
// Don't increase the recursion level when dereferencing pointers
// unless this is a pointer to interface (which could cause an infinite loop)
nextLvl := recurseLevel
if v.Children[0].Kind == reflect.Interface {
nextLvl++
}
v.Children[0].loadValueInternal(nextLvl, cfg)
v.Children[0].loadValueInternal(recurseLevel, cfg)
} else {
v.Children[0].OnlyAddr = true
}
@ -896,14 +808,6 @@ func (v *Variable) loadValueInternal(recurseLevel int, cfg LoadConfig) {
var val float64
val, v.Unreadable = v.readFloatRaw(v.RealType.(*dwarf.FloatType).ByteSize)
v.Value = constant.MakeFloat64(val)
switch {
case math.IsInf(val, +1):
v.FloatSpecial = FloatIsPosInf
case math.IsInf(val, -1):
v.FloatSpecial = FloatIsNegInf
case math.IsNaN(val):
v.FloatSpecial = FloatIsNaN
}
case reflect.Func:
v.readFunctionPtr()
default:
@ -1333,18 +1237,9 @@ func (v *Variable) mapIterator() *mapIterator {
}
}
if it.buckets.Kind != reflect.Struct || it.oldbuckets.Kind != reflect.Struct {
v.Unreadable = mapBucketsNotStructErr
return nil
}
return it
}
var mapBucketContentsNotArrayErr = errors.New("malformed map type: keys, values or tophash of a bucket is not an array")
var mapBucketContentsInconsistentLenErr = errors.New("malformed map type: inconsistent array length in bucket")
var mapBucketsNotStructErr = errors.New("malformed map type: buckets, oldbuckets or overflow field not a struct")
func (it *mapIterator) nextBucket() bool {
if it.overflow != nil && it.overflow.Addr > 0 {
it.b = it.overflow
@ -1433,17 +1328,12 @@ func (it *mapIterator) nextBucket() bool {
}
if it.tophashes.Kind != reflect.Array || it.keys.Kind != reflect.Array || it.values.Kind != reflect.Array {
it.v.Unreadable = mapBucketContentsNotArrayErr
it.v.Unreadable = fmt.Errorf("malformed map type: keys, values or tophash of a bucket is not an array")
return false
}
if it.tophashes.Len != it.keys.Len || it.tophashes.Len != it.values.Len {
it.v.Unreadable = mapBucketContentsInconsistentLenErr
return false
}
if it.overflow.Kind != reflect.Struct {
it.v.Unreadable = mapBucketsNotStructErr
it.v.Unreadable = fmt.Errorf("malformed map type: inconsistent array length in bucket")
return false
}
@ -1644,7 +1534,7 @@ func (v *Variable) loadInterface(recurseLevel int, loadData bool, cfg LoadConfig
data = data.newVariable("data", data.Addr, typ)
v.Children = []Variable{*data}
if loadData && recurseLevel <= cfg.MaxVariableRecurse {
if loadData {
v.Children[0].loadValueInternal(recurseLevel, cfg)
} else {
v.Children[0].OnlyAddr = true
@ -1655,21 +1545,17 @@ func (v *Variable) loadInterface(recurseLevel int, loadData bool, cfg LoadConfig
// Fetches all variables of a specific type in the current function scope
func (scope *EvalScope) variablesByTag(tag dwarf.Tag, cfg LoadConfig) ([]*Variable, error) {
reader := scope.DwarfReader()
off, err := scope.Thread.dbp.findFunctionDebugInfo(scope.PC)
_, err := reader.SeekToFunction(scope.PC)
if err != nil {
return nil, err
}
reader.Seek(off)
reader.Next()
var vars []*Variable
for entry, err := reader.NextScopeVariable(); entry != nil; entry, err = reader.NextScopeVariable() {
if err != nil {
return nil, err
}
if entry.Tag == 0 {
break
}
if entry.Tag == tag {
val, err := scope.extractVariableFromEntry(entry, cfg)
@ -1681,43 +1567,6 @@ func (scope *EvalScope) variablesByTag(tag dwarf.Tag, cfg LoadConfig) ([]*Variab
vars = append(vars, val)
}
}
if len(vars) <= 0 {
return vars, nil
}
// prefetch the whole chunk of memory relative to these variables
minaddr := vars[0].Addr
var maxaddr uintptr
var size int64
for _, v := range vars {
if v.Addr < minaddr {
minaddr = v.Addr
}
size += v.DwarfType.Size()
if end := v.Addr + uintptr(v.DwarfType.Size()); end > maxaddr {
maxaddr = end
}
}
// check that we aren't trying to cache too much memory: we shouldn't
// exceed the real size of the variables by more than the number of
// variables times the size of an architecture pointer (to allow for memory
// alignment).
if int64(maxaddr-minaddr)-size <= int64(len(vars))*int64(scope.PtrSize()) {
mem := cacheMemory(vars[0].mem, minaddr, int(maxaddr-minaddr))
for _, v := range vars {
v.mem = mem
}
}
for _, v := range vars {
v.loadValue(cfg)
}
return vars, nil
}

0
vendor/github.com/derekparker/delve/pkg/proc/zsyscall_windows.go → vendor/github.com/derekparker/delve/proc/zsyscall_windows.go generated vendored
View File

22
vendor/github.com/derekparker/delve/service/api/conversions.go generated vendored
View File

@ -9,8 +9,7 @@ import (
"reflect"
"strconv"
"github.com/derekparker/delve/pkg/proc"
"github.com/derekparker/delve/proc"
"golang.org/x/debug/dwarf"
)
@ -99,19 +98,6 @@ func prettyTypeName(typ dwarf.Type) string {
return r
}
func convertFloatValue(v *proc.Variable, sz int) string {
switch v.FloatSpecial {
case proc.FloatIsPosInf:
return "+Inf"
case proc.FloatIsNegInf:
return "-Inf"
case proc.FloatIsNaN:
return "NaN"
}
f, _ := constant.Float64Val(v.Value)
return strconv.FormatFloat(f, 'f', -1, sz)
}
// ConvertVar converts from proc.Variable to api.Variable.
func ConvertVar(v *proc.Variable) *Variable {
r := Variable{
@ -133,9 +119,11 @@ func ConvertVar(v *proc.Variable) *Variable {
if v.Value != nil {
switch v.Kind {
case reflect.Float32:
r.Value = convertFloatValue(v, 32)
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 32)
case reflect.Float64:
r.Value = convertFloatValue(v, 64)
f, _ := constant.Float64Val(v.Value)
r.Value = strconv.FormatFloat(f, 'f', -1, 64)
case reflect.String, reflect.Func:
r.Value = constant.StringVal(v.Value)
default:

4
vendor/github.com/derekparker/delve/service/api/prettyprint.go generated vendored
View File

@ -87,9 +87,7 @@ func (v *Variable) writeTo(buf io.Writer, top, newlines, includeType bool, inden
}
data := v.Children[0]
if data.Kind == reflect.Ptr {
if len(data.Children) == 0 {
fmt.Fprintf(buf, "...")
} else if data.Children[0].Addr == 0 {
if data.Children[0].Addr == 0 {
fmt.Fprintf(buf, "nil")
} else if data.Children[0].OnlyAddr {
fmt.Fprintf(buf, "0x%x", v.Children[0].Addr)

2
vendor/github.com/derekparker/delve/service/api/types.go generated vendored
View File

@ -8,7 +8,7 @@ import (
"strconv"
"unicode"
"github.com/derekparker/delve/pkg/proc"
"github.com/derekparker/delve/proc"
)
var NotExecutableErr = proc.NotExecutableErr

132
vendor/github.com/derekparker/delve/service/debugger/debugger.go generated vendored
View File

@ -13,8 +13,7 @@ import (
"sync"
"time"
"github.com/derekparker/delve/pkg/proc"
"github.com/derekparker/delve/pkg/target"
"github.com/derekparker/delve/proc"
"github.com/derekparker/delve/service/api"
)
@ -27,10 +26,9 @@ import (
// 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
config *Config
processMutex sync.Mutex
target target.Interface
process *proc.Process
}
// Config provides the configuration to start a Debugger.
@ -63,7 +61,7 @@ func New(config *Config) (*Debugger, error) {
if err != nil {
return nil, attachErrorMessage(d.config.AttachPid, err)
}
d.target = p
d.process = p
} else {
log.Printf("launching process with args: %v", d.config.ProcessArgs)
p, err := proc.Launch(d.config.ProcessArgs, d.config.WorkingDir)
@ -73,7 +71,7 @@ func New(config *Config) (*Debugger, error) {
}
return nil, err
}
d.target = p
d.process = p
}
return d, nil
}
@ -81,13 +79,13 @@ func New(config *Config) (*Debugger, error) {
// ProcessPid returns the PID of the process
// the debugger is debugging.
func (d *Debugger) ProcessPid() int {
return d.target.Pid()
return d.process.Pid
}
// LastModified returns the time that the process' executable was last
// modified.
func (d *Debugger) LastModified() time.Time {
return d.target.LastModified()
return d.process.LastModified
}
// Detach detaches from the target process.
@ -102,9 +100,9 @@ func (d *Debugger) Detach(kill bool) error {
func (d *Debugger) detach(kill bool) error {
if d.config.AttachPid != 0 {
return d.target.Detach(kill)
return d.process.Detach(kill)
}
return d.target.Kill()
return d.process.Kill()
}
// Restart will restart the target process, first killing
@ -113,9 +111,9 @@ 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()
if !d.process.Exited() {
if d.process.Running() {
d.process.Halt()
}
// Ensure the process is in a PTRACE_STOP.
if err := stopProcess(d.ProcessPid()); err != nil {
@ -149,7 +147,7 @@ func (d *Debugger) Restart() ([]api.DiscardedBreakpoint, error) {
return nil, err
}
}
d.target = p
d.process = p
return discarded, nil
}
@ -161,7 +159,7 @@ func (d *Debugger) State() (*api.DebuggerState, error) {
}
func (d *Debugger) state() (*api.DebuggerState, error) {
if d.target.Exited() {
if d.process.Exited() {
return nil, proc.ProcessExitedError{Pid: d.ProcessPid()}
}
@ -170,24 +168,24 @@ func (d *Debugger) state() (*api.DebuggerState, error) {
goroutine *api.Goroutine
)
if d.target.SelectedGoroutine() != nil {
goroutine = api.ConvertGoroutine(d.target.SelectedGoroutine())
if d.process.SelectedGoroutine != nil {
goroutine = api.ConvertGoroutine(d.process.SelectedGoroutine)
}
state = &api.DebuggerState{
SelectedGoroutine: goroutine,
Exited: d.target.Exited(),
Exited: d.process.Exited(),
}
for i := range d.target.Threads() {
th := api.ConvertThread(d.target.Threads()[i])
for i := range d.process.Threads {
th := api.ConvertThread(d.process.Threads[i])
state.Threads = append(state.Threads, th)
if i == d.target.CurrentThread().ID {
if i == d.process.CurrentThread.ID {
state.CurrentThread = th
}
}
for _, bp := range d.target.Breakpoints() {
for _, bp := range d.process.Breakpoints {
if bp.Internal() {
state.NextInProgress = true
break
@ -223,19 +221,19 @@ func (d *Debugger) CreateBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoin
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() {
for symFile := range d.process.Sources() {
if fileNameNormalized == strings.ToLower(filepath.ToSlash(symFile)) {
fileName = symFile
break
}
}
}
addr, err = d.target.FindFileLocation(fileName, requestedBp.Line)
addr, err = d.process.FindFileLocation(fileName, requestedBp.Line)
case len(requestedBp.FunctionName) > 0:
if requestedBp.Line >= 0 {
addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, false, requestedBp.Line)
addr, err = d.process.FindFunctionLocation(requestedBp.FunctionName, false, requestedBp.Line)
} else {
addr, err = d.target.FindFunctionLocation(requestedBp.FunctionName, true, 0)
addr, err = d.process.FindFunctionLocation(requestedBp.FunctionName, true, 0)
}
default:
addr = requestedBp.Addr
@ -245,12 +243,12 @@ func (d *Debugger) CreateBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoin
return nil, err
}
bp, err := d.target.SetBreakpoint(addr, proc.UserBreakpoint, nil)
bp, err := d.process.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 {
if _, err1 := d.process.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
@ -275,7 +273,7 @@ func (d *Debugger) AmendBreakpoint(amend *api.Breakpoint) error {
}
func (d *Debugger) CancelNext() error {
return d.target.ClearInternalBreakpoints()
return d.process.ClearInternalBreakpoints()
}
func copyBreakpointInfo(bp *proc.Breakpoint, requested *api.Breakpoint) (err error) {
@ -299,7 +297,7 @@ func (d *Debugger) ClearBreakpoint(requestedBp *api.Breakpoint) (*api.Breakpoint
defer d.processMutex.Unlock()
var clearedBp *api.Breakpoint
bp, err := d.target.ClearBreakpoint(requestedBp.Addr)
bp, err := d.process.ClearBreakpoint(requestedBp.Addr)
if err != nil {
return nil, fmt.Errorf("Can't clear breakpoint @%x: %s", requestedBp.Addr, err)
}
@ -317,7 +315,7 @@ func (d *Debugger) Breakpoints() []*api.Breakpoint {
func (d *Debugger) breakpoints() []*api.Breakpoint {
bps := []*api.Breakpoint{}
for _, bp := range d.target.Breakpoints() {
for _, bp := range d.process.Breakpoints {
if bp.Internal() {
continue
}
@ -339,7 +337,7 @@ func (d *Debugger) FindBreakpoint(id int) *api.Breakpoint {
}
func (d *Debugger) findBreakpoint(id int) *proc.Breakpoint {
for _, bp := range d.target.Breakpoints() {
for _, bp := range d.process.Breakpoints {
if bp.ID == id {
return bp
}
@ -368,11 +366,11 @@ func (d *Debugger) Threads() ([]*api.Thread, error) {
d.processMutex.Lock()
defer d.processMutex.Unlock()
if d.target.Exited() {
if d.process.Exited() {
return nil, &proc.ProcessExitedError{}
}
threads := []*api.Thread{}
for _, th := range d.target.Threads() {
for _, th := range d.process.Threads {
threads = append(threads, api.ConvertThread(th))
}
return threads, nil
@ -383,11 +381,11 @@ func (d *Debugger) FindThread(id int) (*api.Thread, error) {
d.processMutex.Lock()
defer d.processMutex.Unlock()
if d.target.Exited() {
if d.process.Exited() {
return nil, &proc.ProcessExitedError{}
}
for _, th := range d.target.Threads() {
for _, th := range d.process.Threads {
if th.ID == id {
return api.ConvertThread(th), nil
}
@ -403,7 +401,7 @@ func (d *Debugger) Command(command *api.DebuggerCommand) (*api.DebuggerState, er
// RequestManualStop does not invoke any ptrace syscalls, so it's safe to
// access the process directly.
log.Print("halting")
err = d.target.RequestManualStop()
err = d.process.RequestManualStop()
}
d.processMutex.Lock()
@ -412,7 +410,7 @@ func (d *Debugger) Command(command *api.DebuggerCommand) (*api.DebuggerState, er
switch command.Name {
case api.Continue:
log.Print("continuing")
err = d.target.Continue()
err = d.process.Continue()
if err != nil {
if exitedErr, exited := err.(proc.ProcessExitedError); exited {
state := &api.DebuggerState{}
@ -432,22 +430,22 @@ func (d *Debugger) Command(command *api.DebuggerCommand) (*api.DebuggerState, er
case api.Next:
log.Print("nexting")
err = d.target.Next()
err = d.process.Next()
case api.Step:
log.Print("stepping")
err = d.target.Step()
err = d.process.Step()
case api.StepInstruction:
log.Print("single stepping")
err = d.target.StepInstruction()
err = d.process.StepInstruction()
case api.StepOut:
log.Print("step out")
err = d.target.StepOut()
err = d.process.StepOut()
case api.SwitchThread:
log.Printf("switching to thread %d", command.ThreadID)
err = d.target.SwitchThread(command.ThreadID)
err = d.process.SwitchThread(command.ThreadID)
case api.SwitchGoroutine:
log.Printf("switching to goroutine %d", command.GoroutineID)
err = d.target.SwitchGoroutine(command.GoroutineID)
err = d.process.SwitchGoroutine(command.GoroutineID)
case api.Halt:
// RequestManualStop already called
}
@ -472,7 +470,7 @@ func (d *Debugger) collectBreakpointInformation(state *api.DebuggerState) error
state.Threads[i].BreakpointInfo = bpi
if bp.Goroutine {
g, err := d.target.CurrentThread().GetG()
g, err := d.process.CurrentThread.GetG()
if err != nil {
return err
}
@ -480,7 +478,7 @@ func (d *Debugger) collectBreakpointInformation(state *api.DebuggerState) error
}
if bp.Stacktrace > 0 {
rawlocs, err := d.target.CurrentThread().Stacktrace(bp.Stacktrace)
rawlocs, err := d.process.CurrentThread.Stacktrace(bp.Stacktrace)
if err != nil {
return err
}
@ -490,7 +488,7 @@ func (d *Debugger) collectBreakpointInformation(state *api.DebuggerState) error
}
}
s, err := d.target.Threads()[state.Threads[i].ID].Scope()
s, err := d.process.Threads[state.Threads[i].ID].Scope()
if err != nil {
return err
}
@ -531,7 +529,7 @@ func (d *Debugger) Sources(filter string) ([]string, error) {
}
files := []string{}
for f := range d.target.Sources() {
for f := range d.process.Sources() {
if regex.Match([]byte(f)) {
files = append(files, f)
}
@ -544,7 +542,7 @@ func (d *Debugger) Functions(filter string) ([]string, error) {
d.processMutex.Lock()
defer d.processMutex.Unlock()
return regexFilterFuncs(filter, d.target.Funcs())
return regexFilterFuncs(filter, d.process.Funcs())
}
func (d *Debugger) Types(filter string) ([]string, error) {
@ -556,7 +554,7 @@ func (d *Debugger) Types(filter string) ([]string, error) {
return nil, fmt.Errorf("invalid filter argument: %s", err.Error())
}
types, err := d.target.Types()
types, err := d.process.Types()
if err != nil {
return nil, err
}
@ -598,7 +596,7 @@ func (d *Debugger) PackageVariables(threadID int, filter string, cfg proc.LoadCo
}
vars := []api.Variable{}
thread, found := d.target.Threads()[threadID]
thread, found := d.process.Threads[threadID]
if !found {
return nil, fmt.Errorf("couldn't find thread %d", threadID)
}
@ -623,7 +621,7 @@ func (d *Debugger) Registers(threadID int, floatingPoint bool) (api.Registers, e
d.processMutex.Lock()
defer d.processMutex.Unlock()
thread, found := d.target.Threads()[threadID]
thread, found := d.process.Threads[threadID]
if !found {
return nil, fmt.Errorf("couldn't find thread %d", threadID)
}
@ -647,7 +645,7 @@ func (d *Debugger) LocalVariables(scope api.EvalScope, cfg proc.LoadConfig) ([]a
d.processMutex.Lock()
defer d.processMutex.Unlock()
s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
s, err := d.process.ConvertEvalScope(scope.GoroutineID, scope.Frame)
if err != nil {
return nil, err
}
@ -663,7 +661,7 @@ func (d *Debugger) FunctionArguments(scope api.EvalScope, cfg proc.LoadConfig) (
d.processMutex.Lock()
defer d.processMutex.Unlock()
s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
s, err := d.process.ConvertEvalScope(scope.GoroutineID, scope.Frame)
if err != nil {
return nil, err
}
@ -680,7 +678,7 @@ func (d *Debugger) EvalVariableInScope(scope api.EvalScope, symbol string, cfg p
d.processMutex.Lock()
defer d.processMutex.Unlock()
s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
s, err := d.process.ConvertEvalScope(scope.GoroutineID, scope.Frame)
if err != nil {
return nil, err
}
@ -697,7 +695,7 @@ func (d *Debugger) SetVariableInScope(scope api.EvalScope, symbol, value string)
d.processMutex.Lock()
defer d.processMutex.Unlock()
s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
s, err := d.process.ConvertEvalScope(scope.GoroutineID, scope.Frame)
if err != nil {
return err
}
@ -710,7 +708,7 @@ func (d *Debugger) Goroutines() ([]*api.Goroutine, error) {
defer d.processMutex.Unlock()
goroutines := []*api.Goroutine{}
gs, err := d.target.GoroutinesInfo()
gs, err := d.process.GoroutinesInfo()
if err != nil {
return nil, err
}
@ -729,13 +727,13 @@ func (d *Debugger) Stacktrace(goroutineID, depth int, cfg *proc.LoadConfig) ([]a
var rawlocs []proc.Stackframe
g, err := d.target.FindGoroutine(goroutineID)
g, err := d.process.FindGoroutine(goroutineID)
if err != nil {
return nil, err
}
if g == nil {
rawlocs, err = d.target.CurrentThread().Stacktrace(depth)
rawlocs, err = d.process.CurrentThread.Stacktrace(depth)
} else {
rawlocs, err = g.Stacktrace(depth)
}
@ -750,9 +748,9 @@ func (d *Debugger) convertStacktrace(rawlocs []proc.Stackframe, cfg *proc.LoadCo
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 {
if cfg != nil {
var err error
scope := rawlocs[i].Scope(d.target.CurrentThread())
scope := rawlocs[i].Scope(d.process.CurrentThread)
locals, err := scope.LocalVariables(*cfg)
if err != nil {
return nil, err
@ -781,11 +779,11 @@ func (d *Debugger) FindLocation(scope api.EvalScope, locStr string) ([]api.Locat
return nil, err
}
s, _ := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame)
s, _ := d.process.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)
file, line, fn := d.process.PCToLine(locs[i].PC)
locs[i].File = file
locs[i].Line = line
locs[i].Function = api.ConvertFunction(fn)
@ -800,7 +798,7 @@ func (d *Debugger) Disassemble(scope api.EvalScope, startPC, endPC uint64, flavo
defer d.processMutex.Unlock()
if endPC == 0 {
_, _, fn := d.target.PCToLine(startPC)
_, _, fn := d.process.PCToLine(startPC)
if fn == nil {
return nil, fmt.Errorf("Address 0x%x does not belong to any function", startPC)
}
@ -809,9 +807,9 @@ func (d *Debugger) Disassemble(scope api.EvalScope, startPC, endPC uint64, flavo
}
currentGoroutine := true
thread := d.target.CurrentThread()
thread := d.process.CurrentThread
if s, err := d.target.ConvertEvalScope(scope.GoroutineID, scope.Frame); err == nil {
if s, err := d.process.ConvertEvalScope(scope.GoroutineID, scope.Frame); err == nil {
thread = s.Thread
if scope.GoroutineID != -1 {
g, _ := s.Thread.GetG()

28
vendor/github.com/derekparker/delve/service/debugger/locations.go generated vendored
View File

@ -10,7 +10,7 @@ import (
"strconv"
"strings"
"github.com/derekparker/delve/pkg/proc"
"github.com/derekparker/delve/proc"
"github.com/derekparker/delve/service/api"
)
@ -243,14 +243,14 @@ func (spec *FuncLocationSpec) Match(sym *gosym.Sym) bool {
}
func (loc *RegexLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string) ([]api.Location, error) {
funcs := d.target.Funcs()
funcs := d.process.Funcs()
matches, err := regexFilterFuncs(loc.FuncRegex, funcs)
if err != nil {
return nil, err
}
r := make([]api.Location, 0, len(matches))
for i := range matches {
addr, err := d.target.FindFunctionLocation(matches[i], true, 0)
addr, err := d.process.FindFunctionLocation(matches[i], true, 0)
if err == nil {
r = append(r, api.Location{PC: addr})
}
@ -278,8 +278,8 @@ func (loc *AddrLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr str
addr, _ := constant.Uint64Val(v.Value)
return []api.Location{{PC: addr}}, nil
case reflect.Func:
_, _, fn := d.target.PCToLine(uint64(v.Base))
pc, err := d.target.FirstPCAfterPrologue(fn, false)
_, _, fn := d.process.PCToLine(uint64(v.Base))
pc, err := d.process.FirstPCAfterPrologue(fn, false)
if err != nil {
return nil, err
}
@ -327,8 +327,8 @@ func (ale AmbiguousLocationError) Error() string {
}
func (loc *NormalLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr string) ([]api.Location, error) {
funcs := d.target.Funcs()
files := d.target.Sources()
funcs := d.process.Funcs()
files := d.process.Sources()
candidates := []string{}
for file := range files {
@ -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 = d.process.FindFileLocation(candidates[0], loc.LineOffset)
} else {
if loc.LineOffset < 0 {
addr, err = d.target.FindFunctionLocation(candidates[0], true, 0)
addr, err = d.process.FindFunctionLocation(candidates[0], true, 0)
} else {
addr, err = d.target.FindFunctionLocation(candidates[0], false, loc.LineOffset)
addr, err = d.process.FindFunctionLocation(candidates[0], false, loc.LineOffset)
}
}
if err != nil {
@ -390,11 +390,11 @@ func (loc *OffsetLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr s
if scope == nil {
return nil, fmt.Errorf("could not determine current location (scope is nil)")
}
file, line, fn := d.target.PCToLine(scope.PC)
file, line, fn := d.process.PCToLine(scope.PC)
if fn == nil {
return nil, fmt.Errorf("could not determine current location")
}
addr, err := d.target.FindFileLocation(file, line+loc.Offset)
addr, err := d.process.FindFileLocation(file, line+loc.Offset)
return []api.Location{{PC: addr}}, err
}
@ -402,10 +402,10 @@ func (loc *LineLocationSpec) Find(d *Debugger, scope *proc.EvalScope, locStr str
if scope == nil {
return nil, fmt.Errorf("could not determine current location (scope is nil)")
}
file, _, fn := d.target.PCToLine(scope.PC)
file, _, fn := d.process.PCToLine(scope.PC)
if fn == nil {
return nil, fmt.Errorf("could not determine current location")
}
addr, err := d.target.FindFileLocation(file, loc.Line)
addr, err := d.process.FindFileLocation(file, loc.Line)
return []api.Location{{PC: addr}}, err
}

2
vendor/github.com/derekparker/delve/service/rpc1/server.go generated vendored
View File

@ -4,7 +4,7 @@ import (
"errors"
"fmt"
"github.com/derekparker/delve/pkg/proc"
"github.com/derekparker/delve/proc"
"github.com/derekparker/delve/service"
"github.com/derekparker/delve/service/api"
"github.com/derekparker/delve/service/debugger"

4
vendor/github.com/derekparker/delve/service/rpccommon/server.go generated vendored
View File

@ -16,12 +16,12 @@ import (
"unicode"
"unicode/utf8"
"github.com/derekparker/delve/pkg/version"
"github.com/derekparker/delve/service"
"github.com/derekparker/delve/service/api"
"github.com/derekparker/delve/service/debugger"
"github.com/derekparker/delve/service/rpc1"
"github.com/derekparker/delve/service/rpc2"
"github.com/derekparker/delve/version"
)
// ServerImpl implements a JSON-RPC server that can switch between two
@ -403,7 +403,7 @@ func (err *internalError) Error() string {
var out bytes.Buffer
fmt.Fprintf(&out, "Internal debugger error: %v\n", err.Err)
for _, frame := range err.Stack {
fmt.Fprintf(&out, "%s (%#x)\n\t%s:%d\n", frame.Func, frame.Pc, frame.File, frame.Line)
fmt.Fprintf(&out, "%s (%#x)\n\t%s%d\n", frame.Func, frame.Pc, frame.File, frame.Line)
}
return out.String()
}

0
vendor/github.com/derekparker/delve/pkg/terminal/command.go → vendor/github.com/derekparker/delve/terminal/command.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/terminal/disasmprint.go → vendor/github.com/derekparker/delve/terminal/disasmprint.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/terminal/docgen.go → vendor/github.com/derekparker/delve/terminal/docgen.go generated vendored
View File

2
vendor/github.com/derekparker/delve/pkg/terminal/terminal.go → vendor/github.com/derekparker/delve/terminal/terminal.go generated vendored
View File

@ -12,7 +12,7 @@ import (
"github.com/peterh/liner"
"github.com/derekparker/delve/pkg/config"
"github.com/derekparker/delve/config"
"github.com/derekparker/delve/service"
)

0
vendor/github.com/derekparker/delve/pkg/terminal/terminal_other.go → vendor/github.com/derekparker/delve/terminal/terminal_other.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/terminal/terminal_windows.go → vendor/github.com/derekparker/delve/terminal/terminal_windows.go generated vendored
View File

0
vendor/github.com/derekparker/delve/pkg/version/version.go → vendor/github.com/derekparker/delve/version/version.go generated vendored
View File

118
vendor/vendor.json vendored
View File

@ -15,100 +15,94 @@
"revisionTime": "2017-03-06T13:59:04Z"
},
{
"checksumSHA1": "Ay6dg3VVgggBHMsytbc+U4Wutyc=",
"path": "github.com/derekparker/delve/pkg/config",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "7o4Bn5wmWhqiC6QERVE+eFuMVxE=",
"path": "github.com/derekparker/delve/config",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "i4N90QPS76SMH2GjkJKjuS+z4xI=",
"path": "github.com/derekparker/delve/pkg/dwarf/frame",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "z9dNXc4EocXzA7shhyD9ICYzqMU=",
"path": "github.com/derekparker/delve/dwarf/frame",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "3pNKXngpbU4tnDOZc1ez6ywk7GA=",
"path": "github.com/derekparker/delve/pkg/dwarf/line",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "1fsK0IHP5Gdnj2jdJqWGb+IiSbg=",
"path": "github.com/derekparker/delve/dwarf/line",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "mOPdy13ztM3W5WMt3vVUq00AXfg=",
"path": "github.com/derekparker/delve/pkg/dwarf/op",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "qGcXmO+L1RuCsl1rNxvBfHFF7xQ=",
"path": "github.com/derekparker/delve/dwarf/op",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "hqg+xjH/qCO0CQokj5L1qD5lBmE=",
"path": "github.com/derekparker/delve/pkg/dwarf/reader",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "B4ANlFg/tsjxgw6VGKvymnqmFSs=",
"path": "github.com/derekparker/delve/dwarf/reader",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "QkHSoN99PlCYaEgChgPaEBmUWbk=",
"path": "github.com/derekparker/delve/pkg/dwarf/util",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "sfJBUZjAjg9jlWnYvxxpXSteEfw=",
"path": "github.com/derekparker/delve/dwarf/util",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "KH9MVb6MX5iPgRjySRZHQa324Sw=",
"path": "github.com/derekparker/delve/pkg/proc",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
},
{
"checksumSHA1": "9dbHlIWbcf3jXVu6zRjZvJnDq4c=",
"path": "github.com/derekparker/delve/pkg/target",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
},
{
"checksumSHA1": "nqWjcE4SeTBNSuYlh6MJ8akB0cM=",
"path": "github.com/derekparker/delve/pkg/terminal",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
},
{
"checksumSHA1": "xRa64kuzCXVktmGscs1vCz9jIHs=",
"path": "github.com/derekparker/delve/pkg/version",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"checksumSHA1": "EV76KO6c8eV4x6qu7feUxpBbIyQ=",
"path": "github.com/derekparker/delve/proc",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "BPHre0My8iszpkoNcX4ljtrz1dA=",
"path": "github.com/derekparker/delve/service",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "xMPjvGhTumLbAUApyLI/7UnC7sQ=",
"checksumSHA1": "EaIRvHNXgLb3yU/nwEkM48sA4Xc=",
"path": "github.com/derekparker/delve/service/api",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "/EXcw7FytgML9fdbMV0pxDBJJE0=",
"checksumSHA1": "zi0XsumHd/tKG0fIMNQsmZHSkM8=",
"path": "github.com/derekparker/delve/service/debugger",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "d73mTsiCuYYpDaVs9QtozhzMDU0=",
"checksumSHA1": "MVw0jbqnWHLX41UsSftGP7BZ6xU=",
"path": "github.com/derekparker/delve/service/rpc1",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "B+J0KRNuX0anRlif3mWXhBQhnVo=",
"path": "github.com/derekparker/delve/service/rpc2",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "PsNfnfv8GS79AG225Q/h57q/6F4=",
"checksumSHA1": "qCMUUT6PtR1jsrZcqkDkQHycBXM=",
"path": "github.com/derekparker/delve/service/rpccommon",
"revision": "ab7367ed2bf15044f7bca97147a802f77b875797",
"revisionTime": "2017-03-13T17:59:34Z"
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "KUK2wagVoGOYEIy2vpH7up+DpXA=",
"path": "github.com/derekparker/delve/terminal",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "013Reixyv4BwEJF/J8vHeaSTtSI=",
"path": "github.com/derekparker/delve/version",
"revision": "449b276fe1ce7e20a0c7ffffbdd47d97f40022a1",
"revisionTime": "2017-01-11T19:37:04Z"
},
{
"checksumSHA1": "hveFTNQ9YEyYRs6SWuXM+XU9qRI=",