From 18c5a536856f9296610a3180a6356eeab61f5521 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:13:44 +0100 Subject: [PATCH] Add `@(require_results)` and `contextless` to procedures in `core:math/bits` --- core/math/bits/bits.odin | 231 ++++++++++++++++++++++++++------------- 1 file changed, 154 insertions(+), 77 deletions(-) diff --git a/core/math/bits/bits.odin b/core/math/bits/bits.odin index 850e8038a..959b5536f 100644 --- a/core/math/bits/bits.odin +++ b/core/math/bits/bits.odin @@ -37,68 +37,96 @@ overflowing_sub :: intrinsics.overflow_sub overflowing_mul :: intrinsics.overflow_mul -log2 :: proc(x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) { +@(require_results) +log2 :: proc "contextless" (x: $T) -> T where intrinsics.type_is_integer(T), intrinsics.type_is_unsigned(T) { return (8*size_of(T)-1) - count_leading_zeros(x) } -rotate_left8 :: proc(x: u8, k: int) -> u8 { +@(require_results) +rotate_left8 :: proc "contextless" (x: u8, k: int) -> u8 { n :: 8 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left16 :: proc(x: u16, k: int) -> u16 { +@(require_results) +rotate_left16 :: proc "contextless" (x: u16, k: int) -> u16 { n :: 16 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left32 :: proc(x: u32, k: int) -> u32 { +@(require_results) +rotate_left32 :: proc "contextless" (x: u32, k: int) -> u32 { n :: 32 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left64 :: proc(x: u64, k: int) -> u64 { +@(require_results) +rotate_left64 :: proc "contextless" (x: u64, k: int) -> u64 { n :: 64 s := uint(k) & (n-1) return x <>(n-s) } -rotate_left :: proc(x: uint, k: int) -> uint { +@(require_results) +rotate_left :: proc "contextless" (x: uint, k: int) -> uint { n :: 8*size_of(uint) s := uint(k) & (n-1) return x <>(n-s) } -from_be_u8 :: proc(i: u8) -> u8 { return i } -from_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +from_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +from_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -from_le_u8 :: proc(i: u8) -> u8 { return i } -from_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -from_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +from_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +from_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_be_u8 :: proc(i: u8) -> u8 { return i } -to_be_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_be_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +to_be_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } +@(require_results) +to_be_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Big { return i } else { return byte_swap(i) } } -to_le_u8 :: proc(i: u8) -> u8 { return i } -to_le_u16 :: proc(i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_u32 :: proc(i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_u64 :: proc(i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u8 :: proc "contextless" (i: u8) -> u8 { return i } +@(require_results) +to_le_u16 :: proc "contextless" (i: u16) -> u16 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u32 :: proc "contextless" (i: u32) -> u32 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_u64 :: proc "contextless" (i: u64) -> u64 { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } +@(require_results) +to_le_uint :: proc "contextless" (i: uint) -> uint { when ODIN_ENDIAN == .Little { return i } else { return byte_swap(i) } } -len_u8 :: proc(x: u8) -> int { +@(require_results) +len_u8 :: proc "contextless" (x: u8) -> int { return int(len_u8_table[x]) } -len_u16 :: proc(x: u16) -> (n: int) { +@(require_results) +len_u16 :: proc "contextless" (x: u16) -> (n: int) { x := x if x >= 1<<8 { x >>= 8 @@ -106,7 +134,8 @@ len_u16 :: proc(x: u16) -> (n: int) { } return n + int(len_u8_table[x]) } -len_u32 :: proc(x: u32) -> (n: int) { +@(require_results) +len_u32 :: proc "contextless" (x: u32) -> (n: int) { x := x if x >= 1<<16 { x >>= 16 @@ -118,7 +147,8 @@ len_u32 :: proc(x: u32) -> (n: int) { } return n + int(len_u8_table[x]) } -len_u64 :: proc(x: u64) -> (n: int) { +@(require_results) +len_u64 :: proc "contextless" (x: u64) -> (n: int) { x := x if x >= 1<<32 { x >>= 32 @@ -134,7 +164,8 @@ len_u64 :: proc(x: u64) -> (n: int) { } return n + int(len_u8_table[x]) } -len_uint :: proc(x: uint) -> (n: int) { +@(require_results) +len_uint :: proc "contextless" (x: uint) -> (n: int) { when size_of(uint) == size_of(u64) { return len_u64(u64(x)) } else { @@ -146,21 +177,24 @@ len_uint :: proc(x: uint) -> (n: int) { len :: proc{len_u8, len_u16, len_u32, len_u64, len_uint} -add_u32 :: proc(x, y, carry: u32) -> (sum, carry_out: u32) { +@(require_results) +add_u32 :: proc "contextless" (x, y, carry: u32) -> (sum, carry_out: u32) { tmp_carry, tmp_carry2: bool sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) carry_out = u32(tmp_carry | tmp_carry2) return } -add_u64 :: proc(x, y, carry: u64) -> (sum, carry_out: u64) { +@(require_results) +add_u64 :: proc "contextless" (x, y, carry: u64) -> (sum, carry_out: u64) { tmp_carry, tmp_carry2: bool sum, tmp_carry = intrinsics.overflow_add(x, y) sum, tmp_carry2 = intrinsics.overflow_add(sum, carry) carry_out = u64(tmp_carry | tmp_carry2) return } -add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) { +@(require_results) +add_uint :: proc "contextless" (x, y, carry: uint) -> (sum, carry_out: uint) { when size_of(uint) == size_of(u64) { a, b := add_u64(u64(x), u64(y), u64(carry)) } else { @@ -172,21 +206,24 @@ add_uint :: proc(x, y, carry: uint) -> (sum, carry_out: uint) { add :: proc{add_u32, add_u64, add_uint} -sub_u32 :: proc(x, y, borrow: u32) -> (diff, borrow_out: u32) { +@(require_results) +sub_u32 :: proc "contextless" (x, y, borrow: u32) -> (diff, borrow_out: u32) { tmp_borrow, tmp_borrow2: bool diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) borrow_out = u32(tmp_borrow | tmp_borrow2) return } -sub_u64 :: proc(x, y, borrow: u64) -> (diff, borrow_out: u64) { +@(require_results) +sub_u64 :: proc "contextless" (x, y, borrow: u64) -> (diff, borrow_out: u64) { tmp_borrow, tmp_borrow2: bool diff, tmp_borrow = intrinsics.overflow_sub(x, y) diff, tmp_borrow2 = intrinsics.overflow_sub(diff, borrow) borrow_out = u64(tmp_borrow | tmp_borrow2) return } -sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) { +@(require_results) +sub_uint :: proc "contextless" (x, y, borrow: uint) -> (diff, borrow_out: uint) { when size_of(uint) == size_of(u64) { a, b := sub_u64(u64(x), u64(y), u64(borrow)) } else { @@ -198,18 +235,21 @@ sub_uint :: proc(x, y, borrow: uint) -> (diff, borrow_out: uint) { sub :: proc{sub_u32, sub_u64, sub_uint} -mul_u32 :: proc(x, y: u32) -> (hi, lo: u32) { +@(require_results) +mul_u32 :: proc "contextless" (x, y: u32) -> (hi, lo: u32) { z := u64(x) * u64(y) hi, lo = u32(z>>32), u32(z) return } -mul_u64 :: proc(x, y: u64) -> (hi, lo: u64) { +@(require_results) +mul_u64 :: proc "contextless" (x, y: u64) -> (hi, lo: u64) { prod_wide := u128(x) * u128(y) hi, lo = u64(prod_wide>>64), u64(prod_wide) return } -mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { +@(require_results) +mul_uint :: proc "contextless" (x, y: uint) -> (hi, lo: uint) { when size_of(uint) == size_of(u32) { a, b := mul_u32(u32(x), u32(y)) } else { @@ -222,13 +262,15 @@ mul_uint :: proc(x, y: uint) -> (hi, lo: uint) { mul :: proc{mul_u32, mul_u64, mul_uint} -div_u32 :: proc(hi, lo, y: u32) -> (quo, rem: u32) { +@(require_results) +div_u32 :: proc "odin" (hi, lo, y: u32) -> (quo, rem: u32) { assert(y != 0 && y <= hi) z := u64(hi)<<32 | u64(lo) quo, rem = u32(z/u64(y)), u32(z%u64(y)) return } -div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) { +@(require_results) +div_u64 :: proc "odin" (hi, lo, y: u64) -> (quo, rem: u64) { y := y two32 :: 1 << 32 mask32 :: two32 - 1 @@ -273,7 +315,8 @@ div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) { return q1*two32 + q0, (un21*two32 + un0 - q0*y) >> s } -div_uint :: proc(hi, lo, y: uint) -> (quo, rem: uint) { +@(require_results) +div_uint :: proc "odin" (hi, lo, y: uint) -> (quo, rem: uint) { when size_of(uint) == size_of(u32) { a, b := div_u32(u32(hi), u32(lo), u32(y)) } else { @@ -286,16 +329,26 @@ div :: proc{div_u32, div_u64, div_uint} -is_power_of_two_u8 :: proc(i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i8 :: proc(i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u16 :: proc(i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i16 :: proc(i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u32 :: proc(i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i32 :: proc(i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_u64 :: proc(i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_i64 :: proc(i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_uint :: proc(i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 } -is_power_of_two_int :: proc(i: int) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u8 :: proc "contextless" (i: u8) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i8 :: proc "contextless" (i: i8) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u16 :: proc "contextless" (i: u16) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i16 :: proc "contextless" (i: i16) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u32 :: proc "contextless" (i: u32) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i32 :: proc "contextless" (i: i32) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_u64 :: proc "contextless" (i: u64) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_i64 :: proc "contextless" (i: i64) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_uint :: proc "contextless" (i: uint) -> bool { return i > 0 && (i & (i-1)) == 0 } +@(require_results) +is_power_of_two_int :: proc "contextless" (i: int) -> bool { return i > 0 && (i & (i-1)) == 0 } is_power_of_two :: proc{ is_power_of_two_u8, is_power_of_two_i8, @@ -320,44 +373,56 @@ len_u8_table := [256]u8{ } -bitfield_extract_u8 :: proc(value: u8, offset, bits: uint) -> u8 { return (value >> offset) & u8(1< u16 { return (value >> offset) & u16(1< u32 { return (value >> offset) & u32(1< u64 { return (value >> offset) & u64(1< u128 { return (value >> offset) & u128(1< uint { return (value >> offset) & uint(1< u8 { return (value >> offset) & u8(1< u16 { return (value >> offset) & u16(1< u32 { return (value >> offset) & u32(1< u64 { return (value >> offset) & u64(1< u128 { return (value >> offset) & u128(1< uint { return (value >> offset) & uint(1< i8 { +@(require_results) +bitfield_extract_i8 :: proc "contextless" (value: i8, offset, bits: uint) -> i8 { v := (u8(value) >> offset) & u8(1< i16 { +@(require_results) +bitfield_extract_i16 :: proc "contextless" (value: i16, offset, bits: uint) -> i16 { v := (u16(value) >> offset) & u16(1< i32 { +@(require_results) +bitfield_extract_i32 :: proc "contextless" (value: i32, offset, bits: uint) -> i32 { v := (u32(value) >> offset) & u32(1< i64 { +@(require_results) +bitfield_extract_i64 :: proc "contextless" (value: i64, offset, bits: uint) -> i64 { v := (u64(value) >> offset) & u64(1< i128 { +@(require_results) +bitfield_extract_i128 :: proc "contextless" (value: i128, offset, bits: uint) -> i128 { v := (u128(value) >> offset) & u128(1< int { +@(require_results) +bitfield_extract_int :: proc "contextless" (value: int, offset, bits: uint) -> int { v := (uint(value) >> offset) & uint(1< u8 { +@(require_results) +bitfield_insert_u8 :: proc "contextless" (base, insert: u8, offset, bits: uint) -> u8 { mask := u8(1< u16 { +@(require_results) +bitfield_insert_u16 :: proc "contextless" (base, insert: u16, offset, bits: uint) -> u16 { mask := u16(1< u32 { +@(require_results) +bitfield_insert_u32 :: proc "contextless" (base, insert: u32, offset, bits: uint) -> u32 { mask := u32(1< u64 { +@(require_results) +bitfield_insert_u64 :: proc "contextless" (base, insert: u64, offset, bits: uint) -> u64 { mask := u64(1< u128 { +@(require_results) +bitfield_insert_u128 :: proc "contextless" (base, insert: u128, offset, bits: uint) -> u128 { mask := u128(1< uint { +@(require_results) +bitfield_insert_uint :: proc "contextless" (base, insert: uint, offset, bits: uint) -> uint { mask := uint(1< i8 { +@(require_results) +bitfield_insert_i8 :: proc "contextless" (base, insert: i8, offset, bits: uint) -> i8 { mask := i8(1< i16 { +@(require_results) +bitfield_insert_i16 :: proc "contextless" (base, insert: i16, offset, bits: uint) -> i16 { mask := i16(1< i32 { +@(require_results) +bitfield_insert_i32 :: proc "contextless" (base, insert: i32, offset, bits: uint) -> i32 { mask := i32(1< i64 { +@(require_results) +bitfield_insert_i64 :: proc "contextless" (base, insert: i64, offset, bits: uint) -> i64 { mask := i64(1< i128 { +@(require_results) +bitfield_insert_i128 :: proc "contextless" (base, insert: i128, offset, bits: uint) -> i128 { mask := i128(1< int { +@(require_results) +bitfield_insert_int :: proc "contextless" (base, insert: int, offset, bits: uint) -> int { mask := int(1<