Reorganize code to improve code generation

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 {

core/runtime/default_temporary_allocator.odin

@@ -37,138 +37,155 @@ default_temp_allocator_destroy :: proc(s: ^Default_Temp_Allocator) {
 	s^ = {};
 }
 
-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) {
+@(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);
 
-	s := (^Default_Temp_Allocator)(allocator_data);
+	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);
 
-	if s.data == nil {
-		default_temp_allocator_init(s, DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, default_allocator());
+		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;
 	}
 
-	size := size;
+	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);
 
-	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;
+	// 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);
 		}
+	}
 
-		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);
+	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;
+	}
 
-		// 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);
+	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");
+}
 
-		return data, .None;
+@(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);
+}
 
-	case .Free:
-		if old_memory == nil {
-			return nil, .None;
+@(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;
+}
 
-		start := uintptr(raw_data(s.data));
-		end := start + uintptr(len(s.data));
-		old_ptr := uintptr(old_memory);
+default_temp_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode,
+                                    size, alignment: int,
+                                    old_memory: rawptr, old_size: int, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
 
-		if s.prev_allocation == old_memory {
-			s.curr_offset = int(uintptr(s.prev_allocation) - start);
-			s.prev_allocation = nil;
-			return nil, .None;
-		}
+	s := (^Default_Temp_Allocator)(allocator_data);
 
-		if start <= old_ptr && old_ptr < end {
-			// NOTE(bill): Cannot free this pointer but it is valid
-			return nil, .None;
-		}
+	if s.data == nil {
+		default_temp_allocator_init(s, DEFAULT_TEMP_ALLOCATOR_BACKING_SIZE, default_allocator());
+	}
 
-		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");
+	switch mode {
+	case .Alloc:
+		data, err = default_temp_allocator_alloc(s, size, alignment, loc);
+	case .Free:
+		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 {

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));

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;
 	}

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);