chore: attempt to fix clone on Darwin

- Use MAP_JIT for cloned function area on Darwin
- Verify the address from mmap is in the acceptable range (it never is
  on Darwin, but I think this should help other OS's)
- Call `pthread_jit_write_protect_np()` on Darwin

None of these things actually make any difference, but I think they're
necessary.

Author: pboyd

clone.go

@@ -83,7 +83,7 @@ func (a *allocator) init(startSize int) error {
 		}
 
 		if protBE, ok := be.(malloc.ProtectedArenaBackend); ok {
-			a.mprotect = protBE.Protect
+			a.mprotect = mprotectHook(protBE.Protect)
 		} else {
 			// No real mprotect for some reason. This shouldn't
 			// really happen, but continue with a no-op mprotect.
@@ -127,34 +127,48 @@ func initMallocBackend() (malloc.ArenaBackend, error) {
 	// space right before the text segment but that's not guaranteed
 	// (particularly when buildmode=pie).
 
-	// The minimum acceptable address is where the first
-	// instruction in the code segment can still reach the final
-	// address before end. These are unsigned so watch for wrap-around.
+	// The minimum acceptable address is where the first instruction in the
+	// code segment can still reach the final address before end. The
+	// maximum address is similar. These are unsigned so watch for
+	// wrap-around.
 	minAddress := end - maxCloneDistance
 	if minAddress > end || minAddress < absMinAddress {
 		minAddress = absMinAddress
 	}
-	for addr := text - pageSize - size; addr >= minAddress; addr -= 0x100000 {
-		be, err := malloc.VirtBackend(size, malloc.MmapAddr(addr), malloc.MmapProt(mprotectExec), malloc.MmapFlags(_MAP_FIXED_NOREPLACE))
+	maxAddress := text + maxCloneDistance - size
+	if maxAddress < text {
+		maxAddress = math.MaxUint
+	}
+
+	for addr := text - pageSize - size; addr >= minAddress; addr -= pageSize {
+		be, err := malloc.VirtBackend(size, malloc.MmapAddr(addr), malloc.MmapProt(mprotectExec), malloc.MmapFlags(_MMAP_FLAGS))
 		if err == nil {
-			return be, nil
+			if be.Addr() < minAddress || be.Addr() > maxAddress {
+				// No good, try again.
+				be.Release()
+			} else {
+				return be, nil
+			}
 		}
 	}
 
 	// Nothing was found before the text segment, repeat the process for
 	// the space after end.
-	maxAddress := text + maxCloneDistance - size
-	if maxAddress < text {
-		maxAddress = math.MaxUint
-	}
-	for addr := end; addr <= maxAddress; addr += 0x100000 {
-		be, err := malloc.VirtBackend(size, malloc.MmapAddr(addr), malloc.MmapProt(mprotectExec), malloc.MmapFlags(_MAP_FIXED_NOREPLACE))
+	for addr := end; addr <= maxAddress; addr += pageSize {
+		be, err := malloc.VirtBackend(size, malloc.MmapAddr(addr), malloc.MmapProt(mprotectExec), malloc.MmapFlags(_MMAP_FLAGS))
 		if err == nil {
-			return be, nil
+			if be.Addr() < minAddress || be.Addr() > maxAddress {
+				// No good, try again.
+				be.Release()
+			} else {
+				return be, nil
+			}
 		}
 	}
 
-	return nil, errors.New("no suitable virtual memory space found")
+	// Well, we tried. We tried really hard. There's nothing left to do but
+	// take whatever address the OS gives us.
+	return malloc.VirtBackend(size, malloc.MmapAddr(minAddress), malloc.MmapProt(mprotectExec), malloc.MmapFlags(_MMAP_FLAGS))
 }
 
 func (a *allocator) BeginMutate() error {

clone_mprotect.go

@@ -0,0 +1,7 @@
+//go:build !(darwin && arm64)
+
+package redefine
+
+func mprotectHook(inner func(int) error) func(int) error {
+	return inner
+}

clone_mprotect_darwin.go

@@ -0,0 +1,22 @@
+//go:build darwin && arm64
+
+package redefine
+
+import "golang.org/x/sys/unix"
+
+/*
+	#include <pthread.h>
+*/
+import "C"
+
+func mprotectHook(inner func(int) error) func(int) error {
+	// TODO: Figure out if this is really needed.
+	return func(prot int) error {
+		if prot&unix.PROT_WRITE != 0 {
+			C.pthread_jit_write_protect_np(0)
+		} else {
+			C.pthread_jit_write_protect_np(1)
+		}
+		return inner(prot)
+	}
+}

go.mod

@@ -3,7 +3,7 @@ module github.com/pboyd/redefine
 go 1.25.0
 
 require (
-	github.com/pboyd/malloc v1.2.0
+	github.com/pboyd/malloc v1.2.1
 	github.com/stretchr/testify v1.11.1
 	golang.org/x/arch v0.23.0
 )

go.sum

@@ -6,6 +6,8 @@ github.com/pboyd/malloc v1.1.0 h1:xVOGFPmrMYU+uV5YnIHcvaXeZi8ERNE/umKwv9aXqKs=
 github.com/pboyd/malloc v1.1.0/go.mod h1:YGRIeEWvukIMTTZffUkV74qEnoRmuAp9mPrw0LDk3SE=
 github.com/pboyd/malloc v1.2.0 h1:YrXyBimK7NsNiUVqKznnKir9aCCmMN5+/tzu5qvEu8M=
 github.com/pboyd/malloc v1.2.0/go.mod h1:YGRIeEWvukIMTTZffUkV74qEnoRmuAp9mPrw0LDk3SE=
+github.com/pboyd/malloc v1.2.1 h1:hRQuCrDsKufuO3WA9z6AM1OXpGhRBvVjsyF64ja+JRw=
+github.com/pboyd/malloc v1.2.1/go.mod h1:YGRIeEWvukIMTTZffUkV74qEnoRmuAp9mPrw0LDk3SE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=

mmap_flags_darwin.go

@@ -0,0 +1,9 @@
+//go:build darwin
+
+package redefine
+
+import "golang.org/x/sys/unix"
+
+// Darwin has no equivalent to MAP_FIXED_NOREPLACE. But MAP_JIT is required to
+// use PROT_WRITE and PROT_EXEC together.
+const _MMAP_FLAGS = unix.MAP_JIT

mmap_flags_fallback.go

@@ -1,14 +1,13 @@
-//go:build darwin || netbsd || openbsd || windows
+//go:build netbsd || openbsd || windows
 
 package redefine
 
-// Darwin, NetBSD, OpenBSD and Windows don't have an equivalent to
-// MAP_FIXED_NOREPLACE. On BSD, MAP_FIXED would almost work except that it
-// would replace existing mappings. We'll have to trust the OS to give us a
-// suitable address based on our request.
+// NetBSD, OpenBSD and Windows don't have an equivalent to MAP_FIXED_NOREPLACE.
+// On BSD, MAP_FIXED would almost work except that it would replace existing
+// mappings. We'll have to trust the OS to give us a suitable address based on
+// our request.
 //
-// https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/mmap.2.html
 // https://man.netbsd.org/mmap.2
 // https://man.openbsd.org/mmap.2
 // https://learn.microsoft.com/en-us/windows/win32/api/memoryapi/nf-memoryapi-virtualalloc
-const _MAP_FIXED_NOREPLACE = 0
+const _MMAP_FLAGS = 0

mmap_flags_freebsd.go

@@ -8,4 +8,4 @@ import "golang.org/x/sys/unix"
 // Linux
 //
 // https://man.freebsd.org/cgi/man.cgi?mmap(2)
-const _MAP_FIXED_NOREPLACE = unix.MAP_FIXED | unix.MAP_EXCL
+const _MMAP_FLAGS = unix.MAP_FIXED | unix.MAP_EXCL

mmap_flags_linux.go

@@ -4,4 +4,4 @@ package redefine
 
 import "golang.org/x/sys/unix"
 
-const _MAP_FIXED_NOREPLACE = unix.MAP_FIXED_NOREPLACE
+const _MMAP_FLAGS = unix.MAP_FIXED_NOREPLACE

redefine.go

@@ -115,7 +115,9 @@ func Original[T any](fn T) T {
 	}
 
 	if clonedType, ok := cloned.(*clonedFunc[T]); ok {
-		return clonedType.Func
+		if clonedType != nil {
+			return clonedType.Func
+		}
 	}
 
 	return *((*T)(nil))
@@ -183,13 +185,13 @@ func unsafeFunc[T any](fn T, newFn any) error {
 		redefined[addr], err = cloneFunc(fn)
 		if err != nil {
 			// TODO: Should this be fatal?
-			return err
+			return fmt.Errorf("unable to clone function: %w", err)
 		}
 	}
 
 	err = mprotect(code, mprotectRWX)
 	if err != nil {
-		return err
+		return fmt.Errorf("mprotect: %w", err)
 	}
 	defer mprotect(code, mprotectRX)