BROKEN BROKEN BROKEN DO NOT MERGE TESTING ONLY

disable a bunch of necessary stuff to benchmark conditional breakpoints

also ugly hack to run all of proc.Continue code inside the ptrace thread

golang/go#21827

pkg/proc/core/core.go

@@ -449,3 +449,7 @@ func (p *Process) FindThread(threadID int) (proc.Thread, bool) {
 func (p *Process) InternalSetCurrentThread(th proc.Thread) {
 	p.currentThread = th.(*Thread)
 }
+
+func (p *Process) MagicThreadExec(fn func()) {
+	fn()
+}

pkg/proc/gdbserial/gdbserver.go

@@ -604,6 +604,10 @@ func (p *Process) InternalSetCurrentThread(th proc.Thread) {
 	p.currentThread = th.(*Thread)
 }
 
+func (p *Process) MagicThreadExec(fn func()) {
+	fn()
+}
+
 const (
 	interruptSignal  = 0x2
 	breakpointSignal = 0x5

pkg/proc/interface.go

@@ -16,6 +16,7 @@ type Process interface {
 	ProcessManipulation
 	BreakpointManipulation
 	RecordingManipulation
+	MagicThreadExec(func())
 }
 
 // RecordingManipulation is an interface for manipulating process recordings.

pkg/proc/native/proc.go

@@ -31,6 +31,7 @@ type Process struct {
 	resumeChan          chan<- struct{}
 	ptraceChan          chan func()
 	ptraceDoneChan      chan interface{}
+	insidePtrace        bool
 	childProcess        bool // this process was launched, not attached to
 	manualStopRequested bool
 
@@ -309,12 +310,20 @@ func (dbp *Process) handlePtraceFuncs() {
 	runtime.LockOSThread()
 
 	for fn := range dbp.ptraceChan {
+		dbp.insidePtrace = true
 		fn()
-		dbp.ptraceDoneChan <- nil
+		dbp.insidePtrace = false
+		if !dbp.exited {
+			dbp.ptraceDoneChan <- nil
+		}
 	}
 }
 
 func (dbp *Process) execPtraceFunc(fn func()) {
+	if dbp.insidePtrace {
+		fn()
+		return
+	}
 	dbp.ptraceChan <- fn
 	<-dbp.ptraceDoneChan
 }
@@ -330,3 +339,7 @@ func (dbp *Process) writeSoftwareBreakpoint(thread *Thread, addr uint64) error {
 	_, err := thread.WriteMemory(uintptr(addr), dbp.bi.Arch.BreakpointInstruction())
 	return err
 }
+
+func (dbp *Process) MagicThreadExec(fn func()) {
+	dbp.execPtraceFunc(fn)
+}

pkg/proc/native/registers_linux_amd64.go

@@ -56,6 +56,7 @@ func registers(thread *Thread, floatingPoint bool) (proc.Registers, error) {
 		return nil, err
 	}
 	r := &linutil.AMD64Registers{&regs, nil, nil}
+	floatingPoint = false
 	if floatingPoint {
 		var fpregset linutil.AMD64Xstate
 		r.Fpregs, fpregset, err = thread.fpRegisters()

pkg/proc/proc.go

@@ -135,6 +135,14 @@ func Next(dbp *Target) (err error) {
 // process. It will continue until it hits a breakpoint
 // or is otherwise stopped.
 func Continue(dbp *Target) error {
+	var err error
+	dbp.MagicThreadExec(func() {
+		err = continueInternal(dbp)
+	})
+	return err
+}
+
+func continueInternal(dbp *Target) error {
 	if _, err := dbp.Valid(); err != nil {
 		return err
 	}
@@ -303,6 +311,11 @@ func pickCurrentThread(dbp *Target, trapthread Thread, threads []Thread) error {
 			return dbp.SwitchThread(th.ThreadID())
 		}
 	}
+	if bp := trapthread.Breakpoint(); bp.Breakpoint != nil && !bp.Active {
+		dbp.InternalSetCurrentThread(trapthread)
+		dbp.selectedGoroutine = nil
+		return nil
+	}
 	return dbp.SwitchThread(trapthread.ThreadID())
 }
 
@@ -716,7 +729,7 @@ func FrameToScope(bi *BinaryInfo, thread MemoryReadWriter, g *G, frames ...Stack
 	// Creates a cacheMem that will preload the entire stack frame the first
 	// time any local variable is read.
 	// Remember that the stack grows downward in memory.
-	minaddr := frames[0].Regs.SP()
+	/*minaddr := frames[0].Regs.SP()
 	var maxaddr uint64
 	if len(frames) > 1 && frames[0].SystemStack == frames[1].SystemStack {
 		maxaddr = uint64(frames[1].Regs.CFA)
@@ -725,7 +738,7 @@ func FrameToScope(bi *BinaryInfo, thread MemoryReadWriter, g *G, frames ...Stack
 	}
 	if maxaddr > minaddr && maxaddr-minaddr < maxFramePrefetchSize {
 		thread = cacheMemory(thread, uintptr(minaddr), int(maxaddr-minaddr))
-	}
+	}*/
 
 	s := &EvalScope{Location: frames[0].Call, Regs: frames[0].Regs, Mem: thread, g: g, BinInfo: bi, frameOffset: frames[0].FrameOffset()}
 	s.PC = frames[0].lastpc

pkg/proc/stack.go

@@ -93,7 +93,8 @@ func (frame *Stackframe) FramePointerOffset() int64 {
 // ThreadStacktrace returns the stack trace for thread.
 // Note the locations in the array are return addresses not call addresses.
 func ThreadStacktrace(thread Thread, depth int) ([]Stackframe, error) {
-	g, _ := GetG(thread)
+	//g, _ := GetG(thread)
+	var g *G = nil
 	if g == nil {
 		regs, err := thread.Registers(true)
 		if err != nil {

pkg/proc/threads.go

@@ -530,18 +530,18 @@ func ThreadScope(thread Thread) (*EvalScope, error) {
 
 // GoroutineScope returns an EvalScope for the goroutine running on this thread.
 func GoroutineScope(thread Thread) (*EvalScope, error) {
-	locations, err := ThreadStacktrace(thread, 1)
+	locations, err := ThreadStacktrace(thread, 0)
 	if err != nil {
 		return nil, err
 	}
 	if len(locations) < 1 {
 		return nil, errors.New("could not decode first frame")
 	}
-	g, err := GetG(thread)
+	/*g, err := GetG(thread)
 	if err != nil {
 		return nil, err
-	}
-	return FrameToScope(thread.BinInfo(), thread, g, locations...), nil
+	}*/
+	return FrameToScope(thread.BinInfo(), thread, nil, locations...), nil
 }
 
 // onNextGoroutine returns true if this thread is on the goroutine requested by the current 'next' command