#import "fmt.odin"; #import "os.odin"; set :: proc(data: rawptr, value: i32, len: int) -> rawptr #link_name "__mem_set" { llvm_memset_64bit :: proc(dst: rawptr, val: byte, len: int, align: i32, is_volatile: bool) #foreign "llvm.memset.p0i8.i64" llvm_memset_64bit(data, value as byte, len, 1, false); return data; } zero :: proc(data: rawptr, len: int) -> rawptr #link_name "__mem_zero" { return set(data, 0, len); } copy :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy" { // NOTE(bill): This _must_ implemented like C's memmove llvm_memmove_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memmove.p0i8.p0i8.i64" llvm_memmove_64bit(dst, src, len, 1, false); return dst; } copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "__mem_copy_non_overlapping" { // NOTE(bill): This _must_ implemented like C's memcpy llvm_memcpy_64bit :: proc(dst, src: rawptr, len: int, align: i32, is_volatile: bool) #foreign "llvm.memcpy.p0i8.p0i8.i64" llvm_memcpy_64bit(dst, src, len, 1, false); return dst; } compare :: proc(dst, src: rawptr, n: int) -> int #link_name "__mem_compare" { // Translation of http://mgronhol.github.io/fast-strcmp/ a := slice_ptr(dst as ^byte, n); b := slice_ptr(src as ^byte, n); fast := n/size_of(int) + 1; offset := (fast-1)*size_of(int); curr_block := 0; if n <= size_of(int) { fast = 0; } la := slice_ptr(^a[0] as ^int, fast); lb := slice_ptr(^b[0] as ^int, fast); for _ : curr_block ..< fast { if (la[curr_block] ~ lb[curr_block]) != 0 { for pos : curr_block*size_of(int) ..< n { if (a[pos] ~ b[pos]) != 0 { return a[pos] as int - b[pos] as int; } } } } for _ : offset ..< n { if (a[offset] ~ b[offset]) != 0 { return a[offset] as int - b[offset] as int; } } return 0; } kilobytes :: proc(x: int) -> int #inline { return (x) * 1024; } megabytes :: proc(x: int) -> int #inline { return kilobytes(x) * 1024; } gigabytes :: proc(x: int) -> int #inline { return gigabytes(x) * 1024; } terabytes :: proc(x: int) -> int #inline { return terabytes(x) * 1024; } is_power_of_two :: proc(x: int) -> bool { if x <= 0 { return false; } return (x & (x-1)) == 0; } align_forward :: proc(ptr: rawptr, align: int) -> rawptr { assert(is_power_of_two(align)); a := align as uint; p := ptr as uint; modulo := p & (a-1); if modulo != 0 { p += a - modulo; } return p as rawptr; } Allocation_Header :: struct { size: int; } allocation_header_fill :: proc(header: ^Allocation_Header, data: rawptr, size: int) { header.size = size; ptr := (header+1) as ^int; while i := 0; ptr as rawptr < data { (ptr+i)^ = -1; i += 1; } } allocation_header :: proc(data: rawptr) -> ^Allocation_Header { p := data as ^int; while (p-1)^ == -1 { p = (p-1); } return (p as ^Allocation_Header)-1; } // Custom allocators Arena :: struct { backing: Allocator; offset: int; memory: []byte; temp_count: int; } Arena_Temp_Memory :: struct { arena: ^Arena; original_count: int; } init_arena_from_memory :: proc(using a: ^Arena, data: []byte) { backing = Allocator{}; memory = data[:0]; temp_count = 0; } init_arena_from_context :: proc(using a: ^Arena, size: int) { backing = context.allocator; memory = new_slice(byte, size); temp_count = 0; } free_arena :: proc(using a: ^Arena) { if backing.procedure != nil { push_allocator backing { free(memory.data); memory = memory[0:0]; offset = 0; } } } arena_allocator :: proc(arena: ^Arena) -> Allocator { return Allocator{ procedure = arena_allocator_proc, data = arena, }; } arena_allocator_proc :: proc(allocator_data: rawptr, mode: Allocator_Mode, size, alignment: int, old_memory: rawptr, old_size: int, flags: u64) -> rawptr { using Allocator_Mode; arena := allocator_data as ^Arena; match mode { case ALLOC: total_size := size + alignment; if arena.offset + total_size > arena.memory.count { fmt.fprintln(os.stderr, "Arena out of memory"); return nil; } #no_bounds_check end := ^arena.memory[arena.offset]; ptr := align_forward(end, alignment); arena.offset += total_size; return zero(ptr, size); case FREE: // NOTE(bill): Free all at once // Use Arena_Temp_Memory if you want to free a block case FREE_ALL: arena.offset = 0; case RESIZE: return default_resize_align(old_memory, old_size, size, alignment); } return nil; } begin_arena_temp_memory :: proc(a: ^Arena) -> Arena_Temp_Memory { tmp: Arena_Temp_Memory; tmp.arena = a; tmp.original_count = a.memory.count; a.temp_count += 1; return tmp; } end_arena_temp_memory :: proc(using tmp: Arena_Temp_Memory) { assert(arena.memory.count >= original_count); assert(arena.temp_count > 0); arena.memory.count = original_count; arena.temp_count -= 1; } align_of_type_info :: proc(type_info: ^Type_Info) -> int { prev_pow2 :: proc(n: i64) -> i64 { if n <= 0 { return 0; } n |= n >> 1; n |= n >> 2; n |= n >> 4; n |= n >> 8; n |= n >> 16; n |= n >> 32; return n - (n >> 1); } WORD_SIZE :: size_of(int); MAX_ALIGN :: size_of([vector 64]f64); // TODO(bill): Should these constants be builtin constants? using Type_Info; match type info : type_info { case Named: return align_of_type_info(info.base); case Integer: return info.size; case Float: return info.size; case String: return WORD_SIZE; case Boolean: return 1; case Pointer: return WORD_SIZE; case Maybe: return max(align_of_type_info(info.elem), 1); case Procedure: return WORD_SIZE; case Array: return align_of_type_info(info.elem); case Slice: return WORD_SIZE; case Vector: size := size_of_type_info(info.elem); count := max(prev_pow2(info.count as i64), 1) as int; total := size * count; return clamp(total, 1, MAX_ALIGN); case Struct: return info.align; case Union: return info.align; case Raw_Union: return info.align; } return 0; } align_formula :: proc(size, align: int) -> int { result := size + align-1; return result - result%align; } size_of_type_info :: proc(type_info: ^Type_Info) -> int { WORD_SIZE :: size_of(int); using Type_Info; match type info : type_info { case Named: return size_of_type_info(info.base); case Integer: return info.size; case Float: return info.size; case Any: return 2*WORD_SIZE; case String: return 2*WORD_SIZE; case Boolean: return 1; case Pointer: return WORD_SIZE; case Maybe: return size_of_type_info(info.elem) + 1; case Procedure: return WORD_SIZE; case Array: count := info.count; if count == 0 { return 0; } size := size_of_type_info(info.elem); align := align_of_type_info(info.elem); alignment := align_formula(size, align); return alignment*(count-1) + size; case Slice: return 3*WORD_SIZE; case Vector: is_bool :: proc(type_info: ^Type_Info) -> bool { match type info : type_info { case Named: return is_bool(info.base); case Boolean: return true; } return false; } count := info.count; if count == 0 { return 0; } bit_size := 8*size_of_type_info(info.elem); if is_bool(info.elem) { // NOTE(bill): LLVM can store booleans as 1 bit because a boolean _is_ an `i1` // Silly LLVM spec bit_size = 1; } total_size_in_bits := bit_size * count; total_size := (total_size_in_bits+7)/8; return total_size; case Struct: return info.size; case Union: return info.size; case Raw_Union: return info.size; } return 0; }