Odin/base/runtime/virtual_memory_darwin.odin

#+private
package runtime

import "base:intrinsics"

VIRTUAL_MEMORY_SUPPORTED :: true

foreign import lib "system:System.framework"

foreign lib {
	mach_task_self :: proc() -> u32 ---
	mach_vm_allocate :: proc(target: u32, address: ^u64, size: u64, flags: i32) -> i32 ---
	mach_vm_deallocate :: proc(target: u32, address: u64, size: u64) -> i32 ---
	mach_vm_map :: proc(
		target_task:    u32,
		address:        ^u64,
		size:           u64,
		mask:           u64,
		flags:          i32,
		object:         i32,
		offset:         uintptr,
		copy:           b32,
		cur_protection,
		max_protection: i32,
		inheritance:    u32,
	) -> i32 ---
	mach_vm_remap :: proc(
		target_task:    u32,
		target_address: ^u64,
		size:           u64,
		mask:           u64,
		flags:          i32,
		src_task:       u32,
		src_address:    u64,
		copy:           b32,
		cur_protection,
		max_protection: ^i32,
		inheritance:    u32,
	) -> i32 ---
}

// The following features are specific to Darwin only.
VM_FLAGS_ANYWHERE :: 0x0001

SUPERPAGE_SIZE_ANY :: 1
SUPERPAGE_SIZE_2MB :: 2

VM_FLAGS_SUPERPAGE_SHIFT    :: 16
VM_FLAGS_SUPERPAGE_SIZE_ANY :: SUPERPAGE_SIZE_ANY << VM_FLAGS_SUPERPAGE_SHIFT
VM_FLAGS_SUPERPAGE_SIZE_2MB :: SUPERPAGE_SIZE_2MB << VM_FLAGS_SUPERPAGE_SHIFT

MEMORY_OBJECT_NULL :: 0
VM_PROT_READ  :: 0x01
VM_PROT_WRITE :: 0x02
VM_INHERIT_COPY :: 1

_allocate_virtual_memory :: proc "contextless" (size: int) -> rawptr {
	address: u64
	result := mach_vm_map(mach_task_self(), &address, u64(size), 0, VM_FLAGS_ANYWHERE, MEMORY_OBJECT_NULL, 0, false, VM_PROT_READ|VM_PROT_WRITE, VM_PROT_READ|VM_PROT_WRITE, VM_INHERIT_COPY)
	if result != 0 {
		return nil
	}
	return rawptr(uintptr(address))
}

_allocate_virtual_memory_superpage :: proc "contextless" () -> rawptr {
	address: u64
	flags: i32 = VM_FLAGS_ANYWHERE
	when ODIN_ARCH == .amd64 {
		// NOTE(Feoramund): As far as we are aware, Darwin only supports
		// explicit superpage allocation on AMD64 with a 2MiB parameter.
		when SUPERPAGE_SIZE == 2 * Megabyte {
			flags |= VM_FLAGS_SUPERPAGE_SIZE_2MB
		} else {
			#panic("An unsupported superpage size has been configured for AMD64 Darwin; only 2MB is supported.")
		}
	}
	alignment_mask: u64 = SUPERPAGE_SIZE - 1 // Assumes a power of two size, ensured by an assertion in `virtual_memory.odin`.
	result := mach_vm_map(mach_task_self(), &address, SUPERPAGE_SIZE, alignment_mask, flags, MEMORY_OBJECT_NULL, 0, false, VM_PROT_READ|VM_PROT_WRITE, VM_PROT_READ|VM_PROT_WRITE, VM_INHERIT_COPY)
	if result != 0 {
		return nil
	}
	assert_contextless(address % SUPERPAGE_SIZE == 0)
	return rawptr(uintptr(address))
}

_allocate_virtual_memory_aligned :: proc "contextless" (size: int, alignment: int) -> rawptr {
	address: u64
	alignment_mask: u64 = u64(alignment) - 1
	result := mach_vm_map(mach_task_self(), &address, u64(size), alignment_mask, VM_FLAGS_ANYWHERE, MEMORY_OBJECT_NULL, 0, false, VM_PROT_READ|VM_PROT_WRITE, VM_PROT_READ|VM_PROT_WRITE, VM_INHERIT_COPY)
	if result != 0 {
		return nil
	}
	return rawptr(uintptr(address))
}

_free_virtual_memory :: proc "contextless" (ptr: rawptr, size: int) {
	mach_vm_deallocate(mach_task_self(), u64(uintptr(ptr)), u64(size))
}

_resize_virtual_memory :: proc "contextless" (ptr: rawptr, old_size: int, new_size: int, alignment: int) -> rawptr {
	old_size_pages := old_size / PAGE_SIZE
	new_size_pages := new_size / PAGE_SIZE
	if old_size % PAGE_SIZE != 0 {
		old_size_pages += 1
	}
	if new_size % PAGE_SIZE != 0 {
		new_size_pages += 1
	}

	if new_size_pages == old_size_pages {
		return ptr
	} else if new_size_pages > old_size_pages {
		new_address: u64
		result_alloc := mach_vm_allocate(mach_task_self(), &new_address, u64(new_size), VM_FLAGS_ANYWHERE)
		if result_alloc != 0 {
			return nil
		}

		alignment_mask: u64
		if alignment != 0 {
			alignment_mask = u64(alignment) - 1
		}

		cur_protection, max_protection: i32
		result_remap := mach_vm_remap(mach_task_self(), &new_address, u64(old_size), alignment_mask, VM_FLAGS_ANYWHERE, mach_task_self(), u64(uintptr(ptr)), true, &cur_protection, &max_protection, VM_INHERIT_COPY)
		if result_remap != 0 {
			return nil
		}
		mach_vm_deallocate(mach_task_self(), u64(uintptr(ptr)), u64(old_size))
		return rawptr(uintptr(new_address))
	} else {
		new_size_boundary := new_size_pages * PAGE_SIZE
		shrink_by := u64(old_size - new_size)
		mach_vm_deallocate(mach_task_self(), u64(uintptr(ptr) + uintptr(new_size_boundary)), shrink_by)
		return rawptr(uintptr(ptr))
	}
}