Add `intrinsics.count_zeros`

core/math/bits/bits.odin

@@ -24,68 +24,18 @@ I32_MAX :: 1 << 31 - 1;
 I64_MAX :: 1 << 63 - 1;
 
 
-count_ones     :: intrinsics.count_ones;
-trailing_zeros :: intrinsics.count_trailing_zeros;
-leading_zeros  :: intrinsics.count_leading_zeros;
+count_ones           :: intrinsics.count_ones;
+count_zeros          :: intrinsics.count_zeros;
+trailing_zeros       :: intrinsics.count_trailing_zeros;
+leading_zeros        :: intrinsics.count_leading_zeros;
 count_trailing_zeros :: intrinsics.count_trailing_zeros;
 count_leading_zeros  :: intrinsics.count_leading_zeros;
-reverse_bits   :: intrinsics.reverse_bits;
-byte_swap :: intrinsics.byte_swap;
+reverse_bits         :: intrinsics.reverse_bits;
+byte_swap            :: intrinsics.byte_swap;
 
-
-
-byte_swap_u16 :: proc(x: u16) -> u16 {
-	return runtime.bswap_16(x);
-}
-byte_swap_u32 :: proc(x: u32) -> u32 {
-	return runtime.bswap_32(x);
-}
-byte_swap_u64 :: proc(x: u64) -> u64 {
-	return runtime.bswap_64(x);
-}
-byte_swap_i16 :: proc(x: i16) -> i16 {
-	return i16(runtime.bswap_16(u16(x)));
-}
-byte_swap_i32 :: proc(x: i32) -> i32 {
-	return i32(runtime.bswap_32(u32(x)));
-}
-byte_swap_i64 :: proc(x: i64) -> i64 {
-	return i64(runtime.bswap_64(u64(x)));
-}
-byte_swap_u128 :: proc(x: u128) -> u128 {
-	return runtime.bswap_128(x);
-}
-byte_swap_i128 :: proc(x: i128) -> i128 {
-	return i128(runtime.bswap_128(u128(x)));
-}
-
-byte_swap_uint :: proc(i: uint) -> uint {
-	when size_of(uint) == size_of(u32) {
-		return uint(byte_swap_u32(u32(i)));
-	} else {
-		return uint(byte_swap_u64(u64(i)));
-	}
-}
-byte_swap_int :: proc(i: int) -> int {
-	when size_of(int) == size_of(i32) {
-		return int(byte_swap_i32(i32(i)));
-	} else {
-		return int(byte_swap_i64(i64(i)));
-	}
-}
-
-
-count_zeros8   :: proc(i:   u8) ->   u8 { return   8 - count_ones(i); }
-count_zeros16  :: proc(i:  u16) ->  u16 { return  16 - count_ones(i); }
-count_zeros32  :: proc(i:  u32) ->  u32 { return  32 - count_ones(i); }
-count_zeros64  :: proc(i:  u64) ->  u64 { return  64 - count_ones(i); }
-
-count_zeros :: proc{
-	count_zeros8,
-	count_zeros16,
-	count_zeros32,
-	count_zeros64,
-};
+overflowing_add :: intrinsics.overflow_add;
+overflowing_sub :: intrinsics.overflow_sub;
+overflowing_mul :: intrinsics.overflow_mul;
 
 
 rotate_left8 :: proc(x: u8,  k: int) -> u8 {
@@ -142,11 +92,6 @@ to_le_uint :: proc(i: uint) -> uint { when ODIN_ENDIAN == "little" { return i; }
 
 
 
-overflowing_add :: intrinsics.overflow_add;
-overflowing_sub :: intrinsics.overflow_sub;
-overflowing_mul :: intrinsics.overflow_mul;
-
-
 len_u8 :: proc(x: u8) -> int {
 	return int(len_u8_table[x]);
 }

src/check_builtin.cpp

@@ -1923,6 +1923,7 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 		break;
 
 	case BuiltinProc_count_ones:
+	case BuiltinProc_count_zeros:
 	case BuiltinProc_count_trailing_zeros:
 	case BuiltinProc_count_leading_zeros:
 	case BuiltinProc_reverse_bits:

src/checker_builtin_procs.hpp

@@ -46,6 +46,7 @@ enum BuiltinProcId {
 	BuiltinProc_read_cycle_counter,
 
 	BuiltinProc_count_ones,
+	BuiltinProc_count_zeros,
 	BuiltinProc_count_trailing_zeros,
 	BuiltinProc_count_leading_zeros,
 	BuiltinProc_reverse_bits,
@@ -265,6 +266,7 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT("read_cycle_counter"), 0, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 
 	{STR_LIT("count_ones"),           1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
+	{STR_LIT("count_zeros"),          1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("count_trailing_zeros"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("count_leading_zeros"),  1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("reverse_bits"),         1, false, Expr_Expr, BuiltinProcPkg_intrinsics},

src/llvm_backend.cpp

@@ -9113,6 +9113,8 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 
 	case BuiltinProc_count_ones:
 		return lb_emit_count_ones(p, lb_build_expr(p, ce->args[0]), tv.type);
+	case BuiltinProc_count_zeros:
+		return lb_emit_count_zeros(p, lb_build_expr(p, ce->args[0]), tv.type);
 
 	case BuiltinProc_reverse_bits:
 		return lb_emit_reverse_bits(p, lb_build_expr(p, ce->args[0]), tv.type);
@@ -9971,6 +9973,14 @@ lbValue lb_emit_count_ones(lbProcedure *p, lbValue x, Type *type) {
 	return res;
 }
 
+lbValue lb_emit_count_zeros(lbProcedure *p, lbValue x, Type *type) {
+	i64 sz = 8*type_size_of(type);
+	lbValue size = lb_const_int(p->module, type, cast(u64)sz);
+	lbValue count = lb_emit_count_ones(p, x, type);
+	return lb_emit_arith(p, Token_Sub, size, count, type);
+}
+
+
 
 lbValue lb_emit_count_trailing_zeros(lbProcedure *p, lbValue x, Type *type) {
 	x = lb_emit_conv(p, x, type);

src/llvm_backend.hpp

@@ -395,6 +395,7 @@ lbValue lb_emit_conv(lbProcedure *p, lbValue value, Type *t);
 LLVMMetadataRef lb_debug_type(lbModule *m, Type *type);
 
 lbValue lb_emit_count_ones(lbProcedure *p, lbValue x, Type *type);
+lbValue lb_emit_count_zeros(lbProcedure *p, lbValue x, Type *type);
 lbValue lb_emit_count_trailing_zeros(lbProcedure *p, lbValue x, Type *type);
 lbValue lb_emit_count_leading_zeros(lbProcedure *p, lbValue x, Type *type);
 lbValue lb_emit_reverse_bits(lbProcedure *p, lbValue x, Type *type);