(Mostly) working on OS X

_fixtures/testprog.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+	"runtime"
 	"time"
 )
 
@@ -19,3 +20,7 @@ func main() {
 		helloworld()
 	}
 }
+
+func init() {
+	runtime.LockOSThread()
+}

dwarf/frame/entries.go

 package frame
 
-import "fmt"
+import (
+	"fmt"
+	"sort"
+)
 
 // Represents a Common Information Entry in
 // the Dwarf .debug_frame section.
@@ -55,29 +58,22 @@ func NewFrameIndex() FrameDescriptionEntries {
 }
 
 func (fdes FrameDescriptionEntries) FDEForPC(pc uint64) (*FrameDescriptionEntry, error) {
-	frame := find(fdes, pc)
-	if frame == nil {
-		return nil, fmt.Errorf("could not find FDE for %#v", pc)
-	}
-	return frame, nil
-}
+	fmt.Println("fdes for pc")
+	idx := sort.Search(len(fdes), func(i int) bool {
+		if fdes[i].Cover(pc) {
+			return true
+		}
+		if fdes[i].More(pc) {
+			return false
+		}
+		return true
 
-func find(fdes FrameDescriptionEntries, pc uint64) *FrameDescriptionEntry {
-	if len(fdes) == 0 {
-		return nil
-	}
-	idx := len(fdes) / 2
-	frame := fdes[idx]
-	if frame.Cover(pc) {
-		return frame
-	}
-	if frame.Less(pc) {
-		return find(fdes[:idx], pc)
-	}
-	if frame.More(pc) {
-		return find(fdes[idx:], pc)
+	})
+	if idx == len(fdes) {
+		return nil, fmt.Errorf("could not find FDE for PC %#v", pc)
 	}
-	return nil
+	fmt.Println("fin")
+	return fdes[idx], nil
 }
 
 func (frame *FrameDescriptionEntry) Less(pc uint64) bool {

dwarf/frame/entries_test.go

@@ -20,7 +20,7 @@ func TestFDEForPC(t *testing.T) {
 
 	node, err := frames.FDEForPC(35)
 	if err != nil {
-		t.Fatal("Could not find FDE")
+		t.Fatal(err)
 	}
 
 	if node != fde1 {

proctl/breakpoints.go

+package proctl
+
+import (
+	"fmt"
+	"runtime"
+)
+
+// Represents a single breakpoint. Stores information on the break
+// point including the byte of data that originally was stored at that
+// address.
+type BreakPoint struct {
+	FunctionName string
+	File         string
+	Line         int
+	Addr         uint64
+	OriginalData []byte
+	ID           int
+	temp         bool
+}
+
+// Returned when trying to set a breakpoint at
+// an address that already has a breakpoint set for it.
+type BreakPointExistsError struct {
+	file string
+	line int
+	addr uint64
+}
+
+func (bpe BreakPointExistsError) Error() string {
+	return fmt.Sprintf("Breakpoint exists at %s:%d at %x", bpe.file, bpe.line, bpe.addr)
+}
+
+// InvalidAddressError represents the result of
+// attempting to set a breakpoint at an invalid address.
+type InvalidAddressError struct {
+	address uint64
+}
+
+func (iae InvalidAddressError) Error() string {
+	return fmt.Sprintf("Invalid address %#v\n", iae.address)
+}
+
+// Returns whether or not a breakpoint has been set for the given address.
+func (dbp *DebuggedProcess) BreakpointExists(addr uint64) bool {
+	for _, bp := range dbp.HWBreakPoints {
+		// TODO(darwin)
+		if runtime.GOOS == "darwin" {
+			break
+		}
+		if bp != nil && bp.Addr == addr {
+			return true
+		}
+	}
+	if _, ok := dbp.BreakPoints[addr]; ok {
+		return true
+	}
+	return false
+}
+
+func (dbp *DebuggedProcess) newBreakpoint(fn, f string, l int, addr uint64, data []byte) *BreakPoint {
+	dbp.breakpointIDCounter++
+	return &BreakPoint{
+		FunctionName: fn,
+		File:         f,
+		Line:         l,
+		Addr:         addr,
+		OriginalData: data,
+		ID:           dbp.breakpointIDCounter,
+	}
+}
+
+func (dbp *DebuggedProcess) setBreakpoint(tid int, addr uint64) (*BreakPoint, error) {
+	var f, l, fn = dbp.GoSymTable.PCToLine(uint64(addr))
+	if fn == nil {
+		return nil, InvalidAddressError{address: addr}
+	}
+	if dbp.BreakpointExists(addr) {
+		return nil, BreakPointExistsError{f, l, addr}
+	}
+	// Try and set a hardware breakpoint.
+	for i, v := range dbp.HWBreakPoints {
+		// TODO(darwin)
+		if runtime.GOOS == "darwin" {
+			break
+		}
+		if v == nil {
+			if err := setHardwareBreakpoint(i, tid, addr); err != nil {
+				return nil, fmt.Errorf("could not set hardware breakpoint: %v", err)
+			}
+			dbp.HWBreakPoints[i] = dbp.newBreakpoint(fn.Name, f, l, addr, nil)
+			return dbp.HWBreakPoints[i], nil
+		}
+	}
+	// Fall back to software breakpoint. 0xCC is INT 3, software
+	// breakpoint trap interrupt.
+	thread := dbp.Threads[tid]
+	originalData := make([]byte, 1)
+	if _, err := readMemory(thread, uintptr(addr), originalData); err != nil {
+		return nil, err
+	}
+	if _, err := writeMemory(thread, uintptr(addr), []byte{0xCC}); err != nil {
+		return nil, err
+	}
+	dbp.BreakPoints[addr] = dbp.newBreakpoint(fn.Name, f, l, addr, originalData)
+	return dbp.BreakPoints[addr], nil
+}
+
+func (dbp *DebuggedProcess) clearBreakpoint(tid int, addr uint64) (*BreakPoint, error) {
+	// Check for hardware breakpoint
+	for i, bp := range dbp.HWBreakPoints {
+		if bp == nil {
+			continue
+		}
+		if bp.Addr == addr {
+			dbp.HWBreakPoints[i] = nil
+			if err := clearHardwareBreakpoint(i, tid); err != nil {
+				return nil, err
+			}
+			return bp, nil
+		}
+	}
+	// Check for software breakpoint
+	if bp, ok := dbp.BreakPoints[addr]; ok {
+		thread := dbp.Threads[tid]
+		if _, err := writeMemory(thread, uintptr(bp.Addr), bp.OriginalData); err != nil {
+			return nil, fmt.Errorf("could not clear breakpoint %s", err)
+		}
+		delete(dbp.BreakPoints, addr)
+		return bp, nil
+	}
+	return nil, fmt.Errorf("No breakpoint currently set for %#v", addr)
+}

proctl/breakpoints_darwin_amd64.go

+package proctl
+
+import "fmt"
+
+// TODO(darwin)
+func setHardwareBreakpoint(reg, tid int, addr uint64) error {
+	return fmt.Errorf("not implemented on darwin")
+}
+
+// TODO(darwin)
+func clearHardwareBreakpoint(reg, tid int) error {
+	return fmt.Errorf("not implemented on darwin")
+}

proctl/breakpoints_linux_amd64.go

@@ -15,147 +15,7 @@ int offset(int reg) {
 */
 import "C"
 
-import (
-	"fmt"
-	"syscall"
-	"unsafe"
-
-	sys "golang.org/x/sys/unix"
-)
-
-// Represents a single breakpoint. Stores information on the break
-// point including the byte of data that originally was stored at that
-// address.
-type BreakPoint struct {
-	FunctionName string
-	File         string
-	Line         int
-	Addr         uint64
-	OriginalData []byte
-	ID           int
-	temp         bool
-}
-
-// Returned when trying to set a breakpoint at
-// an address that already has a breakpoint set for it.
-type BreakPointExistsError struct {
-	file string
-	line int
-	addr uint64
-}
-
-func (bpe BreakPointExistsError) Error() string {
-	return fmt.Sprintf("Breakpoint exists at %s:%d at %x", bpe.file, bpe.line, bpe.addr)
-}
-
-// InvalidAddressError represents the result of
-// attempting to set a breakpoint at an invalid address.
-type InvalidAddressError struct {
-	address uint64
-}
-
-func (iae InvalidAddressError) Error() string {
-	return fmt.Sprintf("Invalid address %#v\n", iae.address)
-}
-
-func PtracePokeUser(tid int, off, addr uintptr) error {
-	_, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PTRACE_POKEUSR, uintptr(tid), uintptr(off), uintptr(addr), 0, 0)
-	if err != syscall.Errno(0) {
-		return err
-	}
-	return nil
-}
-
-func PtracePeekUser(tid int, off uintptr) (uintptr, error) {
-	var val uintptr
-	_, _, err := syscall.Syscall6(syscall.SYS_PTRACE, syscall.PTRACE_PEEKUSR, uintptr(tid), uintptr(off), uintptr(unsafe.Pointer(&val)), 0, 0)
-	if err != syscall.Errno(0) {
-		return 0, err
-	}
-	return val, nil
-}
-
-// Returns whether or not a breakpoint has been set for the given address.
-func (dbp *DebuggedProcess) BreakpointExists(addr uint64) bool {
-	for _, bp := range dbp.HWBreakPoints {
-		if bp != nil && bp.Addr == addr {
-			return true
-		}
-	}
-	if _, ok := dbp.BreakPoints[addr]; ok {
-		return true
-	}
-	return false
-}
-
-func (dbp *DebuggedProcess) setBreakpoint(tid int, addr uint64) (*BreakPoint, error) {
-	var f, l, fn = dbp.GoSymTable.PCToLine(uint64(addr))
-	if fn == nil {
-		return nil, InvalidAddressError{address: addr}
-	}
-	if dbp.BreakpointExists(addr) {
-		return nil, BreakPointExistsError{f, l, addr}
-	}
-	// Try and set a hardware breakpoint.
-	for i, v := range dbp.HWBreakPoints {
-		if v == nil {
-			if err := setHardwareBreakpoint(i, tid, addr); err != nil {
-				return nil, fmt.Errorf("could not set hardware breakpoint: %v", err)
-			}
-			dbp.HWBreakPoints[i] = dbp.newBreakpoint(fn.Name, f, l, addr, nil)
-			return dbp.HWBreakPoints[i], nil
-		}
-	}
-	// Fall back to software breakpoint. 0xCC is INT 3, software
-	// breakpoint trap interrupt.
-	originalData := make([]byte, 1)
-	if _, err := readMemory(tid, uintptr(addr), originalData); err != nil {
-		return nil, err
-	}
-	_, err := writeMemory(tid, uintptr(addr), []byte{0xCC})
-	if err != nil {
-		return nil, err
-	}
-	dbp.BreakPoints[addr] = dbp.newBreakpoint(fn.Name, f, l, addr, originalData)
-	return dbp.BreakPoints[addr], nil
-}
-
-func (dbp *DebuggedProcess) clearBreakpoint(tid int, addr uint64) (*BreakPoint, error) {
-	// Check for hardware breakpoint
-	for i, bp := range dbp.HWBreakPoints {
-		if bp == nil {
-			continue
-		}
-		if bp.Addr == addr {
-			dbp.HWBreakPoints[i] = nil
-			if err := clearHardwareBreakpoint(i, tid); err != nil {
-				return nil, err
-			}
-			return bp, nil
-		}
-	}
-	// Check for software breakpoint
-	if bp, ok := dbp.BreakPoints[addr]; ok {
-		if _, err := writeMemory(tid, uintptr(bp.Addr), bp.OriginalData); err != nil {
-			return nil, fmt.Errorf("could not clear breakpoint %s", err)
-		}
-		delete(dbp.BreakPoints, addr)
-		return bp, nil
-	}
-	return nil, fmt.Errorf("No breakpoint currently set for %#v", addr)
-}
-
-func (dbp *DebuggedProcess) newBreakpoint(fn, f string, l int, addr uint64, data []byte) *BreakPoint {
-	dbp.breakpointIDCounter++
-	return &BreakPoint{
-		FunctionName: fn,
-		File:         f,
-		Line:         l,
-		Addr:         addr,
-		OriginalData: data,
-		ID:           dbp.breakpointIDCounter,
-	}
-}
+import "fmt"
 
 // Sets a hardware breakpoint by setting the contents of the
 // debug register `reg` with the address of the instruction
@@ -208,3 +68,10 @@ func setHardwareBreakpoint(reg, tid int, addr uint64) error {
 	// an instruction stored in dr0-dr3.
 	return PtracePokeUser(tid, dr7off, dr7)
 }
+
+// Clears a hardware breakpoint. Essentially sets
+// the debug reg to 0 and clears the control register
+// flags for that reg.
+func clearHardwareBreakpoint(reg, tid int) error {
+	return setHardwareBreakpoint(reg, tid, 0)
+}

proctl/exc.defs

+/*
+ * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/* 
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+/*
+ * Abstract:
+ *	MiG definitions file for Mach exception interface.
+ */
+
+subsystem
+#if	KERNEL_USER
+	  KernelUser
+#endif
+		     exc 2401;
+
+#include <mach/std_types.defs>
+#include <mach/mach_types.defs>
+
+ServerPrefix catch_;
+
+type exception_data_t		= array[*:2] of integer_t;
+type exception_type_t		= int;
+
+routine		exception_raise(
+#if	KERNEL_USER
+			exception_port	: mach_port_move_send_t;
+			thread		: mach_port_move_send_t;
+			task		: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port	: mach_port_t;
+			thread		: mach_port_t;
+			task		: mach_port_t;
+#endif	/* KERNEL_USER */
+			exception	: exception_type_t;
+			code		: exception_data_t
+			);
+
+routine		exception_raise_state(
+#if	KERNEL_USER
+			exception_port	: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port	: mach_port_t;
+#endif	/* KERNEL_USER */
+			exception	: exception_type_t;
+			code		: exception_data_t, const;
+		  inout flavor		: int;
+			old_state	: thread_state_t, const;
+		    out new_state	: thread_state_t);
+
+routine		exception_raise_state_identity(
+#if	KERNEL_USER
+			exception_port  : mach_port_move_send_t;
+			thread		: mach_port_move_send_t;
+			task		: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port  : mach_port_t;
+			thread          : mach_port_t;
+			task            : mach_port_t;
+#endif	/* KERNEL_USER */
+			exception       : exception_type_t;
+			code            : exception_data_t;
+		  inout flavor          : int;
+			old_state       : thread_state_t;
+		    out new_state       : thread_state_t);
+
+/* vim: set ft=c : */

proctl/exc.h

+#ifndef	_exc_user_
+#define	_exc_user_
+
+/* Module exc */
+
+#include <string.h>
+#include <mach/ndr.h>
+#include <mach/boolean.h>
+#include <mach/kern_return.h>
+#include <mach/notify.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/mig_errors.h>
+#include <mach/port.h>
+	
+/* BEGIN VOUCHER CODE */
+
+#ifndef KERNEL
+#if defined(__has_include)
+#if __has_include(<mach/mig_voucher_support.h>)
+#ifndef USING_VOUCHERS
+#define USING_VOUCHERS
+#endif
+#ifndef __VOUCHER_FORWARD_TYPE_DECLS__
+#define __VOUCHER_FORWARD_TYPE_DECLS__
+#ifdef __cplusplus
+extern "C" {
+#endif
+	extern boolean_t voucher_mach_msg_set(mach_msg_header_t *msg) __attribute__((weak_import));
+#ifdef __cplusplus
+}
+#endif
+#endif // __VOUCHER_FORWARD_TYPE_DECLS__
+#endif // __has_include(<mach/mach_voucher_types.h>)
+#endif // __has_include
+#endif // !KERNEL
+	
+/* END VOUCHER CODE */
+
+
+#ifdef AUTOTEST
+#ifndef FUNCTION_PTR_T
+#define FUNCTION_PTR_T
+typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
+typedef struct {
+        char            *name;
+        function_ptr_t  function;
+} function_table_entry;
+typedef function_table_entry   *function_table_t;
+#endif /* FUNCTION_PTR_T */
+#endif /* AUTOTEST */
+
+#ifndef	exc_MSG_COUNT
+#define	exc_MSG_COUNT	3
+#endif	/* exc_MSG_COUNT */
+
+#include <mach/std_types.h>
+#include <mach/mig.h>
+#include <mach/mig.h>
+#include <mach/mach_types.h>
+
+#ifdef __BeforeMigUserHeader
+__BeforeMigUserHeader
+#endif /* __BeforeMigUserHeader */
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+
+/* Routine exception_raise */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	exception_data_t code,
+	mach_msg_type_number_t codeCnt
+);
+
+/* Routine exception_raise_state */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise_state
+(
+	mach_port_t exception_port,
+	exception_type_t exception,
+	const exception_data_t code,
+	mach_msg_type_number_t codeCnt,
+	int *flavor,
+	const thread_state_t old_state,
+	mach_msg_type_number_t old_stateCnt,
+	thread_state_t new_state,
+	mach_msg_type_number_t *new_stateCnt
+);
+
+/* Routine exception_raise_state_identity */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t exception_raise_state_identity
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	exception_data_t code,
+	mach_msg_type_number_t codeCnt,
+	int *flavor,
+	thread_state_t old_state,
+	mach_msg_type_number_t old_stateCnt,
+	thread_state_t new_state,
+	mach_msg_type_number_t *new_stateCnt
+);
+
+__END_DECLS
+
+/********************** Caution **************************/
+/* The following data types should be used to calculate  */
+/* maximum message sizes only. The actual message may be */
+/* smaller, and the position of the arguments within the */
+/* message layout may vary from what is presented here.  */
+/* For example, if any of the arguments are variable-    */
+/* sized, and less than the maximum is sent, the data    */
+/* will be packed tight in the actual message to reduce  */
+/* the presence of holes.                                */
+/********************** Caution **************************/
+
+/* typedefs for all requests */
+
+#ifndef __Request__exc_subsystem__defined
+#define __Request__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+	} __Request__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[224];
+	} __Request__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		integer_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[224];
+	} __Request__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Request__exc_subsystem__defined */
+
+/* union of all requests */
+
+#ifndef __RequestUnion__exc_subsystem__defined
+#define __RequestUnion__exc_subsystem__defined
+union __RequestUnion__exc_subsystem {
+	__Request__exception_raise_t Request_exception_raise;
+	__Request__exception_raise_state_t Request_exception_raise_state;
+	__Request__exception_raise_state_identity_t Request_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__exc_subsystem__defined */
+/* typedefs for all replies */
+
+#ifndef __Reply__exc_subsystem__defined
+#define __Reply__exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[224];
+	} __Reply__exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[224];
+	} __Reply__exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Reply__exc_subsystem__defined */
+
+/* union of all replies */
+
+#ifndef __ReplyUnion__exc_subsystem__defined
+#define __ReplyUnion__exc_subsystem__defined
+union __ReplyUnion__exc_subsystem {
+	__Reply__exception_raise_t Reply_exception_raise;
+	__Reply__exception_raise_state_t Reply_exception_raise_state;
+	__Reply__exception_raise_state_identity_t Reply_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__exc_subsystem__defined */
+
+#ifndef subsystem_to_name_map_exc
+#define subsystem_to_name_map_exc \
+    { "exception_raise", 2401 },\
+    { "exception_raise_state", 2402 },\
+    { "exception_raise_state_identity", 2403 }
+#endif
+
+#ifdef __AfterMigUserHeader
+__AfterMigUserHeader
+#endif /* __AfterMigUserHeader */
+
+#endif	 /* _exc_user_ */

proctl/mach_exc.defs

+/*
+ * Copyright (c) 2006 Apple Computer, Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ * 
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ * 
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ * 
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+/*
+ * @OSF_COPYRIGHT@
+ */
+/* 
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ */
+/*
+ * Abstract:
+ *	MiG definitions file for Mach exception interface.
+ */
+
+subsystem
+#if	KERNEL_USER
+	  KernelUser
+#endif
+		     mach_exc 2405;
+
+#include <mach/std_types.defs>
+#include <mach/mach_types.defs>
+
+ServerPrefix catch_;
+
+type mach_exception_data_t	= array[*:2] of int64_t;
+type exception_type_t		= int;
+
+routine		mach_exception_raise(
+#if	KERNEL_USER
+			exception_port	: mach_port_move_send_t;
+			thread		: mach_port_move_send_t;
+			task		: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port	: mach_port_t;
+			thread		: mach_port_t;
+			task		: mach_port_t;
+#endif	/* KERNEL_USER */
+			exception	: exception_type_t;
+			code		: mach_exception_data_t
+			);
+
+routine		mach_exception_raise_state(
+#if	KERNEL_USER
+			exception_port	: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port	: mach_port_t;
+#endif	/* KERNEL_USER */
+			exception	: exception_type_t;
+			code		: mach_exception_data_t, const;
+		  inout flavor		: int;
+			old_state	: thread_state_t, const;
+		    out new_state	: thread_state_t);
+
+routine		mach_exception_raise_state_identity(
+#if	KERNEL_USER
+			exception_port  : mach_port_move_send_t;
+			thread		: mach_port_move_send_t;
+			task		: mach_port_move_send_t;
+#else	/* KERNEL_USER */
+			exception_port  : mach_port_t;
+			thread          : mach_port_t;
+			task            : mach_port_t;
+#endif	/* KERNEL_USER */
+			exception       : exception_type_t;
+			code            : mach_exception_data_t;
+		  inout flavor          : int;
+			old_state       : thread_state_t;
+		    out new_state       : thread_state_t);
+
+/* vim: set ft=c : */

proctl/mach_exc.h

+#ifndef	_mach_exc_user_
+#define	_mach_exc_user_
+
+/* Module mach_exc */
+
+#include <string.h>
+#include <mach/ndr.h>
+#include <mach/boolean.h>
+#include <mach/kern_return.h>
+#include <mach/notify.h>
+#include <mach/mach_types.h>
+#include <mach/message.h>
+#include <mach/mig_errors.h>
+#include <mach/port.h>
+
+/* BEGIN VOUCHER CODE */
+
+#ifndef KERNEL
+#if defined(__has_include)
+#if __has_include(<mach/mig_voucher_support.h>)
+#ifndef USING_VOUCHERS
+#define USING_VOUCHERS
+#endif
+#ifndef __VOUCHER_FORWARD_TYPE_DECLS__
+#define __VOUCHER_FORWARD_TYPE_DECLS__
+#ifdef __cplusplus
+extern "C" {
+#endif
+	extern boolean_t voucher_mach_msg_set(mach_msg_header_t *msg) __attribute__((weak_import));
+#ifdef __cplusplus
+}
+#endif
+#endif // __VOUCHER_FORWARD_TYPE_DECLS__
+#endif // __has_include(<mach/mach_voucher_types.h>)
+#endif // __has_include
+#endif // !KERNEL
+
+/* END VOUCHER CODE */
+
+
+#ifdef AUTOTEST
+#ifndef FUNCTION_PTR_T
+#define FUNCTION_PTR_T
+typedef void (*function_ptr_t)(mach_port_t, char *, mach_msg_type_number_t);
+typedef struct {
+        char            *name;
+        function_ptr_t  function;
+} function_table_entry;
+typedef function_table_entry   *function_table_t;
+#endif /* FUNCTION_PTR_T */
+#endif /* AUTOTEST */
+
+#ifndef	mach_exc_MSG_COUNT
+#define	mach_exc_MSG_COUNT	3
+#endif	/* mach_exc_MSG_COUNT */
+
+#include <mach/std_types.h>
+#include <mach/mig.h>
+#include <mach/mig.h>
+#include <mach/mach_types.h>
+
+#ifdef __BeforeMigUserHeader
+__BeforeMigUserHeader
+#endif /* __BeforeMigUserHeader */
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+
+/* Routine mach_exception_raise */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_exception_raise
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	mach_exception_data_t code,
+	mach_msg_type_number_t codeCnt
+);
+
+/* Routine mach_exception_raise_state */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_exception_raise_state
+(
+	mach_port_t exception_port,
+	exception_type_t exception,
+	const mach_exception_data_t code,
+	mach_msg_type_number_t codeCnt,
+	int *flavor,
+	const thread_state_t old_state,
+	mach_msg_type_number_t old_stateCnt,
+	thread_state_t new_state,
+	mach_msg_type_number_t *new_stateCnt
+);
+
+/* Routine mach_exception_raise_state_identity */
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+kern_return_t mach_exception_raise_state_identity
+(
+	mach_port_t exception_port,
+	mach_port_t thread,
+	mach_port_t task,
+	exception_type_t exception,
+	mach_exception_data_t code,
+	mach_msg_type_number_t codeCnt,
+	int *flavor,
+	thread_state_t old_state,
+	mach_msg_type_number_t old_stateCnt,
+	thread_state_t new_state,
+	mach_msg_type_number_t *new_stateCnt
+);
+
+__END_DECLS
+
+/********************** Caution **************************/
+/* The following data types should be used to calculate  */
+/* maximum message sizes only. The actual message may be */
+/* smaller, and the position of the arguments within the */
+/* message layout may vary from what is presented here.  */
+/* For example, if any of the arguments are variable-    */
+/* sized, and less than the maximum is sent, the data    */
+/* will be packed tight in the actual message to reduce  */
+/* the presence of holes.                                */
+/********************** Caution **************************/
+
+/* typedefs for all requests */
+
+#ifndef __Request__mach_exc_subsystem__defined
+#define __Request__mach_exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		int64_t code[2];
+	} __Request__mach_exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		int64_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[224];
+	} __Request__mach_exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		/* start of the kernel processed data */
+		mach_msg_body_t msgh_body;
+		mach_msg_port_descriptor_t thread;
+		mach_msg_port_descriptor_t task;
+		/* end of the kernel processed data */
+		NDR_record_t NDR;
+		exception_type_t exception;
+		mach_msg_type_number_t codeCnt;
+		int64_t code[2];
+		int flavor;
+		mach_msg_type_number_t old_stateCnt;
+		natural_t old_state[224];
+	} __Request__mach_exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Request__mach_exc_subsystem__defined */
+
+/* union of all requests */
+
+#ifndef __RequestUnion__mach_exc_subsystem__defined
+#define __RequestUnion__mach_exc_subsystem__defined
+union __RequestUnion__mach_exc_subsystem {
+	__Request__mach_exception_raise_t Request_mach_exception_raise;
+	__Request__mach_exception_raise_state_t Request_mach_exception_raise_state;
+	__Request__mach_exception_raise_state_identity_t Request_mach_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__mach_exc_subsystem__defined */
+/* typedefs for all replies */
+
+#ifndef __Reply__mach_exc_subsystem__defined
+#define __Reply__mach_exc_subsystem__defined
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+	} __Reply__mach_exception_raise_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[224];
+	} __Reply__mach_exception_raise_state_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+
+#ifdef  __MigPackStructs
+#pragma pack(4)
+#endif
+	typedef struct {
+		mach_msg_header_t Head;
+		NDR_record_t NDR;
+		kern_return_t RetCode;
+		int flavor;
+		mach_msg_type_number_t new_stateCnt;
+		natural_t new_state[224];
+	} __Reply__mach_exception_raise_state_identity_t;
+#ifdef  __MigPackStructs
+#pragma pack()
+#endif
+#endif /* !__Reply__mach_exc_subsystem__defined */
+
+/* union of all replies */
+
+#ifndef __ReplyUnion__mach_exc_subsystem__defined
+#define __ReplyUnion__mach_exc_subsystem__defined
+union __ReplyUnion__mach_exc_subsystem {
+	__Reply__mach_exception_raise_t Reply_mach_exception_raise;
+	__Reply__mach_exception_raise_state_t Reply_mach_exception_raise_state;
+	__Reply__mach_exception_raise_state_identity_t Reply_mach_exception_raise_state_identity;
+};
+#endif /* !__RequestUnion__mach_exc_subsystem__defined */
+
+#ifndef subsystem_to_name_map_mach_exc
+#define subsystem_to_name_map_mach_exc \
+    { "mach_exception_raise", 2401 },\
+    { "mach_exception_raise_state", 2402 },\
+    { "mach_exception_raise_state_identity", 2403 }
+#endif
+
+#ifdef __AfterMigUserHeader
+__AfterMigUserHeader
+#endif /* __AfterMigUserHeader */
+
+#endif	 /* _mach_exc_user_ */

proctl/proctl.go

@@ -12,7 +12,6 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"time"
 
 	sys "golang.org/x/sys/unix"
 
@@ -32,6 +31,7 @@ type DebuggedProcess struct {
 	BreakPoints         map[uint64]*BreakPoint
 	Threads             map[int]*ThreadContext
 	CurrentThread       *ThreadContext
+	os                  *OSProcessDetails
 	breakpointIDCounter int
 	running             bool
 	halt                bool
@@ -52,19 +52,9 @@ func Attach(pid int) (*DebuggedProcess, error) {
 		return nil, err
 	}
 	// Attach to all currently active threads.
-	allm, err := dbp.CurrentThread.AllM()
-	if err != nil {
+	if err := dbp.updateThreadList(); err != nil {
 		return nil, err
 	}
-	for _, m := range allm {
-		if m.procid == 0 {
-			continue
-		}
-		_, err := dbp.AttachThread(m.procid)
-		if err != nil {
-			return nil, err
-		}
-	}
 	return dbp, nil
 }
 
@@ -90,70 +80,6 @@ func Launch(cmd []string) (*DebuggedProcess, error) {
 	return newDebugProcess(proc.Process.Pid, false)
 }
 
-// Returns a new DebuggedProcess struct with sensible defaults.
-func newDebugProcess(pid int, attach bool) (*DebuggedProcess, error) {
-	dbp := DebuggedProcess{
-		Pid:         pid,
-		Threads:     make(map[int]*ThreadContext),
-		BreakPoints: make(map[uint64]*BreakPoint),
-	}
-
-	if attach {
-		thread, err := dbp.AttachThread(pid)
-		if err != nil {
-			return nil, err
-		}
-		dbp.CurrentThread = thread
-	} else {
-		thread, err := dbp.addThread(pid)
-		if err != nil {
-			return nil, err
-		}
-		dbp.CurrentThread = thread
-	}
-
-	proc, err := os.FindProcess(pid)
-	if err != nil {
-		return nil, err
-	}
-
-	dbp.Process = proc
-	err = dbp.LoadInformation()
-	if err != nil {
-		return nil, err
-	}
-
-	return &dbp, nil
-}
-
-// Attach to a newly created thread, and store that thread in our list of
-// known threads.
-func (dbp *DebuggedProcess) AttachThread(tid int) (*ThreadContext, error) {
-	if thread, ok := dbp.Threads[tid]; ok {
-		return thread, nil
-	}
-
-	err := sys.PtraceAttach(tid)
-	if err != nil && err != sys.EPERM {
-		// Do not return err if err == EPERM,
-		// we may already be tracing this thread due to
-		// PTRACE_O_TRACECLONE. We will surely blow up later
-		// if we truly don't have permissions.
-		return nil, fmt.Errorf("could not attach to new thread %d %s", tid, err)
-	}
-
-	pid, status, err := wait(tid, 0)
-	if err != nil {
-		return nil, err
-	}
-
-	if status.Exited() {
-		return nil, fmt.Errorf("thread already exited %d", pid)
-	}
-
-	return dbp.addThread(tid)
-}
-
 // Returns whether or not Delve thinks the debugged
 // process is currently executing.
 func (dbp *DebuggedProcess) Running() bool {
@@ -219,18 +145,22 @@ func (dbp *DebuggedProcess) FindLocation(str string) (uint64, error) {
 func (dbp *DebuggedProcess) RequestManualStop() {
 	dbp.halt = true
 	for _, th := range dbp.Threads {
-		if stopped(th.Id) {
-			continue
-		}
-		sys.Tgkill(dbp.Pid, th.Id, sys.SIGSTOP)
+		th.Halt()
 	}
 	dbp.running = false
 }
 
-// Sets a breakpoint, adding it to our list of known breakpoints. Uses
-// the "current thread" when setting the breakpoint.
+// Sets a breakpoint at addr, and stores it in the process wide
+// 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.
+//
+// Depending on hardware support, Delve will choose to either
+// set a hardware or software breakpoint. Essentially, if the
+// hardware supports it, and there are free debug registers, Delve
+// will set a hardware breakpoint. Otherwise we fall back to software
+// breakpoints, which are a bit more work for us.
 func (dbp *DebuggedProcess) Break(addr uint64) (*BreakPoint, error) {
-	return dbp.CurrentThread.Break(addr)
+	return dbp.setBreakpoint(dbp.CurrentThread.Id, addr)
 }
 
 // Sets a breakpoint by location string (function, file+line, address)
@@ -239,12 +169,12 @@ func (dbp *DebuggedProcess) BreakByLocation(loc string) (*BreakPoint, error) {
 	if err != nil {
 		return nil, err
 	}
-	return dbp.CurrentThread.Break(addr)
+	return dbp.Break(addr)
 }
 
 // Clears a breakpoint in the current thread.
 func (dbp *DebuggedProcess) Clear(addr uint64) (*BreakPoint, error) {
-	return dbp.CurrentThread.Clear(addr)
+	return dbp.clearBreakpoint(dbp.CurrentThread.Id, addr)
 }
 
 // Clears a breakpoint by location (function, file+line, address, breakpoint id)
@@ -253,7 +183,7 @@ func (dbp *DebuggedProcess) ClearByLocation(loc string) (*BreakPoint, error) {
 	if err != nil {
 		return nil, err
 	}
-	return dbp.CurrentThread.Clear(addr)
+	return dbp.Clear(addr)
 }
 
 // Returns the status of the current main thread context.
@@ -272,62 +202,16 @@ func (dbp *DebuggedProcess) PrintThreadInfo() error {
 	return nil
 }
 
-// Steps through process.
-func (dbp *DebuggedProcess) Step() (err error) {
-	var (
-		th *ThreadContext
-		ok bool
-	)
-
-	allm, err := dbp.CurrentThread.AllM()
-	if err != nil {
-		return err
-	}
-
-	fn := func() error {
-		for _, m := range allm {
-			th, ok = dbp.Threads[m.procid]
-			if !ok {
-				th = dbp.Threads[dbp.Pid]
-			}
-
-			if m.blocked == 0 {
-				err := th.Step()
-				if err != nil {
-					return err
-				}
-			}
-
-		}
-		return nil
-	}
-
-	return dbp.run(fn)
-}
-
 // Step over function calls.
 func (dbp *DebuggedProcess) Next() error {
-	var (
-		th *ThreadContext
-		ok bool
-	)
+	var runnable []*ThreadContext
 
 	fn := func() error {
-		allm, err := dbp.CurrentThread.AllM()
-		if err != nil {
-			return err
-		}
-
-		for _, m := range allm {
-			th, ok = dbp.Threads[m.procid]
-			if !ok {
-				th = dbp.Threads[dbp.Pid]
-			}
-
-			if m.blocked == 1 {
-				// Continue any blocked M so that the
-				// scheduler can continue to do its'
-				// job correctly.
+		for _, th := range dbp.Threads {
+			// Continue any blocked M so that the
+			// scheduler can continue to do its'
+			// job correctly.
+			if th.blocked() {
 				err := th.Continue()
 				if err != nil {
 					return err
@@ -335,12 +219,15 @@ func (dbp *DebuggedProcess) Next() error {
 				continue
 			}
 
+			runnable = append(runnable, th)
+		}
+		for _, th := range runnable {
 			err := th.Next()
 			if err != nil && err != sys.ESRCH {
 				return err
 			}
 		}
-		return stopTheWorld(dbp)
+		return dbp.Halt()
 	}
 	return dbp.run(fn)
 }
@@ -364,6 +251,24 @@ func (dbp *DebuggedProcess) Continue() error {
 	return dbp.run(fn)
 }
 
+// Steps through process.
+func (dbp *DebuggedProcess) Step() (err error) {
+	fn := func() error {
+		for _, th := range dbp.Threads {
+			if th.blocked() {
+				continue
+			}
+			err := th.Step()
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	return dbp.run(fn)
+}
+
 // Obtains register values from what Delve considers to be the current
 // thread of the traced process.
 func (dbp *DebuggedProcess) Registers() (Registers, error) {
@@ -404,47 +309,20 @@ func (pe ProcessExitedError) Error() string {
 	return fmt.Sprintf("process %d has exited", pe.pid)
 }
 
-func trapWait(dbp *DebuggedProcess, pid int) (int, *sys.WaitStatus, error) {
-	for {
-		wpid, status, err := wait(pid, 0)
-		if err != nil {
-			return -1, nil, fmt.Errorf("wait err %s %d", err, pid)
-		}
-		if wpid == 0 {
-			continue
-		}
-		if th, ok := dbp.Threads[wpid]; ok {
-			th.Status = status
-		}
-		if status.Exited() && wpid == dbp.Pid {
-			return -1, status, ProcessExitedError{wpid}
-		}
-		if status.StopSignal() == sys.SIGTRAP && status.TrapCause() == sys.PTRACE_EVENT_CLONE {
-			err = addNewThread(dbp, wpid)
-			if err != nil {
-				return -1, nil, err
-			}
-			continue
-		}
-		if status.StopSignal() == sys.SIGTRAP {
-			return wpid, status, nil
-		}
-		if status.StopSignal() == sys.SIGSTOP && dbp.halt {
-			return -1, nil, ManualStopError{}
-		}
+func handleBreakPoint(dbp *DebuggedProcess, pid int) error {
+	thread, ok := dbp.Threads[pid]
+	if !ok {
+		return fmt.Errorf("could not find thread for %d", pid)
 	}
-}
 
-func handleBreakPoint(dbp *DebuggedProcess, pid int) error {
-	thread := dbp.Threads[pid]
 	if pid != dbp.CurrentThread.Id {
-		fmt.Printf("thread context changed from %d to %d\n", dbp.CurrentThread.Id, pid)
+		fmt.Printf("thread context changed from %d to %d\n", dbp.CurrentThread.Id, thread.Id)
 		dbp.CurrentThread = thread
 	}
 
 	pc, err := thread.CurrentPC()
 	if err != nil {
-		return fmt.Errorf("could not get current pc %s", err)
+		return err
 	}
 
 	// Check to see if we hit a runtime.breakpoint
@@ -457,15 +335,15 @@ func handleBreakPoint(dbp *DebuggedProcess, pid int) error {
 				return err
 			}
 		}
-		stopTheWorld(dbp)
+		dbp.Halt()
 		return nil
 	}
 
 	// Check for hardware breakpoint
 	for _, bp := range dbp.HWBreakPoints {
-		if bp.Addr == pc {
+		if bp != nil && bp.Addr == pc {
 			if !bp.temp {
-				stopTheWorld(dbp)
+				return dbp.Halt()
 			}
 			return nil
 		}
@@ -473,81 +351,10 @@ func handleBreakPoint(dbp *DebuggedProcess, pid int) error {
 	// Check to see if we have hit a software breakpoint.
 	if bp, ok := dbp.BreakPoints[pc-1]; ok {
 		if !bp.temp {
-			stopTheWorld(dbp)
+			return dbp.Halt()
 		}
 		return nil
 	}
 
-	return fmt.Errorf("did not hit recognized breakpoint")
-}
-
-// Ensure execution of every traced thread is halted.
-func stopTheWorld(dbp *DebuggedProcess) error {
-	// Loop through all threads and ensure that we
-	// stop the rest of them, so that by the time
-	// we return control to the user, all threads
-	// are inactive. We send SIGSTOP and ensure all
-	// threads are in in signal-delivery-stop mode.
-	for _, th := range dbp.Threads {
-		if stopped(th.Id) {
-			continue
-		}
-		err := sys.Tgkill(dbp.Pid, th.Id, sys.SIGSTOP)
-		if err != nil {
-			return err
-		}
-		pid, _, err := wait(th.Id, sys.WNOHANG)
-		if err != nil {
-			return fmt.Errorf("wait err %s %d", err, pid)
-		}
-	}
-
-	return nil
-}
-
-func addNewThread(dbp *DebuggedProcess, pid int) error {
-	// A traced thread has cloned a new thread, grab the pid and
-	// add it to our list of traced threads.
-	msg, err := sys.PtraceGetEventMsg(pid)
-	if err != nil {
-		return fmt.Errorf("could not get event message: %s", err)
-	}
-	fmt.Println("new thread spawned", msg)
-
-	_, err = dbp.addThread(int(msg))
-	if err != nil {
-		return err
-	}
-
-	err = sys.PtraceCont(int(msg), 0)
-	if err != nil {
-		return fmt.Errorf("could not continue new thread %d %s", msg, err)
-	}
-
-	// Here we loop for a while to ensure that the once we continue
-	// the newly created thread, we allow enough time for the runtime
-	// to assign m->procid. This is important because we rely on
-	// looping through runtime.allm in other parts of the code, so
-	// we require that this is set before we do anything else.
-	// TODO(dp): we might be able to eliminate this loop by telling
-	// the CPU to emit a breakpoint exception on write to this location
-	// in memory. That way we prevent having to loop, and can be
-	// notified as soon as m->procid is set.
-	th := dbp.Threads[pid]
-	for {
-		allm, _ := th.AllM()
-		for _, m := range allm {
-			if m.procid == int(msg) {
-				// Continue the thread that cloned
-				return sys.PtraceCont(pid, 0)
-			}
-		}
-		time.Sleep(time.Millisecond)
-	}
-}
-
-func wait(pid, options int) (int, *sys.WaitStatus, error) {
-	var status sys.WaitStatus
-	wpid, err := sys.Wait4(pid, &status, sys.WALL|options, nil)
-	return wpid, &status, err
+	return fmt.Errorf("unrecognized breakpoint %#v", pc)
 }

proctl/proctl_darwin.c

+#include "proctl_darwin.h"
+
+
+static const unsigned char info_plist[]
+__attribute__ ((section ("__TEXT,__info_plist"),used)) =
+  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+  "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\""
+  " \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
+  "<plist version=\"1.0\">\n"
+  "<dict>\n"
+  "  <key>CFBundleIdentifier</key>\n"
+  "  <string>org.dlv</string>\n"
+  "  <key>CFBundleName</key>\n"
+  "  <string>delve</string>\n"
+  "  <key>CFBundleVersion</key>\n"
+  "  <string>1.0</string>\n"
+  "  <key>SecTaskAccess</key>\n"
+  "  <array>\n"
+  "    <string>allowed</string>\n"
+  "    <string>debug</string>\n"
+  "  </array>\n"
+  "</dict>\n"
+  "</plist>\n";
+
+static thread_act_t _global_thread;
+
+kern_return_t
+acquire_mach_task(int tid, mach_port_name_t *task, mach_port_t *exception_port) {
+  kern_return_t kret;
+  mach_port_t self = mach_task_self();
+
+  kret = task_for_pid(self, tid, task);
+  if (kret != KERN_SUCCESS) return kret;
+
+  kret = mach_port_allocate(self, MACH_PORT_RIGHT_RECEIVE, exception_port);
+  if (kret != KERN_SUCCESS) return kret;
+
+  kret = mach_port_insert_right(self, *exception_port, *exception_port, MACH_MSG_TYPE_MAKE_SEND);
+  if (kret != KERN_SUCCESS) return kret;
+
+  // Set exception port
+  return task_set_exception_ports(*task, EXC_MASK_BREAKPOINT|EXC_MASK_SOFTWARE, *exception_port,
+    EXCEPTION_DEFAULT, THREAD_STATE_NONE);
+}
+
+char *
+find_executable(int pid) {
+	static char pathbuf[PATH_MAX];
+	proc_pidpath(pid, pathbuf, PATH_MAX);
+	return pathbuf;
+}
+
+kern_return_t
+get_threads(task_t task, void *slice) {
+  kern_return_t kret;
+  thread_act_array_t list;
+  mach_msg_type_number_t count;
+
+  kret = task_threads(task, &list, &count);
+  if (kret != KERN_SUCCESS) {
+    return kret;
+  }
+
+  memcpy(slice, (void*)list, count*sizeof(list[0]));
+  return (kern_return_t)0;
+}
+
+int
+thread_count(task_t task) {
+  kern_return_t kret;
+  thread_act_array_t list;
+  mach_msg_type_number_t count;
+
+  // TODO(dp) vm_deallocate list
+  kret = task_threads(task, &list, &count);
+  if (kret != KERN_SUCCESS) return -1;
+  return count;
+}
+
+typedef struct exc_msg {
+  mach_msg_header_t Head;
+  mach_msg_body_t msgh_body;
+  mach_msg_port_descriptor_t thread;
+  mach_msg_port_descriptor_t task;
+  NDR_record_t NDR;
+  exception_type_t exception;
+  mach_msg_type_number_t codeCnt;
+  exception_data_t code;
+  char pad[512];
+} exc_msg_t;
+
+thread_act_t
+mach_port_wait(mach_port_t port) {
+  puts("begin mach wait");
+  mach_msg_return_t msg = mach_msg_server_once(exc_server, sizeof(exc_msg_t), port, MACH_MSG_TIMEOUT_NONE);
+  if (msg != MACH_MSG_SUCCESS) {
+  }
+  puts("fin mach wait");
+  return _global_thread;
+}
+
+// 64 bit exception handlers
+
+kern_return_t
+catch_mach_exception_raise(
+  mach_port_t exception_port,
+  mach_port_t thread,
+  mach_port_t task,
+  exception_type_t exception,
+  mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt)
+{
+  puts("caught exception raise");
+  fprintf(stderr, "My exception handler was called by exception_raise()\n");
+  return KERN_SUCCESS;
+}
+
+kern_return_t
+catch_mach_exception_raise_state(
+  mach_port_t exception_port,
+  exception_type_t exception,
+  const mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt,
+  int *flavor,
+  const thread_state_t old_state,
+  mach_msg_type_number_t old_stateCnt,
+  thread_state_t new_state,
+  mach_msg_type_number_t *new_stateCnt)
+{
+  puts("caught raise state");
+  fprintf(stderr, "My exception handler was called by exception_raise()\n");
+  return KERN_SUCCESS;
+}
+
+kern_return_t
+catch_mach_exception_raise_state_identity(
+  mach_port_t exception_port,
+  mach_port_t thread,
+  mach_port_t task,
+  exception_type_t exception,
+  mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt,
+  int *flavor,
+  thread_state_t old_state,
+  mach_msg_type_number_t old_stateCnt,
+  thread_state_t new_state,
+  mach_msg_type_number_t *new_stateCnt)
+{
+  puts("caught identity");
+  fprintf(stderr, "My exception handler was called by exception_raise()\n");
+  return KERN_SUCCESS;
+}
+
+// 32 bit exception handlers
+
+kern_return_t
+catch_exception_raise(
+  mach_port_t exception_port,
+  mach_port_t thread,
+  mach_port_t task,
+  exception_type_t exception,
+  mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt)
+{
+  _global_thread = (thread_act_t)thread;
+  thread_suspend(thread);
+  return KERN_SUCCESS;
+}
+
+kern_return_t
+catch_exception_raise_state(
+  mach_port_t exception_port,
+  exception_type_t exception,
+  const mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt,
+  int *flavor,
+  const thread_state_t old_state,
+  mach_msg_type_number_t old_stateCnt,
+  thread_state_t new_state,
+  mach_msg_type_number_t *new_stateCnt)
+{
+  puts("caught raise state");
+  fprintf(stderr, "My exception handler was called by exception_raise()\n");
+  return KERN_SUCCESS;
+}
+
+kern_return_t
+catch_exception_raise_state_identity(
+  mach_port_t exception_port,
+  mach_port_t thread,
+  mach_port_t task,
+  exception_type_t exception,
+  mach_exception_data_t code,
+  mach_msg_type_number_t codeCnt,
+  int *flavor,
+  thread_state_t old_state,
+  mach_msg_type_number_t old_stateCnt,
+  thread_state_t new_state,
+  mach_msg_type_number_t *new_stateCnt)
+{
+  puts("caught identity");
+  fprintf(stderr, "My exception handler was called by exception_raise()\n");
+  return KERN_SUCCESS;
+}

proctl/proctl_darwin.h

+#include <errno.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <libproc.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include "mach_exc.h"
+#include "exc.h"
+
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+boolean_t exc_server(
+		mach_msg_header_t *InHeadP,
+		mach_msg_header_t *OutHeadP);
+
+#ifdef	mig_external
+mig_external
+#else
+extern
+#endif	/* mig_external */
+boolean_t mach_exc_server(
+		mach_msg_header_t *InHeadP,
+		mach_msg_header_t *OutHeadP);
+
+kern_return_t
+acquire_mach_task(int, mach_port_name_t *, mach_port_t *);
+
+char *
+find_executable(int pid);
+
+kern_return_t
+get_threads(task_t task, void *);
+
+int
+thread_count(task_t task);
+
+thread_act_t
+mach_port_wait(mach_port_t);

proctl/ptrace_darwin.go

+package proctl
+
+import (
+	"syscall"
+
+	sys "golang.org/x/sys/unix"
+)
+
+func PtraceCont(tid, sig int) error {
+	_, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PTRACE_CONT, uintptr(tid), 1, uintptr(sig), 0, 0)
+	if err != syscall.Errno(0) {
+		return err
+	}
+	return nil
+}
+
+func PtraceSingleStep(tid int) error {
+	_, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PT_STEP, uintptr(tid), 1, 0, 0, 0)
+	if err != syscall.Errno(0) {
+		return err
+	}
+	return nil
+}

proctl/ptrace_linux.go

+package proctl
+
+import (
+	"syscall"
+	"unsafe"
+
+	sys "golang.org/x/sys/unix"
+)
+
+func PtraceCont(tid, sig int) error {
+	return sys.PtraceCont(tid, sig)
+}
+
+func PtraceSingleStep(tid int) error {
+	return sys.PtraceSingleStep(tid)
+}
+
+func PtracePokeUser(tid int, off, addr uintptr) error {
+	_, _, err := sys.Syscall6(sys.SYS_PTRACE, sys.PTRACE_POKEUSR, uintptr(tid), uintptr(off), uintptr(addr), 0, 0)
+	if err != syscall.Errno(0) {
+		return err
+	}
+	return nil
+}
+
+func PtracePeekUser(tid int, off uintptr) (uintptr, error) {
+	var val uintptr
+	_, _, err := syscall.Syscall6(syscall.SYS_PTRACE, syscall.PTRACE_PEEKUSR, uintptr(tid), uintptr(off), uintptr(unsafe.Pointer(&val)), 0, 0)
+	if err != syscall.Errno(0) {
+		return 0, err
+	}
+	return val, nil
+}

proctl/registers_darwin_amd64.go

+package proctl
+
+// #include "threads_darwin.h"
+import "C"
+
+type Regs struct {
+	pc, sp uint64
+}
+
+func (r *Regs) PC() uint64 {
+	return r.pc
+}
+
+func (r *Regs) SP() uint64 {
+	return r.sp
+}
+
+func (r *Regs) SetPC(thread *ThreadContext, pc uint64) error {
+	C.set_pc(thread.os.thread_act, C.uint64_t(pc))
+	return nil
+}
+
+func registers(thread *ThreadContext) (Registers, error) {
+	state := C.get_registers(C.mach_port_name_t(thread.os.thread_act))
+	regs := &Regs{pc: uint64(state.__rip), sp: uint64(state.__rsp)}
+	return regs, nil
+}