Rename intrinsics to count_trailing_zeros and count_leading_zeros

core/math/bits/bits.odin

@@ -25,23 +25,14 @@ I64_MAX :: 1 << 63 - 1;
 
 
 count_ones     :: intrinsics.count_ones;
-trailing_zeros :: intrinsics.trailing_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;
 
 
-leading_zeros_u8  :: proc(i:  u8) -> int {
-	return 8*size_of(i) - len_u8(i);
-}
-leading_zeros_u16 :: proc(i: u16) -> int {
-	return 8*size_of(i) - len_u16(i);
-}
-leading_zeros_u32 :: proc(i: u32) -> int {
-	return 8*size_of(i) - len_u32(i);
-}
-leading_zeros_u64 :: proc(i: u64) -> int {
-	return 8*size_of(i) - len_u64(i);
-}
-
 
 byte_swap_u16 :: proc(x: u16) -> u16 {
 	return runtime.bswap_16(x);
@@ -83,18 +74,6 @@ byte_swap_int :: proc(i: int) -> int {
 	}
 }
 
-byte_swap :: proc{
-	byte_swap_u16,
-	byte_swap_u32,
-	byte_swap_u64,
-	byte_swap_u128,
-	byte_swap_i16,
-	byte_swap_i32,
-	byte_swap_i64,
-	byte_swap_i128,
-	byte_swap_uint,
-	byte_swap_int,
-};
 
 count_zeros8   :: proc(i:   u8) ->   u8 { return   8 - count_ones(i); }
 count_zeros16  :: proc(i:  u16) ->  u16 { return  16 - count_ones(i); }
@@ -324,7 +303,7 @@ div_u64 :: proc(hi, lo, y: u64) -> (quo, rem: u64) {
 		panic("overflow error");
 	}
 
-	s := uint(leading_zeros_u64(y));
+	s := uint(count_leading_zeros(y));
 	y <<= s;
 
 	yn1 := y >> 32;

core/runtime/internal_linux.odin

@@ -98,7 +98,7 @@ floattidf :: proc(a: i128) -> f64 {
 	N :: size_of(i128) * 8;
 	s := a >> (N-1);
 	a = (a ~ s) - s;
-	sd: = N - intrinsics.leading_zeros(a);  // number of significant digits
+	sd: = N - intrinsics.count_leading_zeros(a);  // number of significant digits
 	e := u32(sd - 1);        // exponent
 	if sd > DBL_MANT_DIG {
 		switch sd {

core/runtime/internal_windows.odin

@@ -98,7 +98,7 @@ floattidf :: proc(a: i128) -> f64 {
 	N :: size_of(i128) * 8;
 	s := a >> (N-1);
 	a = (a ~ s) - s;
-	sd: = N - intrinsics.leading_zeros((a);  // number of significant digits
+	sd: = N - intrinsics.count_leading_zeros(a);  // number of significant digits
 	e := u32(sd - 1);        // exponent
 	if sd > DBL_MANT_DIG {
 		switch sd {

core/runtime/udivmod128.odin

@@ -3,8 +3,8 @@ package runtime
 import "intrinsics"
 
 udivmod128 :: proc "c" (a, b: u128, rem: ^u128) -> u128 {
-	_ctz :: intrinsics.trailing_zeros;
-	_clz :: intrinsics.leading_zeros;
+	_ctz :: intrinsics.count_trailing_zeros;
+	_clz :: intrinsics.count_leading_zeros;
 
 	n := transmute([2]u64)a;
 	d := transmute([2]u64)b;

src/check_builtin.cpp

@@ -1923,8 +1923,8 @@ bool check_builtin_procedure(CheckerContext *c, Operand *operand, Ast *call, i32
 		break;
 
 	case BuiltinProc_count_ones:
-	case BuiltinProc_trailing_zeros:
-	case BuiltinProc_leading_zeros:
+	case BuiltinProc_count_trailing_zeros:
+	case BuiltinProc_count_leading_zeros:
 	case BuiltinProc_reverse_bits:
 		{
 			Operand x = {};

src/checker_builtin_procs.hpp

@@ -46,8 +46,8 @@ enum BuiltinProcId {
 	BuiltinProc_read_cycle_counter,
 
 	BuiltinProc_count_ones,
-	BuiltinProc_trailing_zeros,
-	BuiltinProc_leading_zeros,
+	BuiltinProc_count_trailing_zeros,
+	BuiltinProc_count_leading_zeros,
 	BuiltinProc_reverse_bits,
 	BuiltinProc_byte_swap,
 
@@ -264,11 +264,11 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT("debug_trap"),         0, false, Expr_Stmt, BuiltinProcPkg_intrinsics, /*diverging*/false},
 	{STR_LIT("read_cycle_counter"), 0, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 
-	{STR_LIT("count_ones"),     1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-	{STR_LIT("trailing_zeros"), 1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-	{STR_LIT("leading_zeros"),  1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-	{STR_LIT("reverse_bits"),   1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-	{STR_LIT("byte_swap"),      1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
+	{STR_LIT("count_ones"),           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},
+	{STR_LIT("byte_swap"),            1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 
 	{STR_LIT("overflow_add"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("overflow_sub"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics},

src/llvm_backend.cpp

@@ -9106,10 +9106,10 @@ lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValue const &tv,
 			return res;
 		}
 
-	case BuiltinProc_trailing_zeros:
-		return lb_emit_trailing_zeros(p, lb_build_expr(p, ce->args[0]), tv.type);
-	case BuiltinProc_leading_zeros:
-		return lb_emit_leading_zeros(p, lb_build_expr(p, ce->args[0]), tv.type);
+	case BuiltinProc_count_trailing_zeros:
+		return lb_emit_count_trailing_zeros(p, lb_build_expr(p, ce->args[0]), tv.type);
+	case BuiltinProc_count_leading_zeros:
+		return lb_emit_count_leading_zeros(p, lb_build_expr(p, ce->args[0]), tv.type);
 
 	case BuiltinProc_count_ones:
 		return lb_emit_count_ones(p, lb_build_expr(p, ce->args[0]), tv.type);
@@ -9972,7 +9972,7 @@ lbValue lb_emit_count_ones(lbProcedure *p, lbValue x, Type *type) {
 }
 
 
-lbValue lb_emit_trailing_zeros(lbProcedure *p, lbValue x, Type *type) {
+lbValue lb_emit_count_trailing_zeros(lbProcedure *p, lbValue x, Type *type) {
 	x = lb_emit_conv(p, x, type);
 
 	char const *name = "llvm.cttz";
@@ -9991,7 +9991,7 @@ lbValue lb_emit_trailing_zeros(lbProcedure *p, lbValue x, Type *type) {
 	return res;
 }
 
-lbValue lb_emit_leading_zeros(lbProcedure *p, lbValue x, Type *type) {
+lbValue lb_emit_count_leading_zeros(lbProcedure *p, lbValue x, Type *type) {
 	x = lb_emit_conv(p, x, type);
 
 	char const *name = "llvm.ctlz";

src/llvm_backend.hpp

@@ -395,8 +395,8 @@ 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_trailing_zeros(lbProcedure *p, lbValue x, Type *type);
-lbValue lb_emit_leading_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);
 
 lbValue lb_emit_bit_set_card(lbProcedure *p, lbValue x);