diff --git a/core/runtime/core_builtin.odin b/core/runtime/core_builtin.odin index 6a7276b86..a74043f95 100644 --- a/core/runtime/core_builtin.odin +++ b/core/runtime/core_builtin.odin @@ -35,26 +35,26 @@ copy :: proc{copy_slice, copy_from_string}; @builtin -unordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) { +unordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) #no_bounds_check { bounds_check_error_loc(loc, index, len(array)); n := len(array)-1; if index != n { array[index] = array[n]; } - pop(array); + (^Raw_Dynamic_Array)(array).len -= 1; } @builtin -ordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) { +ordered_remove :: proc(array: ^$D/[dynamic]$T, index: int, loc := #caller_location) #no_bounds_check { bounds_check_error_loc(loc, index, len(array)); if index+1 < len(array) { copy(array[index:], array[index+1:]); } - pop(array); + (^Raw_Dynamic_Array)(array).len -= 1; } @builtin -remove_range :: proc(array: ^$D/[dynamic]$T, lo, hi: int, loc := #caller_location) { +remove_range :: proc(array: ^$D/[dynamic]$T, lo, hi: int, loc := #caller_location) #no_bounds_check { slice_expr_error_lo_hi_loc(loc, lo, hi, len(array)); n := max(hi-lo, 0); if n > 0 { diff --git a/core/runtime/default_temporary_allocator.odin b/core/runtime/default_temporary_allocator.odin index f5bad2a7d..ea545f26b 100644 --- a/core/runtime/default_temporary_allocator.odin +++ b/core/runtime/default_temporary_allocator.odin @@ -37,9 +37,125 @@ default_temp_allocator_destroy :: proc(s: ^Default_Temp_Allocator) { s^ = {}; } +@(private) +default_temp_allocator_alloc :: proc(s: ^Default_Temp_Allocator, size, alignment: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + size := size; + size = align_forward_int(size, alignment); + + switch { + case s.curr_offset+size <= len(s.data): + start := uintptr(raw_data(s.data)); + ptr := start + uintptr(s.curr_offset); + ptr = align_forward_uintptr(ptr, uintptr(alignment)); + mem_zero(rawptr(ptr), size); + + s.prev_allocation = rawptr(ptr); + offset := int(ptr - start); + s.curr_offset = offset + size; + return byte_slice(rawptr(ptr), size), .None; + + case size <= len(s.data): + start := uintptr(raw_data(s.data)); + ptr := align_forward_uintptr(start, uintptr(alignment)); + mem_zero(rawptr(ptr), size); + + s.prev_allocation = rawptr(ptr); + offset := int(ptr - start); + s.curr_offset = offset + size; + return byte_slice(rawptr(ptr), size), .None; + } + a := s.backup_allocator; + if a.procedure == nil { + a = context.allocator; + s.backup_allocator = a; + } + + data, err := mem_alloc_bytes(size, alignment, a, loc); + if err != nil { + return data, err; + } + if s.leaked_allocations == nil { + s.leaked_allocations = make([dynamic][]byte, a); + } + append(&s.leaked_allocations, data); + + // TODO(bill): Should leaks be notified about? + if logger := context.logger; logger.lowest_level <= .Warning { + if logger.procedure != nil { + logger.procedure(logger.data, .Warning, "default temp allocator resorted to backup_allocator" , logger.options, loc); + } + } + + return data, .None; +} + +@(private) +default_temp_allocator_free :: proc(s: ^Default_Temp_Allocator, old_memory: rawptr, loc := #caller_location) -> Allocator_Error { + if old_memory == nil { + return .None; + } + + start := uintptr(raw_data(s.data)); + end := start + uintptr(len(s.data)); + old_ptr := uintptr(old_memory); + + if s.prev_allocation == old_memory { + s.curr_offset = int(uintptr(s.prev_allocation) - start); + s.prev_allocation = nil; + return .None; + } + + if start <= old_ptr && old_ptr < end { + // NOTE(bill): Cannot free this pointer but it is valid + return .None; + } + + if len(s.leaked_allocations) != 0 { + for data, i in s.leaked_allocations { + ptr := raw_data(data); + if ptr == old_memory { + free(ptr, s.backup_allocator); + ordered_remove(&s.leaked_allocations, i); + return .None; + } + } + } + return .Invalid_Pointer; + // panic("invalid pointer passed to default_temp_allocator"); +} + +@(private) +default_temp_allocator_free_all :: proc(s: ^Default_Temp_Allocator, loc := #caller_location) { + s.curr_offset = 0; + s.prev_allocation = nil; + for data in s.leaked_allocations { + free(raw_data(data), s.backup_allocator); + } + clear(&s.leaked_allocations); +} + +@(private) +default_temp_allocator_resize :: proc(s: ^Default_Temp_Allocator, old_memory: rawptr, old_size, size, alignment: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + begin := uintptr(raw_data(s.data)); + end := begin + uintptr(len(s.data)); + old_ptr := uintptr(old_memory); + if old_memory == s.prev_allocation && old_ptr & uintptr(alignment)-1 == 0 { + if old_ptr+uintptr(size) < end { + s.curr_offset = int(old_ptr-begin)+size; + return byte_slice(old_memory, size), .None; + } + } + data, err := default_temp_allocator_alloc(s, size, alignment, loc); + if err == .None { + copy(data, byte_slice(old_memory, old_size)); + err = default_temp_allocator_free(s, old_memory, loc); + } + return data, err; +} + default_temp_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, - old_memory: rawptr, old_size: int, loc := #caller_location) -> ([]byte, Allocator_Error) { + old_memory: rawptr, old_size: int, loc := #caller_location) -> (data: []byte, err: Allocator_Error) { s := (^Default_Temp_Allocator)(allocator_data); @@ -47,128 +163,29 @@ default_temp_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode default_temp_allocator_init(s, DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, default_allocator()); } - size := size; - switch mode { case .Alloc: - size = align_forward_int(size, alignment); - - switch { - case s.curr_offset+size <= len(s.data): - start := uintptr(raw_data(s.data)); - ptr := start + uintptr(s.curr_offset); - ptr = align_forward_uintptr(ptr, uintptr(alignment)); - mem_zero(rawptr(ptr), size); - - s.prev_allocation = rawptr(ptr); - offset := int(ptr - start); - s.curr_offset = offset + size; - return byte_slice(rawptr(ptr), size), .None; - - case size <= len(s.data): - start := uintptr(raw_data(s.data)); - ptr := align_forward_uintptr(start, uintptr(alignment)); - mem_zero(rawptr(ptr), size); - - s.prev_allocation = rawptr(ptr); - offset := int(ptr - start); - s.curr_offset = offset + size; - return byte_slice(rawptr(ptr), size), .None; - } - a := s.backup_allocator; - if a.procedure == nil { - a = context.allocator; - s.backup_allocator = a; - } - - data, err := mem_alloc_bytes(size, alignment, a, loc); - if err != nil { - return data, err; - } - if s.leaked_allocations == nil { - s.leaked_allocations = make([dynamic][]byte, a); - } - append(&s.leaked_allocations, data); - - // TODO(bill): Should leaks be notified about? - if logger := context.logger; logger.lowest_level <= .Warning { - if logger.procedure != nil { - logger.procedure(logger.data, .Warning, "default temp allocator resorted to backup_allocator" , logger.options, loc); - } - } - - return data, .None; - + data, err = default_temp_allocator_alloc(s, size, alignment, loc); case .Free: - if old_memory == nil { - return nil, .None; - } - - start := uintptr(raw_data(s.data)); - end := start + uintptr(len(s.data)); - old_ptr := uintptr(old_memory); - - if s.prev_allocation == old_memory { - s.curr_offset = int(uintptr(s.prev_allocation) - start); - s.prev_allocation = nil; - return nil, .None; - } - - if start <= old_ptr && old_ptr < end { - // NOTE(bill): Cannot free this pointer but it is valid - return nil, .None; - } - - if len(s.leaked_allocations) != 0 { - for data, i in s.leaked_allocations { - ptr := raw_data(data); - if ptr == old_memory { - free(ptr, s.backup_allocator); - ordered_remove(&s.leaked_allocations, i); - return nil, .None; - } - } - } - return nil, .Invalid_Pointer; - // panic("invalid pointer passed to default_temp_allocator"); + err = default_temp_allocator_free(s, old_memory, loc); case .Free_All: - s.curr_offset = 0; - s.prev_allocation = nil; - for data in s.leaked_allocations { - free(raw_data(data), s.backup_allocator); - } - clear(&s.leaked_allocations); + default_temp_allocator_free_all(s, loc); case .Resize: - begin := uintptr(raw_data(s.data)); - end := begin + uintptr(len(s.data)); - old_ptr := uintptr(old_memory); - if old_memory == s.prev_allocation && old_ptr & uintptr(alignment)-1 == 0 { - if old_ptr+uintptr(size) < end { - s.curr_offset = int(old_ptr-begin)+size; - return byte_slice(old_memory, size), .None; - } - } - ptr, err := default_temp_allocator_proc(allocator_data, .Alloc, size, alignment, old_memory, old_size, loc); - if err == .None { - copy(ptr, byte_slice(old_memory, old_size)); - _, err = default_temp_allocator_proc(allocator_data, .Free, 0, alignment, old_memory, old_size, loc); - } - return ptr, err; + data, err = default_temp_allocator_resize(s, old_memory, old_size, size, alignment, loc); case .Query_Features: set := (^Allocator_Mode_Set)(old_memory); if set != nil { set^ = {.Alloc, .Free, .Free_All, .Resize, .Query_Features}; } - return nil, nil; case .Query_Info: - return nil, .None; + // Nothing to give } - return nil, .None; + return; } default_temp_allocator :: proc(allocator: ^Default_Temp_Allocator) -> Allocator { diff --git a/core/runtime/error_checks.odin b/core/runtime/error_checks.odin index b172ae9c8..3e4632215 100644 --- a/core/runtime/error_checks.odin +++ b/core/runtime/error_checks.odin @@ -22,7 +22,6 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index return; } handle_error :: proc "contextless" (file: string, line, column: i32, index, count: int) { - context = default_context(); print_caller_location(Source_Code_Location{file, line, column, ""}); print_string(" Index "); print_i64(i64(index)); @@ -35,7 +34,6 @@ bounds_check_error :: proc "contextless" (file: string, line, column: i32, index } slice_handle_error :: proc "contextless" (file: string, line, column: i32, lo, hi: int, len: int) -> ! { - context = default_context(); print_caller_location(Source_Code_Location{file, line, column, ""}); print_string(" Invalid slice indices: "); print_i64(i64(lo)); @@ -66,7 +64,6 @@ dynamic_array_expr_error :: proc "contextless" (file: string, line, column: i32, return; } handle_error :: proc "contextless" (file: string, line, column: i32, low, high, max: int) { - context = default_context(); print_caller_location(Source_Code_Location{file, line, column, ""}); print_string(" Invalid dynamic array values: "); print_i64(i64(low)); @@ -86,7 +83,6 @@ type_assertion_check :: proc "contextless" (ok: bool, file: string, line, column return; } handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid) { - context = default_context(); print_caller_location(Source_Code_Location{file, line, column, ""}); print_string(" Invalid type assertion from "); print_typeid(from); @@ -131,7 +127,6 @@ type_assertion_check2 :: proc "contextless" (ok: bool, file: string, line, colum } handle_error :: proc "contextless" (file: string, line, column: i32, from, to: typeid, from_data: rawptr) { - context = default_context(); actual := variant_type(from, from_data); @@ -156,7 +151,6 @@ make_slice_error_loc :: #force_inline proc "contextless" (loc := #caller_locatio return; } handle_error :: proc "contextless" (loc: Source_Code_Location, len: int) { - context = default_context(); print_caller_location(loc); print_string(" Invalid slice length for make: "); print_i64(i64(len)); @@ -171,7 +165,6 @@ make_dynamic_array_error_loc :: #force_inline proc "contextless" (using loc := # return; } handle_error :: proc "contextless" (loc: Source_Code_Location, len, cap: int) { - context = default_context(); print_caller_location(loc); print_string(" Invalid dynamic array parameters for make: "); print_i64(i64(len)); @@ -188,7 +181,6 @@ make_map_expr_error_loc :: #force_inline proc "contextless" (loc := #caller_loca return; } handle_error :: proc "contextless" (loc: Source_Code_Location, cap: int) { - context = default_context(); print_caller_location(loc); print_string(" Invalid map capacity for make: "); print_i64(i64(cap)); diff --git a/core/runtime/os_specific_windows.odin b/core/runtime/os_specific_windows.odin index 936ea9dbe..5ec8d6336 100644 --- a/core/runtime/os_specific_windows.odin +++ b/core/runtime/os_specific_windows.odin @@ -24,7 +24,7 @@ foreign kernel32 { HeapFree :: proc(hHeap: rawptr, dwFlags: u32, lpMem: rawptr) -> b32 --- } -_os_write :: proc "contextless" (data: []byte) -> (n: int, err: _OS_Errno) { +_os_write :: proc "contextless" (data: []byte) -> (n: int, err: _OS_Errno) #no_bounds_check { if len(data) == 0 { return 0, 0; } diff --git a/core/runtime/print.odin b/core/runtime/print.odin index e60d97103..fd756410a 100644 --- a/core/runtime/print.odin +++ b/core/runtime/print.odin @@ -86,7 +86,7 @@ print_encoded_rune :: proc "contextless" (r: rune) { print_byte('\''); } -print_rune :: proc "contextless" (r: rune) -> (int, _OS_Errno) { +print_rune :: proc "contextless" (r: rune) -> (int, _OS_Errno) #no_bounds_check { RUNE_SELF :: 0x80; if r < RUNE_SELF { @@ -98,7 +98,7 @@ print_rune :: proc "contextless" (r: rune) -> (int, _OS_Errno) { } -print_u64 :: proc "contextless" (x: u64) { +print_u64 :: proc "contextless" (x: u64) #no_bounds_check { digits := _INTEGER_DIGITS; a: [129]byte; @@ -115,7 +115,7 @@ print_u64 :: proc "contextless" (x: u64) { } -print_i64 :: proc "contextless" (x: i64) { +print_i64 :: proc "contextless" (x: i64) #no_bounds_check { digits := _INTEGER_DIGITS; b :: i64(10);