bruno/brlib
1
0
Fork 0
Code Issues 9 Pull Requests Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Bruno Raoult
2023-12-16 17:05:07 +01:00
parent 0de2befedc
commit 8f1818c9e8
2 changed files with 176 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
c/bits.c Normal file
View File

@@ -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");
}

118
c/include/bits.h
View File

@@ -15,10 +15,9 @@
#include <stdint.h> #include <stdint.h>
#include <stdbool.h> #include <stdbool.h>
#include <bits/wordsize.h> /* defines __WORDSIZE: 32 or 64 */
/* next include will define __WORDSIZE: 32 or 64 void bits_implementation(void);
*/
#include <bits/wordsize.h>
#ifndef __has_builtin #ifndef __has_builtin
#define __has_builtin(x) 0 #define __has_builtin(x) 0
@@ -77,15 +76,9 @@ typedef signed char schar;
static __always_inline int popcount64(u64 n) static __always_inline int popcount64(u64 n)
{ {
# if __has_builtin(__builtin_popcountl) # if __has_builtin(__builtin_popcountl)
# ifdef DEBUG_BITS
log_f(1, "builtin.\n");
# endif
return __builtin_popcountl(n); return __builtin_popcountl(n);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
int count = 0; int count = 0;
while (n) { while (n) {
count++; count++;
@@ -98,15 +91,9 @@ static __always_inline int popcount64(u64 n)
static __always_inline int popcount32(u32 n) static __always_inline int popcount32(u32 n)
{ {
# if __has_builtin(__builtin_popcount) # if __has_builtin(__builtin_popcount)
# ifdef DEBUG_BITS
log_f(1, "builtin.\n");
# endif
return __builtin_popcount(n); return __builtin_popcount(n);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
int count = 0; int count = 0;
while (n) { while (n) {
count++; count++;
@@ -122,21 +109,12 @@ static __always_inline int popcount32(u32 n)
static __always_inline int ctz64(u64 n) static __always_inline int ctz64(u64 n)
{ {
# if __has_builtin(__builtin_ctzl) # if __has_builtin(__builtin_ctzl)
# ifdef DEBUG_BITS
log_f(1, "builtin ctzl.\n");
# endif
return __builtin_ctzl(n); return __builtin_ctzl(n);
# elif __has_builtin(__builtin_clzl) # elif __has_builtin(__builtin_clzl)
# ifdef DEBUG_BITS
log_f(1, "builtin clzl.\n");
# endif
return __WORDSIZE - (__builtin_clzl(n & -n) + 1); return __WORDSIZE - (__builtin_clzl(n & -n) + 1);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
return popcount64((n & -n) - 1); return popcount64((n & -n) - 1);
# endif # endif
} }
@@ -144,21 +122,12 @@ static __always_inline int ctz64(u64 n)
static __always_inline int ctz32(u32 n) static __always_inline int ctz32(u32 n)
{ {
# if __has_builtin(__builtin_ctz) # if __has_builtin(__builtin_ctz)
# ifdef DEBUG_BITS
log_f(1, "builtin ctz.\n");
# endif
return __builtin_ctzl(n); return __builtin_ctzl(n);
# elif __has_builtin(__builtin_clz) # elif __has_builtin(__builtin_clz)
# ifdef DEBUG_BITS
log_f(1, "builtin clz.\n");
# endif
return __WORDSIZE - (__builtin_clz(n & -n) + 1); return __WORDSIZE - (__builtin_clz(n & -n) + 1);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
return popcount32((n & -n) - 1); return popcount32((n & -n) - 1);
# endif # endif
} }
@@ -169,15 +138,9 @@ static __always_inline int ctz32(u32 n)
static __always_inline int clz64(u64 n) static __always_inline int clz64(u64 n)
{ {
# if __has_builtin(__builtin_clzl) # if __has_builtin(__builtin_clzl)
# ifdef DEBUG_BITS
log_f(1, "builtin.\n");
# endif
return __builtin_clzl(n); return __builtin_clzl(n);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
u64 r, q; u64 r, q;
r = (n > 0xFFFFFFFF) << 5; n >>= r; r = (n > 0xFFFFFFFF) << 5; n >>= r;
@@ -193,15 +156,9 @@ static __always_inline int clz64(u64 n)
static __always_inline int clz32(u32 n) static __always_inline int clz32(u32 n)
{ {
# if __has_builtin(__builtin_clz) # if __has_builtin(__builtin_clz)
# ifdef DEBUG_BITS
log_f(1, "builtin.\n");
# endif
return __builtin_clz(n); return __builtin_clz(n);
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
u32 r, q; u32 r, q;
r = (n > 0xFFFF) << 4; n >>= r; r = (n > 0xFFFF) << 4; n >>= r;
@@ -236,23 +193,14 @@ static __always_inline int fls32(u32 n)
static __always_inline uint ffs64(u64 n) static __always_inline uint ffs64(u64 n)
{ {
# if __has_builtin(__builtin_ffsl) # if __has_builtin(__builtin_ffsl)
# ifdef DEBUG_BITS
log_f(1, "builtin ffsl.\n");
# endif
return __builtin_ffsl(n); return __builtin_ffsl(n);
# elif __has_builtin(__builtin_ctzl) # elif __has_builtin(__builtin_ctzl)
# ifdef DEBUG_BITS
log_f(1, "builtin ctzl.\n");
# endif
if (n == 0) if (n == 0)
return (0); return (0);
return __builtin_ctzl(n) + 1; return __builtin_ctzl(n) + 1;
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
return popcount64(n ^ ~-n); return popcount64(n ^ ~-n);
# endif # endif
} }
@@ -260,28 +208,19 @@ static __always_inline uint ffs64(u64 n)
static __always_inline uint ffs32(u32 n) static __always_inline uint ffs32(u32 n)
{ {
# if __has_builtin(__builtin_ffs) # if __has_builtin(__builtin_ffs)
# ifdef DEBUG_BITS
log_f(1, "builtin ffs.\n");
# endif
return __builtin_ffs(n); return __builtin_ffs(n);
# elif __has_builtin(__builtin_ctz) # elif __has_builtin(__builtin_ctz)
# ifdef DEBUG_BITS
log_f(1, "builtin ctz.\n");
# endif
if (n == 0) if (n == 0)
return (0); return (0);
return __builtin_ctz(n) + 1; return __builtin_ctz(n) + 1;
# else # else
# ifdef DEBUG_BITS
log_f(1, "emulated.\n");
# endif
return popcount32(n ^ ~-n); return popcount32(n ^ ~-n);
# endif # 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 * 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)) static __always_inline __attribute__((const))
int __ilog2_u64(u64 n) int __ilog2_u64(u64 n)
{ {
return fls64(n) - 1; 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 * is_power_of_2() - check if a value is a power of two
* @n: the value to check * @n: the value to check
@@ -394,6 +336,25 @@ bool is_power_of_2(unsigned long n)
return (n != 0 && ((n & (n - 1)) == 0)); 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 * ilog2 - log base 2 of 32-bit or a 64-bit unsigned value
* @n: parameter * @n: parameter
@@ -446,8 +407,7 @@ bool is_power_of_2(unsigned long n)
__rounddown_pow_of_two(n) \ __rounddown_pow_of_two(n) \
) )
static inline __attribute_const__ static inline __attribute_const__ int __order_base_2(unsigned long n)
int __order_base_2(unsigned long n)
{ {
return n > 1 ? ilog2(n - 1) + 1 : 0; return n > 1 ? ilog2(n - 1) + 1 : 0;
} }
@@ -468,13 +428,13 @@ int __order_base_2(unsigned long n)
#define order_base_2(n) \ #define order_base_2(n) \
( \ ( \
__builtin_constant_p(n) ? ( \ __builtin_constant_p(n) ? ( \
((n) == 0 || (n) == 1) ? 0 : \ ((n) == 0 || (n) == 1) ? \
0 : \
ilog2((n) - 1) + 1) : \ ilog2((n) - 1) + 1) : \
__order_base_2(n) \ __order_base_2(n) \
) )
static inline __attribute__((const)) static inline __attribute__((const)) int __bits_per(unsigned long n)
int __bits_per(unsigned long n)
{ {
if (n < 2) if (n < 2)
return 1; return 1;
@@ -501,9 +461,9 @@ int __bits_per(unsigned long n)
#define bits_per(n) \ #define bits_per(n) \
( \ ( \
__builtin_constant_p(n) ? ( \ __builtin_constant_p(n) ? ( \
((n) == 0 || (n) == 1) \ ((n) == 0 || (n) == 1) ? \
? 1 : ilog2(n) + 1 \ 1 : \
) : \ ilog2(n) + 1 : \
__bits_per(n) \ __bits_per(n) \
) )