Alias heap calls from base:runtime is core:os

base/runtime/heap_allocator.odin

@@ -95,3 +95,16 @@ heap_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
 
 	return nil, nil
 }
+
+
+heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
+	return _heap_alloc(size, zero_memory)
+}
+
+heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+	return heap_resize(ptr, new_size)
+}
+
+heap_free :: proc(ptr: rawptr) {
+	_heap_free(ptr)
+}

base/runtime/heap_allocator_other.odin

@@ -2,14 +2,14 @@
 //+private
 package runtime
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
+_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
 	unimplemented("base:runtime 'heap_alloc' procedure is not supported on this platform")
 }
 
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
 	unimplemented("base:runtime 'heap_resize' procedure is not supported on this platform")
 }
 
-heap_free :: proc(ptr: rawptr) {
+_heap_free :: proc(ptr: rawptr) {
 	unimplemented("base:runtime 'heap_free' procedure is not supported on this platform")
 }

base/runtime/heap_allocator_unix.odin

@@ -16,7 +16,7 @@ foreign libc {
 	@(link_name="realloc")  _unix_realloc  :: proc(ptr: rawptr, size: int) -> rawptr ---
 }
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
+_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
 	if size <= 0 {
 		return nil
 	}
@@ -27,12 +27,12 @@ heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
 	}
 }
 
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
+_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
 	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
 	// POSIX platforms. Ensure your caller takes this into account.
 	return _unix_realloc(ptr, new_size)
 }
 
-heap_free :: proc(ptr: rawptr) {
+_heap_free :: proc(ptr: rawptr) {
 	_unix_free(ptr)
 }

base/runtime/heap_allocator_windows.odin

@@ -5,34 +5,35 @@ foreign import kernel32 "system:Kernel32.lib"
 @(private="file")
 @(default_calling_convention="system")
 foreign kernel32 {
-        // NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency
+	// NOTE(bill): The types are not using the standard names (e.g. DWORD and LPVOID) to just minimizing the dependency
 
-        // default_allocator
+	// default_allocator
-        GetProcessHeap :: proc() -> rawptr ---
+	GetProcessHeap :: proc() -> rawptr ---
-        HeapAlloc      :: proc(hHeap: rawptr, dwFlags: u32, dwBytes: uint) -> rawptr ---
+	HeapAlloc      :: proc(hHeap: rawptr, dwFlags: u32, dwBytes: uint) -> rawptr ---
-        HeapReAlloc    :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr, dwBytes: uint) -> rawptr ---
+	HeapReAlloc    :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr, dwBytes: uint) -> rawptr ---
-        HeapFree       :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr) -> b32 ---
+	HeapFree       :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr) -> b32 ---
 }
 
-heap_alloc :: proc "contextless" (size: int, zero_memory := true) -> rawptr {
+_heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-        HEAP_ZERO_MEMORY :: 0x00000008
+	HEAP_ZERO_MEMORY :: 0x00000008
-        return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY if zero_memory else 0, uint(size))
+	return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY if zero_memory else 0, uint(size))
 }
-heap_resize :: proc "contextless" (ptr: rawptr, new_size: int) -> rawptr {
+_heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-        if new_size == 0 {
+	if new_size == 0 {
-                heap_free(ptr)
+		_heap_free(ptr)
-                return nil
+		return nil
-        }
+	}
-        if ptr == nil {
+	if ptr == nil {
-                return heap_alloc(new_size)
+		return _heap_alloc(new_size)
-        }
+	}
 
-        HEAP_ZERO_MEMORY :: 0x00000008
+	HEAP_ZERO_MEMORY :: 0x00000008
-        return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, uint(new_size))
+	return HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ptr, uint(new_size))
 }
-heap_free :: proc "contextless" (ptr: rawptr) {
+_heap_free :: proc(ptr: rawptr) {
-        if ptr == nil {
+	if ptr == nil {
-                return
+		return
-        }
+	}
-        HeapFree(GetProcessHeap(), 0, ptr)
+	HeapFree(GetProcessHeap(), 0, ptr)
 }
+

base/runtime/os_specific_windows.odin

@@ -49,60 +49,3 @@ _os_write :: proc "contextless" (data: []byte) -> (n: int, err: _OS_Errno) #no_b
 	n = int(total_write)
 	return
 }
-
-
-
-//
-// NOTE(tetra, 2020-01-14): The heap doesn't respect alignment.
-// Instead, we overallocate by `alignment + size_of(rawptr) - 1`, and insert
-// padding. We also store the original pointer returned by heap_alloc right before
-// the pointer we return to the user.
-//
-
-
-
-_windows_default_alloc_or_resize :: proc "contextless" (size, alignment: int, old_ptr: rawptr = nil, zero_memory := true) -> ([]byte, Allocator_Error) {
-	if size == 0 {
-		_windows_default_free(old_ptr)
-		return nil, nil
-	}
-
-	a := max(alignment, align_of(rawptr))
-	space := size + a - 1
-
-	allocated_mem: rawptr
-	if old_ptr != nil {
-		original_old_ptr := ([^]rawptr)(old_ptr)[-1]
-		allocated_mem = heap_resize(original_old_ptr, space+size_of(rawptr))
-	} else {
-		allocated_mem = heap_alloc(space+size_of(rawptr), zero_memory)
-	}
-	aligned_mem := ([^]u8)(allocated_mem)[size_of(rawptr):]
-
-	ptr := uintptr(aligned_mem)
-	aligned_ptr := (ptr - 1 + uintptr(a)) & -uintptr(a)
-	diff := int(aligned_ptr - ptr)
-	if (size + diff) > space || allocated_mem == nil {
-		return nil, .Out_Of_Memory
-	}
-
-	aligned_mem = ([^]byte)(aligned_ptr)
-	([^]rawptr)(aligned_mem)[-1] = allocated_mem
-
-	return aligned_mem[:size], nil
-}
-
-_windows_default_alloc :: proc "contextless" (size, alignment: int, zero_memory := true) -> ([]byte, Allocator_Error) {
-	return _windows_default_alloc_or_resize(size, alignment, nil, zero_memory)
-}
-
-
-_windows_default_free :: proc "contextless" (ptr: rawptr) {
-	if ptr != nil {
-		heap_free(([^]rawptr)(ptr)[-1])
-	}
-}
-
-_windows_default_resize :: proc "contextless" (p: rawptr, old_size: int, new_size: int, new_alignment: int) -> ([]byte, Allocator_Error) {
-	return _windows_default_alloc_or_resize(new_size, new_alignment, p)
-}

core/os/os.odin

@@ -1,5 +1,6 @@
 package os
 
+import "base:runtime"
 import "core:mem"
 import "core:strconv"
 import "core:unicode/utf8"
@@ -168,99 +169,12 @@ read_ptr :: proc(fd: Handle, data: rawptr, len: int) -> (int, Errno) {
 	return read(fd, s)
 }
 
-heap_allocator_proc :: proc(allocator_data: rawptr, mode: mem.Allocator_Mode,
+heap_allocator_proc :: runtime.heap_allocator_proc
-                            size, alignment: int,
+heap_allocator :: runtime.heap_allocator
-                            old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, mem.Allocator_Error) {
-	//
-	// NOTE(tetra, 2020-01-14): The heap doesn't respect alignment.
-	// Instead, we overallocate by `alignment + size_of(rawptr) - 1`, and insert
-	// padding. We also store the original pointer returned by heap_alloc right before
-	// the pointer we return to the user.
-	//
 
-	aligned_alloc :: proc(size, alignment: int, old_ptr: rawptr = nil, zero_memory := true) -> ([]byte, mem.Allocator_Error) {
+heap_alloc  :: runtime.heap_alloc
-		a := max(alignment, align_of(rawptr))
+heap_resize :: runtime.heap_resize
-		space := size + a - 1
+heap_free   :: runtime.heap_free
-
-		allocated_mem: rawptr
-		if old_ptr != nil {
-			original_old_ptr := mem.ptr_offset((^rawptr)(old_ptr), -1)^
-			allocated_mem = heap_resize(original_old_ptr, space+size_of(rawptr))
-		} else {
-			allocated_mem = heap_alloc(space+size_of(rawptr), zero_memory)
-		}
-		aligned_mem := rawptr(mem.ptr_offset((^u8)(allocated_mem), size_of(rawptr)))
-
-		ptr := uintptr(aligned_mem)
-		aligned_ptr := (ptr - 1 + uintptr(a)) & -uintptr(a)
-		diff := int(aligned_ptr - ptr)
-		if (size + diff) > space || allocated_mem == nil {
-			return nil, .Out_Of_Memory
-		}
-
-		aligned_mem = rawptr(aligned_ptr)
-		mem.ptr_offset((^rawptr)(aligned_mem), -1)^ = allocated_mem
-
-		return mem.byte_slice(aligned_mem, size), nil
-	}
-
-	aligned_free :: proc(p: rawptr) {
-		if p != nil {
-			heap_free(mem.ptr_offset((^rawptr)(p), -1)^)
-		}
-	}
-
-	aligned_resize :: proc(p: rawptr, old_size: int, new_size: int, new_alignment: int, zero_memory := true) -> (new_memory: []byte, err: mem.Allocator_Error) {
-		if p == nil {
-			return nil, nil
-		}
-
-		new_memory = aligned_alloc(new_size, new_alignment, p, zero_memory) or_return
-
-		// NOTE: heap_resize does not zero the new memory, so we do it
-		if zero_memory && new_size > old_size {
-			new_region := mem.raw_data(new_memory[old_size:])
-			mem.zero(new_region, new_size - old_size)
-		}
-		return
-	}
-
-	switch mode {
-	case .Alloc, .Alloc_Non_Zeroed:
-		return aligned_alloc(size, alignment, nil, mode == .Alloc)
-
-	case .Free:
-		aligned_free(old_memory)
-
-	case .Free_All:
-		return nil, .Mode_Not_Implemented
-
-	case .Resize, .Resize_Non_Zeroed:
-		if old_memory == nil {
-			return aligned_alloc(size, alignment, nil, mode == .Resize)
-		}
-		return aligned_resize(old_memory, old_size, size, alignment, mode == .Resize)
-
-	case .Query_Features:
-		set := (^mem.Allocator_Mode_Set)(old_memory)
-		if set != nil {
-			set^ = {.Alloc, .Alloc_Non_Zeroed, .Free, .Resize, .Resize_Non_Zeroed, .Query_Features}
-		}
-		return nil, nil
-
-	case .Query_Info:
-		return nil, .Mode_Not_Implemented
-	}
-
-	return nil, nil
-}
-
-heap_allocator :: proc() -> mem.Allocator {
-	return mem.Allocator{
-		procedure = heap_allocator_proc,
-		data = nil,
-	}
-}
 
 processor_core_count :: proc() -> int {
 	return _processor_core_count()

core/os/os_darwin.odin

@@ -859,25 +859,6 @@ access :: proc(path: string, mask: int) -> bool {
 	return _unix_access(cstr, mask) == 0
 }
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	if size <= 0 {
-		return nil
-	}
-	if zero_memory {
-		return _unix_calloc(1, size)
-	} else {
-		return _unix_malloc(size)
-	}
-}
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
-	// POSIX platforms. Ensure your caller takes this into account.
-	return _unix_realloc(ptr, new_size)
-}
-heap_free :: proc(ptr: rawptr) {
-	_unix_free(ptr)
-}
-
 lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)

core/os/os_freebsd.odin

@@ -617,27 +617,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) {
 	return true, ERROR_NONE
 }
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	if size <= 0 {
-		return nil
-	}
-	if zero_memory {
-		return _unix_calloc(1, c.size_t(size))
-	} else {
-		return _unix_malloc(c.size_t(size))
-	}
-}
-
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
-	// POSIX platforms. Ensure your caller takes this into account.
-	return _unix_realloc(ptr, c.size_t(new_size))
-}
-
-heap_free :: proc(ptr: rawptr) {
-	_unix_free(ptr)
-}
-
 lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 

core/os/os_js.odin

@@ -237,17 +237,6 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
 }
 
 
-
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	unimplemented("core:os procedure not supported on JS target")
-}
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	unimplemented("core:os procedure not supported on JS target")
-}
-heap_free :: proc(ptr: rawptr) {
-	unimplemented("core:os procedure not supported on JS target")
-}
-
 get_page_size :: proc() -> int {
 	unimplemented("core:os procedure not supported on JS target")
 }

core/os/os_linux.odin

@@ -888,27 +888,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) {
 	return true, ERROR_NONE
 }
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	if size <= 0 {
-		return nil
-	}
-	if zero_memory {
-		return _unix_calloc(1, c.size_t(size))
-	} else {
-		return _unix_malloc(c.size_t(size))
-	}
-}
-
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
-	// POSIX platforms. Ensure your caller takes this into account.
-	return _unix_realloc(ptr, c.size_t(new_size))
-}
-
-heap_free :: proc(ptr: rawptr) {
-	_unix_free(ptr)
-}
-
 lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)

core/os/os_openbsd.odin

@@ -615,27 +615,6 @@ access :: proc(path: string, mask: int) -> (bool, Errno) {
 	return true, ERROR_NONE
 }
 
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	if size <= 0 {
-		return nil
-	}
-	if zero_memory {
-		return _unix_calloc(1, c.size_t(size))
-	} else {
-		return _unix_malloc(c.size_t(size))
-	}
-}
-
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	// NOTE: _unix_realloc doesn't guarantee new memory will be zeroed on
-	// POSIX platforms. Ensure your caller takes this into account.
-	return _unix_realloc(ptr, c.size_t(new_size))
-}
-
-heap_free :: proc(ptr: rawptr) {
-	_unix_free(ptr)
-}
-
 lookup_env :: proc(key: string, allocator := context.allocator) -> (value: string, found: bool) {
 	runtime.DEFAULT_TEMP_ALLOCATOR_TEMP_GUARD(ignore = context.temp_allocator == allocator)
 	path_str := strings.clone_to_cstring(key, context.temp_allocator)

core/os/os_wasi.odin

@@ -103,28 +103,6 @@ file_size :: proc(fd: Handle) -> (i64, Errno) {
 }
 
 
-
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	return nil
-}
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	if new_size == 0 {
-		heap_free(ptr)
-		return nil
-	}
-	if ptr == nil {
-		return heap_alloc(new_size)
-	}
-
-	return nil
-}
-heap_free :: proc(ptr: rawptr) {
-	if ptr == nil {
-		return
-	}
-}
-
-
 exit :: proc "contextless" (code: int) -> ! {
 	runtime._cleanup_runtime_contextless()
 	wasi.proc_exit(wasi.exitcode_t(code))

core/os/os_windows.odin

@@ -91,28 +91,6 @@ last_write_time_by_name :: proc(name: string) -> (File_Time, Errno) {
 }
 
 
-
-heap_alloc :: proc(size: int, zero_memory := true) -> rawptr {
-	return win32.HeapAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY if zero_memory else 0, uint(size))
-}
-heap_resize :: proc(ptr: rawptr, new_size: int) -> rawptr {
-	if new_size == 0 {
-		heap_free(ptr)
-		return nil
-	}
-	if ptr == nil {
-		return heap_alloc(new_size)
-	}
-
-	return win32.HeapReAlloc(win32.GetProcessHeap(), win32.HEAP_ZERO_MEMORY, ptr, uint(new_size))
-}
-heap_free :: proc(ptr: rawptr) {
-	if ptr == nil {
-		return
-	}
-	win32.HeapFree(win32.GetProcessHeap(), 0, ptr)
-}
-
 get_page_size :: proc() -> int {
 	// NOTE(tetra): The page size never changes, so why do anything complicated
 	// if we don't have to.