@salang/sa 0.1.2 → 0.1.4

package/sa_std/alloc/vec.sa

@@ -0,0 +1,684 @@
+@import "../core/mem.sa"
+@import "../core/slice.sal"
+@import "../core/slice.sa"
+@import "../num.sa"
+@import "vec.sal"
+
+@export sa_vec_new() -> ^ptr:
+    vec = alloc Vec_SIZE
+    store vec+Vec_ptr, 0 as ptr
+    store vec+Vec_cap, 0 as u64
+    store vec+Vec_len, 0 as u64
+    return vec
+
+@export sa_vec_with_capacity(cap: u64, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    vec = alloc Vec_SIZE
+    EXPAND NUM_U64_CHECKED_MUL bytes_ok, bytes, cap, elem_size
+    br bytes_ok -> L_SIZE_OK, L_SIZE_OVERFLOW
+L_SIZE_OVERFLOW:
+    panic(1201)
+L_SIZE_OK:
+    has_bytes = ne bytes, 0
+    br has_bytes -> L_ALLOC, L_EMPTY
+L_ALLOC:
+    buf = alloc bytes
+    call @sa_mem_set(&buf, 0, bytes)
+    store vec+Vec_ptr, buf as ptr
+    store vec+Vec_cap, cap as u64
+    store vec+Vec_len, 0 as u64
+    ^buf
+    !bytes
+    !bytes_ok
+    !has_bytes
+    !cap
+    return vec
+L_EMPTY:
+    store vec+Vec_ptr, 0 as ptr
+    store vec+Vec_cap, cap as u64
+    store vec+Vec_len, 0 as u64
+    !bytes
+    !bytes_ok
+    !has_bytes
+    !cap
+    return vec
+
+@export sa_vec_len(&vec: ptr) -> u64:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    !vec
+    return len
+
+@export sa_vec_capacity(&vec: ptr) -> u64:
+L_ENTRY:
+    cap = load vec+Vec_cap as u64
+    !vec
+    return cap
+
+@export sa_vec_is_empty(&vec: ptr) -> i32:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    empty = eq len, 0
+    result = empty as i32
+    !len
+    !vec
+    return result
+
+@export sa_vec_clear(&vec: ptr) -> void:
+L_ENTRY:
+    store vec+Vec_len, 0 as u64
+    !vec
+    return
+
+@export sa_vec_truncate(&vec: ptr, new_len: u64) -> void:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    should_shrink = ult new_len, len
+    br should_shrink -> L_TRUNCATE, L_DONE
+L_TRUNCATE:
+    store vec+Vec_len, new_len as u64
+    !should_shrink
+    !len
+    !new_len
+    !vec
+    return
+L_DONE:
+    !should_shrink
+    !len
+    !new_len
+    !vec
+    return
+
+@export sa_vec_reserve(^vec: ptr, additional: u64, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    cap = load vec+Vec_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD needed_ok, needed, len, additional
+    br needed_ok -> L_RESERVE_NEED_OK, L_RESERVE_OVERFLOW
+
+L_RESERVE_OVERFLOW:
+    panic(1202)
+
+L_RESERVE_NEED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_RESERVE_DONE, L_RESERVE_GROW
+
+L_RESERVE_GROW:
+    old_buf = take vec+Vec_ptr
+    EXPAND NUM_U64_CHECKED_MUL new_bytes_ok, new_bytes, needed, elem_size
+    br new_bytes_ok -> L_RESERVE_ALLOC, L_RESERVE_ALLOC_OVERFLOW
+
+L_RESERVE_ALLOC_OVERFLOW:
+    panic(1203)
+
+L_RESERVE_ALLOC:
+    new_buf = alloc new_bytes
+    call @sa_mem_set(&new_buf, 0, new_bytes)
+    EXPAND NUM_U64_CHECKED_MUL copy_bytes_ok, copy_bytes, len, elem_size
+    br copy_bytes_ok -> L_RESERVE_COPY, L_RESERVE_COPY_OVERFLOW
+
+L_RESERVE_COPY_OVERFLOW:
+    panic(1204)
+
+L_RESERVE_COPY:
+    call @sa_mem_copy(&new_buf, &old_buf, copy_bytes)
+    store vec+Vec_ptr, new_buf as ptr
+    store vec+Vec_cap, needed as u64
+    !copy_bytes_ok
+    !copy_bytes
+    !new_bytes_ok
+    !new_bytes
+    !old_buf
+    ^new_buf
+    !has_room
+    !needed
+    !needed_ok
+    !cap
+    !len
+    !elem_size
+    !additional
+    return vec
+
+L_RESERVE_DONE:
+    !has_room
+    !needed
+    !needed_ok
+    !cap
+    !len
+    !elem_size
+    !additional
+    return vec
+
+@export sa_vec_push(^vec: ptr, value: u64, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    buf = take vec+Vec_ptr
+    len = load vec+Vec_len as u64
+    cap = load vec+Vec_cap as u64
+    needs_grow = eq len, cap
+    br needs_grow -> L_GROW, L_REUSE
+L_GROW:
+    cap_is_zero = eq cap, 0
+    br cap_is_zero -> L_GROW_FROM_ZERO, L_GROW_DOUBLE
+
+L_GROW_FROM_ZERO:
+    next_cap = add 0, 1
+    next_cap_ok = add 0, 1
+    jmp L_GROW_ALLOC
+
+L_GROW_DOUBLE:
+    EXPAND NUM_U64_CHECKED_ADD next_cap_ok, next_cap, cap, cap
+    br next_cap_ok -> L_GROW_ALLOC, L_GROW_CAP_OVERFLOW
+
+L_GROW_CAP_OVERFLOW:
+    panic(1205)
+
+L_GROW_ALLOC:
+    EXPAND NUM_U64_CHECKED_MUL next_cap_bytes_ok, next_cap_bytes, next_cap, elem_size
+    br next_cap_bytes_ok -> L_GROW_COPY_SIZE, L_GROW_BYTES_OVERFLOW
+
+L_GROW_BYTES_OVERFLOW:
+    panic(1206)
+
+L_GROW_COPY_SIZE:
+    next_ptr = alloc next_cap_bytes
+    EXPAND NUM_U64_CHECKED_MUL copy_bytes_ok, copy_bytes, len, elem_size
+    br copy_bytes_ok -> L_GROW_COPY, L_GROW_COPY_OVERFLOW
+
+L_GROW_COPY_OVERFLOW:
+    panic(1207)
+
+L_GROW_COPY:
+    call @sa_mem_copy(&next_ptr, &buf, copy_bytes)
+    store vec+Vec_ptr, next_ptr as ptr
+    store vec+Vec_cap, next_cap as u64
+    jmp L_WRITE_GROW
+L_REUSE:
+    store vec+Vec_ptr, buf as ptr
+    jmp L_WRITE_REUSE
+L_WRITE_GROW:
+    write_off = mul len, elem_size
+    write_ptr = ptr_add next_ptr, write_off
+    store write_ptr+0, value as u64
+    next_len = add len, 1
+    store vec+Vec_len, next_len as u64
+    !write_ptr
+    !write_off
+    !next_len
+    !copy_bytes_ok
+    !copy_bytes
+    !next_cap_bytes_ok
+    !next_cap_bytes
+    !next_cap_ok
+    !next_cap
+    !cap_is_zero
+    !buf
+    !value
+    !elem_size
+    !cap
+    !len
+    !needs_grow
+    return vec
+L_WRITE_REUSE:
+    write_off = mul len, elem_size
+    write_ptr = ptr_add buf, write_off
+    store write_ptr+0, value as u64
+    next_len = add len, 1
+    store vec+Vec_len, next_len as u64
+    !write_ptr
+    !write_off
+    !next_len
+    !buf
+    !value
+    !elem_size
+    !cap
+    !len
+    !needs_grow
+    return vec
+
+@export sa_vec_try_pop(&vec: ptr, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    empty = eq len, 0
+    br empty -> L_EMPTY, L_READY
+L_READY:
+    buf = load vec+Vec_ptr as ptr
+    last_index = sub len, 1
+    last_off = mul last_index, 8
+    last_ptr = ptr_add buf, last_off
+    value = load last_ptr+0 as u64
+    next_len = sub len, 1
+    store out_value_slot+0, value as u64
+    store vec+Vec_len, next_len as u64
+    !last_ptr
+    !last_off
+    !last_index
+    !value
+    !next_len
+    !buf
+    !len
+    !empty
+    !out_value_slot
+    !vec
+    return 1
+L_EMPTY:
+    store out_value_slot+0, 0 as ptr
+    !len
+    !empty
+    !out_value_slot
+    !vec
+    return 0
+
+@export sa_vec_extend_from_slice(^vec: ptr, &slice: ptr, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    add_len = load slice+Slice_len as u64
+    add_zero = eq add_len, 0
+    br add_zero -> L_DONE, L_GROW
+
+L_GROW:
+    len = load vec+Vec_len as u64
+    cap = load vec+Vec_cap as u64
+    EXPAND NUM_U64_CHECKED_ADD needed_ok, needed, len, add_len
+    br needed_ok -> L_EXTEND_NEEDED_OK, L_EXTEND_NEEDED_OVERFLOW
+
+L_EXTEND_NEEDED_OVERFLOW:
+    panic(1208)
+
+L_EXTEND_NEEDED_OK:
+    has_room = uge cap, needed
+    br has_room -> L_COPY, L_REALLOC
+
+L_REALLOC:
+    old_buf = take vec+Vec_ptr
+    EXPAND NUM_U64_CHECKED_MUL new_bytes_ok, new_bytes, needed, elem_size
+    br new_bytes_ok -> L_EXTEND_ALLOC, L_EXTEND_ALLOC_OVERFLOW
+
+L_EXTEND_ALLOC_OVERFLOW:
+    panic(1209)
+
+L_EXTEND_ALLOC:
+    new_buf = alloc new_bytes
+    call @sa_mem_set(&new_buf, 0, new_bytes)
+    EXPAND NUM_U64_CHECKED_MUL copy_old_bytes_ok, copy_old_bytes, len, elem_size
+    br copy_old_bytes_ok -> L_EXTEND_COPY_OLD, L_EXTEND_COPY_OLD_OVERFLOW
+
+L_EXTEND_COPY_OLD_OVERFLOW:
+    panic(1210)
+
+L_EXTEND_COPY_OLD:
+    call @sa_mem_copy(&new_buf, &old_buf, copy_old_bytes)
+    store vec+Vec_ptr, new_buf as ptr
+    store vec+Vec_cap, needed as u64
+    ^new_buf
+    !copy_old_bytes_ok
+    !copy_old_bytes
+    !new_bytes_ok
+    !new_bytes
+    !old_buf
+
+L_COPY:
+    dst_buf = load vec+Vec_ptr as ptr
+    src_buf = load slice+Slice_ptr as ptr
+    EXPAND NUM_U64_CHECKED_MUL dst_off_ok, dst_off, len, elem_size
+    br dst_off_ok -> L_EXTEND_COPY_ADD_SIZE, L_EXTEND_DST_OVERFLOW
+
+L_EXTEND_DST_OVERFLOW:
+    panic(1211)
+
+L_EXTEND_COPY_ADD_SIZE:
+    dst_ptr = ptr_add dst_buf, dst_off
+    EXPAND NUM_U64_CHECKED_MUL copy_add_bytes_ok, copy_add_bytes, add_len, elem_size
+    br copy_add_bytes_ok -> L_EXTEND_COPY_ADD, L_EXTEND_COPY_ADD_OVERFLOW
+
+L_EXTEND_COPY_ADD_OVERFLOW:
+    panic(1212)
+
+L_EXTEND_COPY_ADD:
+    call @sa_mem_copy(&dst_ptr, &src_buf, copy_add_bytes)
+    store vec+Vec_len, needed as u64
+    !copy_add_bytes_ok
+    !copy_add_bytes
+    !dst_ptr
+    !dst_off_ok
+    !dst_off
+    !src_buf
+    !dst_buf
+    !has_room
+    !needed
+    !needed_ok
+    !cap
+    !len
+    !add_len
+    !add_zero
+    !elem_size
+    !slice
+    return vec
+
+L_DONE:
+    !add_len
+    !add_zero
+    !elem_size
+    !slice
+    return vec
+
+@export sa_vec_append(^dst_vec: ptr, &src_vec: ptr, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    src_slice = alloc Slice_SIZE
+    src_ptr = load src_vec+Vec_ptr as ptr
+    src_len = load src_vec+Vec_len as u64
+    EXPAND SLICE_NEW src_slice, src_ptr, src_len
+    dst_vec = call @sa_vec_extend_from_slice(^dst_vec, &src_slice, elem_size)
+    store src_vec+Vec_len, 0 as u64
+    !src_slice
+    !src_ptr
+    !src_len
+    !elem_size
+    !src_vec
+    return dst_vec
+
+@export sa_vec_try_swap_remove(&vec: ptr, index: u64, &out_value_slot: ptr) -> i32:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    in_bounds = ult index, len
+    br in_bounds -> L_READY, L_MISS
+
+L_READY:
+    buf = load vec+Vec_ptr as ptr
+    last_index = sub len, 1
+    remove_off = mul index, 8
+    remove_ptr = ptr_add buf, remove_off
+    removed = load remove_ptr+0 as u64
+    last_off = mul last_index, 8
+    last_ptr = ptr_add buf, last_off
+    last_value = load last_ptr+0 as u64
+    store remove_ptr+0, last_value as u64
+    next_len = sub len, 1
+    store out_value_slot+0, removed as u64
+    store vec+Vec_len, next_len as u64
+    !next_len
+    !last_value
+    !last_ptr
+    !last_off
+    !removed
+    !remove_ptr
+    !remove_off
+    !last_index
+    !buf
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !vec
+    return 1
+
+L_MISS:
+    store out_value_slot+0, 0 as ptr
+    !in_bounds
+    !len
+    !index
+    !out_value_slot
+    !vec
+    return 0
+
+@export sa_vec_try_remove(&vec: ptr, index: u64, &out_value_slot: ptr, elem_size: u64) -> i32:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    in_bounds = ult index, len
+    br in_bounds -> L_READY, L_MISS
+
+L_READY:
+    buf = load vec+Vec_ptr as ptr
+    remove_off = mul index, elem_size
+    remove_ptr = ptr_add buf, remove_off
+    removed = load remove_ptr+0 as u64
+    trailing = sub len, index
+    trailing_after = sub trailing, 1
+    move_bytes = mul trailing_after, elem_size
+    move_zero = eq move_bytes, 0
+    br move_zero -> L_STORE_RESULT, L_SHIFT_INIT
+
+L_SHIFT_INIT:
+    src_ptr = ptr_add remove_ptr, elem_size
+    move_off_slot = stack_alloc 8
+    store move_off_slot+0, 0 as u64
+    jmp L_SHIFT_HEAD
+
+L_SHIFT_HEAD:
+    move_off = load move_off_slot+0 as u64
+    done = eq move_off, move_bytes
+    br done -> L_STORE_RESULT, L_SHIFT_BODY
+
+L_SHIFT_BODY:
+    src_byte_ptr = ptr_add src_ptr, move_off
+    dst_byte_ptr = ptr_add remove_ptr, move_off
+    byte = load src_byte_ptr+0 as u8
+    store dst_byte_ptr+0, byte as u8
+    next_move_off = add move_off, 1
+    store move_off_slot+0, next_move_off as u64
+    !next_move_off
+    !byte
+    !dst_byte_ptr
+    !src_byte_ptr
+    !done
+    !move_off
+    jmp L_SHIFT_HEAD
+
+L_STORE_RESULT:
+    next_len = sub len, 1
+    store out_value_slot+0, removed as u64
+    store vec+Vec_len, next_len as u64
+    !next_len
+    !move_zero
+    !move_bytes
+    !trailing_after
+    !trailing
+    !removed
+    !remove_ptr
+    !remove_off
+    !buf
+    !in_bounds
+    !len
+    !elem_size
+    !index
+    !out_value_slot
+    !vec
+    return 1
+
+L_MISS:
+    store out_value_slot+0, 0 as ptr
+    !in_bounds
+    !len
+    !elem_size
+    !index
+    !out_value_slot
+    !vec
+    return 0
+
+@export sa_vec_try_split_off(^vec: ptr, index: u64, elem_size: u64, &out_vec_slot: ptr) -> ^ptr:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    in_bounds = ule index, len
+    br in_bounds -> L_READY, L_MISS
+
+L_READY:
+    tail_len = sub len, index
+    out_vec = call @sa_vec_with_capacity(tail_len, elem_size)
+    tail_zero = eq tail_len, 0
+    br tail_zero -> L_STORE_VEC, L_COPY_TAIL
+
+L_COPY_TAIL:
+    src_buf = load vec+Vec_ptr as ptr
+    src_off = mul index, elem_size
+    src_ptr = ptr_add src_buf, src_off
+    dst_buf = load out_vec+Vec_ptr as ptr
+    copy_bytes = mul tail_len, elem_size
+    call @sa_mem_copy(&dst_buf, &src_ptr, copy_bytes)
+    !copy_bytes
+    !dst_buf
+    !src_ptr
+    !src_off
+    !src_buf
+
+L_STORE_VEC:
+    store out_vec+Vec_len, tail_len as u64
+    store vec+Vec_len, index as u64
+    store out_vec_slot+0, out_vec as ptr
+    !tail_zero
+    !tail_len
+    !out_vec
+    !in_bounds
+    !len
+    !elem_size
+    !index
+    !out_vec_slot
+    return vec
+
+L_MISS:
+    store out_vec_slot+0, 0 as ptr
+    !in_bounds
+    !len
+    !elem_size
+    !index
+    !out_vec_slot
+    return vec
+
+@export sa_vec_shrink_to(^vec: ptr, min_cap: u64, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    cap = load vec+Vec_cap as u64
+    keep_len = uge len, min_cap
+    br keep_len -> L_TARGET_LEN, L_TARGET_MIN
+
+L_TARGET_LEN:
+    target_cap = add len, 0
+    jmp L_CHECK
+
+L_TARGET_MIN:
+    target_cap = add min_cap, 0
+
+L_CHECK:
+    needs_shrink = ult target_cap, cap
+    br needs_shrink -> L_SHRINK, L_DONE
+
+L_SHRINK:
+    target_zero = eq target_cap, 0
+    br target_zero -> L_ZERO, L_ALLOC
+
+L_ZERO:
+    store vec+Vec_ptr, 0 as ptr
+    store vec+Vec_cap, 0 as u64
+    !target_zero
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !elem_size
+    !min_cap
+    return vec
+
+L_ALLOC:
+    old_buf = take vec+Vec_ptr
+    EXPAND NUM_U64_CHECKED_MUL shrink_new_bytes_ok, new_bytes, target_cap, elem_size
+    br shrink_new_bytes_ok -> L_SHRINK_ALLOC, L_SHRINK_ALLOC_OVERFLOW
+
+L_SHRINK_ALLOC_OVERFLOW:
+    panic(1213)
+
+L_SHRINK_ALLOC:
+    new_buf = alloc new_bytes
+    call @sa_mem_set(&new_buf, 0, new_bytes)
+    EXPAND NUM_U64_CHECKED_MUL shrink_copy_bytes_ok, copy_bytes, len, elem_size
+    br shrink_copy_bytes_ok -> L_SHRINK_COPY, L_SHRINK_COPY_OVERFLOW
+
+L_SHRINK_COPY_OVERFLOW:
+    panic(1214)
+
+L_SHRINK_COPY:
+    call @sa_mem_copy(&new_buf, &old_buf, copy_bytes)
+    store vec+Vec_ptr, new_buf as ptr
+    store vec+Vec_cap, target_cap as u64
+    !shrink_copy_bytes_ok
+    !copy_bytes
+    !shrink_new_bytes_ok
+    !new_bytes
+    !old_buf
+    ^new_buf
+    !target_zero
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !elem_size
+    !min_cap
+    return vec
+
+L_DONE:
+    !needs_shrink
+    !target_cap
+    !keep_len
+    !cap
+    !len
+    !elem_size
+    !min_cap
+    return vec
+
+@export sa_vec_shrink_to_fit(^vec: ptr, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    vec = call @sa_vec_shrink_to(^vec, len, elem_size)
+    !len
+    return vec
+
+@export sa_vec_resize(^vec: ptr, new_len: u64, fill_value: u64, elem_size: u64) -> ^ptr:
+L_ENTRY:
+    len = load vec+Vec_len as u64
+    should_shrink = ule new_len, len
+    br should_shrink -> L_SHRINK, L_GROW
+
+L_SHRINK:
+    store vec+Vec_len, new_len as u64
+    !should_shrink
+    !len
+    !fill_value
+    !elem_size
+    !new_len
+    return vec
+
+L_GROW:
+    additional = sub new_len, len
+    vec = call @sa_vec_reserve(^vec, additional, elem_size)
+    remaining_slot = stack_alloc 8
+    store remaining_slot+0, additional as u64
+    jmp L_GROW_HEAD
+
+L_GROW_HEAD:
+    remaining = load remaining_slot+0 as u64
+    done = eq remaining, 0
+    br done -> L_GROW_DONE, L_GROW_BODY
+
+L_GROW_BODY:
+    vec = call @sa_vec_push(^vec, fill_value, elem_size)
+    next_remaining = sub remaining, 1
+    store remaining_slot+0, next_remaining as u64
+    !next_remaining
+    !done
+    !remaining
+    jmp L_GROW_HEAD
+
+L_GROW_DONE:
+    !done
+    !remaining
+    !should_shrink
+    !additional
+    !len
+    !fill_value
+    !elem_size
+    !new_len
+    return vec
+
+@export sa_vec_free(^vec: ptr) -> void:
+    inner_ptr = take vec+Vec_ptr
+    !inner_ptr
+    !vec
+    return

package/sa_std/alloc/vec.sal

@@ -0,0 +1,4 @@
+#def Vec_SIZE = 24
+#def Vec_ptr  = +0
+#def Vec_cap  = +8
+#def Vec_len  = +16