optimize: checked_ilog when base is a power of two

if base == 2 ** k, then
log(base, n) == log(2, n) / k

Author: Kmeakin

library/core/src/num/uint_macros.rs

@@ -1567,6 +1567,10 @@ macro_rules! uint_impl {
         ///
         /// ```
         #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(5), Some(1));")]
+        #[doc = concat!("assert_eq!(4", stringify!($SelfT), ".checked_ilog(5), Some(0));")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(0), None);")]
+        #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(1), None);")]
+        #[doc = concat!("assert_eq!(0", stringify!($SelfT), ".checked_ilog(1), None);")]
         /// ```
         #[stable(feature = "int_log", since = "1.67.0")]
         #[rustc_const_stable(feature = "int_log", since = "1.67.0")]
@@ -1581,9 +1585,14 @@ macro_rules! uint_impl {
             // applied by the compiler. If you want those specific bases,
             // use `.checked_ilog2()` or `.checked_ilog10()` directly.
             if core::intrinsics::is_val_statically_known(base) {
-                if base == 2 {
-                    return self.checked_ilog2();
-                } else if base == 10 {
+                // change of base:
+                // if base == 2 ** k, then
+                // log(base, n) == log(2, n) / k
+                if base.is_power_of_two() && base > 1 {
+                    let k = base.ilog2();
+                    return Some(try_opt!(self.checked_ilog2()) / k);
+                }
+                if base == 10 {
                     return self.checked_ilog10();
                 }
             }

tests/codegen-llvm/ilog_known_base.rs

@@ -0,0 +1,36 @@
+//@ compile-flags: -Copt-level=3
+// Test that `checked_ilog` can use a faster implementation when `base` is a
+// known power of two
+
+#![crate_type = "lib"]
+
+// CHECK-LABEL: @checked_ilog2
+#[no_mangle]
+pub fn checked_ilog2(val: u32) -> Option<u32> {
+    // CHECK: %[[ICMP:.+]] = icmp ne i32 %val, 0
+    // CHECK: %[[CTZ:.+]] = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 %val, i1 true)
+    // CHECK: %[[LOG2:.+]] = xor i32 %[[CTZ]], 31
+    val.checked_ilog(2)
+}
+
+// log(4, x) == log(2, x) / 2
+// CHECK-LABEL: @checked_ilog4
+#[no_mangle]
+pub fn checked_ilog4(val: u32) -> Option<u32> {
+    // CHECK: %[[ICMP:.+]] = icmp ne i32 %val, 0
+    // CHECK: %[[CTZ:.+]] = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 %val, i1 true)
+    // CHECK: %[[DIV2:.+]] = lshr i32 %[[CTZ]], 1
+    // CHECK: %[[LOG4:.+]] = xor i32 %[[DIV2]], 15
+    val.checked_ilog(4)
+}
+
+// log(16, x) == log(2, x) / 4
+// CHECK-LABEL: @checked_ilog16
+#[no_mangle]
+pub fn checked_ilog16(val: u32) -> Option<u32> {
+    // CHECK: %[[ICMP:.+]] = icmp ne i32 %val, 0
+    // CHECK: %[[CTZ:.+]] = tail call range(i32 0, 33) i32 @llvm.ctlz.i32(i32 %val, i1 true)
+    // CHECK: %[[DIV4:.+]] = lshr i32 %[[CTZ]], 2
+    // CHECK: %[[LOG16:.+]] = xor i32 %[[DIV2]], 7
+    val.checked_ilog(16)
+}