bits.[ch]: remove logs in macros (moved to bits.c)

c/bits.c

@@ -0,0 +1,91 @@
+/* bits.c - information about bitops implementation.
+ *
+ * Copyright (C) 2021-2022 Bruno Raoult ("br")
+ * Licensed under the GNU General Public License v3.0 or later.
+ * Some rights reserved. See COPYING.
+ *
+ * You should have received a copy of the GNU General Public License along with this
+ * program. If not, see <https://www.gnu.org/licenses/gpl-3.0-standalone.html>.
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later <https://spdx.org/licenses/GPL-3.0-or-later.html>
+ *
+ */
+
+#include "bits.h"
+#include "debug.h"
+
+/**
+ * bits_implementation - display bitops implementation.
+ *
+ * For basic bitops (popcount, ctz, etc...), print the implementation
+ * (builtin, emulated).
+ */
+void bits_implementation(void)
+{
+    log(0, "bitops implementation: ");
+
+    log(0, "popcount64: ");
+#   if __has_builtin(__builtin_popcountl)
+    log(0, "builtin, ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "popcount32: ");
+#   if __has_builtin(__builtin_popcount)
+    log(0, "builtin, ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "ctz64: ");
+#   if __has_builtin(__builtin_ctzl)
+    log(0, "builtin, ");
+#   elif __has_builtin(__builtin_clzl)
+    log(0, "builtin (clzl), ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "ctz32: ");
+#   if __has_builtin(__builtin_ctz)
+    log(0, "builtin, ");
+#   elif __has_builtin(__builtin_clz)
+    log(0, "builtin (clz), ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "clz64: ");
+#   if __has_builtin(__builtin_clzl)
+    log(0, "builtin, ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "clz32: ");
+#   if __has_builtin(__builtin_clz)
+    log(0, "builtin, ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "ffs64: ");
+#   if __has_builtin(__builtin_ffsl)
+    log(0, "builtin, ");
+#   elif __has_builtin(__builtin_ctzl)
+    log(0, "builtin (ctzl), ");
+#   else
+    log(0, "emulated, ");
+#   endif
+
+    log(0, "ffs32: ");
+#   if __has_builtin(__builtin_ffs)
+    log(0, "builtin, ");
+#   elif __has_builtin(__builtin_ctz)
+    log(0, "builtin (ctzl), ");
+#   else
+    log(0, "emulated, ");
+#   endif
+    log(0, "\n");
+}

c/include/bits.h

@@ -15,10 +15,9 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <bits/wordsize.h>                        /* defines __WORDSIZE: 32 or 64 */
 
-/* next include will define __WORDSIZE: 32 or 64
- */
-#include <bits/wordsize.h>
+void bits_implementation(void);
 
 #ifndef __has_builtin
 #define __has_builtin(x) 0
@@ -77,15 +76,9 @@ typedef signed char schar;
 static __always_inline int popcount64(u64 n)
 {
 #   if __has_builtin(__builtin_popcountl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin.\n");
-#   endif
     return __builtin_popcountl(n);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     int count = 0;
     while (n) {
         count++;
@@ -98,15 +91,9 @@ static __always_inline int popcount64(u64 n)
 static __always_inline int popcount32(u32 n)
 {
 #   if __has_builtin(__builtin_popcount)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin.\n");
-#   endif
     return __builtin_popcount(n);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     int count = 0;
     while (n) {
         count++;
@@ -122,21 +109,12 @@ static __always_inline int popcount32(u32 n)
 static __always_inline int ctz64(u64 n)
 {
 #   if __has_builtin(__builtin_ctzl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ctzl.\n");
-#   endif
     return __builtin_ctzl(n);
 
 #   elif __has_builtin(__builtin_clzl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin clzl.\n");
-#   endif
     return __WORDSIZE - (__builtin_clzl(n & -n) + 1);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     return popcount64((n & -n) - 1);
 #   endif
 }
@@ -144,21 +122,12 @@ static __always_inline int ctz64(u64 n)
 static __always_inline int ctz32(u32 n)
 {
 #   if __has_builtin(__builtin_ctz)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ctz.\n");
-#   endif
     return __builtin_ctzl(n);
 
 #   elif __has_builtin(__builtin_clz)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin clz.\n");
-#   endif
     return __WORDSIZE - (__builtin_clz(n & -n) + 1);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     return popcount32((n & -n) - 1);
 #   endif
 }
@@ -169,15 +138,9 @@ static __always_inline int ctz32(u32 n)
 static __always_inline int clz64(u64 n)
 {
 #   if __has_builtin(__builtin_clzl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin.\n");
-#   endif
     return __builtin_clzl(n);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     u64 r, q;
 
     r = (n > 0xFFFFFFFF) << 5; n >>= r;
@@ -193,15 +156,9 @@ static __always_inline int clz64(u64 n)
 static __always_inline int clz32(u32 n)
 {
 #   if __has_builtin(__builtin_clz)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin.\n");
-#   endif
     return __builtin_clz(n);
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     u32 r, q;
 
     r = (n > 0xFFFF)     << 4; n >>= r;
@@ -236,23 +193,14 @@ static __always_inline int fls32(u32 n)
 static __always_inline uint ffs64(u64 n)
 {
 #   if __has_builtin(__builtin_ffsl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ffsl.\n");
-#   endif
     return __builtin_ffsl(n);
 
 #   elif __has_builtin(__builtin_ctzl)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ctzl.\n");
-#   endif
     if (n == 0)
         return (0);
     return __builtin_ctzl(n) + 1;
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     return popcount64(n ^ ~-n);
 #   endif
 }
@@ -260,28 +208,19 @@ static __always_inline uint ffs64(u64 n)
 static __always_inline uint ffs32(u32 n)
 {
 #   if __has_builtin(__builtin_ffs)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ffs.\n");
-#   endif
     return __builtin_ffs(n);
 
 #   elif __has_builtin(__builtin_ctz)
-#   ifdef DEBUG_BITS
-    log_f(1, "builtin ctz.\n");
-#   endif
     if (n == 0)
         return (0);
     return __builtin_ctz(n) + 1;
 
 #   else
-#   ifdef DEBUG_BITS
-    log_f(1, "emulated.\n");
-#   endif
     return popcount32(n ^ ~-n);
 #   endif
 }
 
-/*  rolXX are taken from kernel's <linux/bitops.h> are are:
+/* rolXX/rorXX are taken from kernel's <linux/bitops.h> are are:
  * SPDX-License-Identifier: GPL-2.0
  */
 
@@ -366,20 +305,23 @@ static inline u8 ror8(u8 word, unsigned int shift)
 }
 
 /**
- * ilog2 -
+ * __ilog2 - non-constant log of base 2 calculators
+ * - the arch may override these in asm/bitops.h if they can be implemented
+ *   more efficiently than using fls() and fls64()
+ * - the arch is not required to handle n==0 if implementing the fallback
  */
-static __always_inline __attribute__((const))
-int __ilog2_u32(u32 n)
-{
-	return fls32(n) - 1;
-}
-
 static __always_inline __attribute__((const))
 int __ilog2_u64(u64 n)
 {
         return fls64(n) - 1;
 }
 
+static __always_inline __attribute__((const))
+int __ilog2_u32(u32 n)
+{
+        return fls32(n) - 1;
+}
+
 /**
  * is_power_of_2() - check if a value is a power of two
  * @n: the value to check
@@ -394,6 +336,25 @@ bool is_power_of_2(unsigned long n)
         return (n != 0 && ((n & (n - 1)) == 0));
 }
 
+/**
+ * __roundup_pow_of_two() - round up to nearest power of two
+ * @n: value to round up
+ */
+static inline __attribute__((const))
+u64 __roundup_pow_of_two(u64 n)
+{
+        return 1UL << fls64(n - 1);
+}
+
+/**
+ * __rounddown_pow_of_two() - round down to nearest power of two
+ * @n: value to round down
+ */
+static inline __attribute__((const)) u64 __rounddown_pow_of_two(u64 n)
+{
+        return 1UL << (fls64(n) - 1);
+}
+
 /**
  * ilog2 - log base 2 of 32-bit or a 64-bit unsigned value
  * @n: parameter
@@ -446,8 +407,7 @@ bool is_power_of_2(unsigned long n)
         __rounddown_pow_of_two(n)               \
  )
 
-static inline __attribute_const__
-int __order_base_2(unsigned long n)
+static inline __attribute_const__ int __order_base_2(unsigned long n)
 {
         return n > 1 ? ilog2(n - 1) + 1 : 0;
 }
@@ -468,13 +428,13 @@ int __order_base_2(unsigned long n)
 #define order_base_2(n)                         \
 (                                               \
         __builtin_constant_p(n) ? (             \
-		((n) == 0 || (n) == 1) ? 0 :	\
+            ((n) == 0 || (n) == 1) ?            \
+            0 :                                 \
             ilog2((n) - 1) + 1) :               \
         __order_base_2(n)                       \
 )
 
-static inline __attribute__((const))
-int __bits_per(unsigned long n)
+static inline __attribute__((const)) int __bits_per(unsigned long n)
 {
         if (n < 2)
             return 1;
@@ -501,9 +461,9 @@ int __bits_per(unsigned long n)
 #define bits_per(n)                             \
 (                                               \
         __builtin_constant_p(n) ? (             \
-		((n) == 0 || (n) == 1)		\
-			? 1 : ilog2(n) + 1	\
-	) :					\
+            ((n) == 0 || (n) == 1) ?            \
+            1 :                                 \
+            ilog2(n) + 1 :                      \
             __bits_per(n)                       \
 )