librz/util: add bit counting and address alignment calculation helper. (#4886)

* Add bit counting function.
* Add address padding calculating function.
* Add doxygen to rz_bits_count_X()
* Rename rz_bits_count -> rz_bits_count_ones

Author: Rot127

librz/include/rz_util/rz_bits.h

@@ -11,6 +11,28 @@ extern "C" {
 #include <rz_util/rz_assert.h>
 #include <rz_types_base.h>
 
+/**
+ * \brief Count number of 1s in the given value.
+ * Reference: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
+ *
+ * \param v The value to count the set bits in.
+ *
+ * \return Number of set bits in \p v.
+ */
+#define DEFINE_COUNT_ONES(T) \
+	static inline size_t rz_bits_count_ones_##T(T v) { \
+		v = v - ((v >> 1) & (T) ~(T)0 / 3); \
+		v = (v & (T) ~(T)0 / 15 * 3) + ((v >> 2) & (T) ~(T)0 / 15 * 3); \
+		v = (v + (v >> 4)) & (T) ~(T)0 / 255 * 15; \
+		size_t c = (T)(v * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * CHAR_BIT; \
+		return c; \
+	}
+
+DEFINE_COUNT_ONES(ut64);
+DEFINE_COUNT_ONES(ut32);
+DEFINE_COUNT_ONES(ut16);
+DEFINE_COUNT_ONES(ut8);
+
 /**
  * \brief Get the number of leading zeros of a 64-bit integer in binary representation.
  * \param x the 64-bit integer

librz/include/rz_util/rz_mem.h

@@ -36,6 +36,7 @@ RZ_API const ut8 *rz_mem_mem_aligned(const ut8 *haystack, int hlen, const ut8 *n
 RZ_API int rz_mem_count(const ut8 **addr);
 RZ_API bool rz_mem_is_printable(const ut8 *a, int la);
 RZ_API bool rz_mem_is_zero(const ut8 *b, int l);
+RZ_API ut64 rz_mem_align_padding(const ut64 address, ut64 alignment);
 
 #ifdef __cplusplus
 }

librz/util/mem.c

@@ -286,6 +286,34 @@ RZ_API bool rz_mem_is_zero(const ut8 *b, int l) {
 	return true;
 }
 
+/**
+ * \brief Calculates the required padding to align the given \p address to the
+ * given \p alignment.
+ *
+ * This is only valid for architectures with a defined alignment of n^2.
+ *
+ * \param address   The address to calculate the required padding for.
+ * \param alignment The required alignment. It must be a power of 2 and greater than 0.
+ *
+ * \return The additional padding to align \p address. If \p alignment
+ * is equal 0 or not a power of two it returns UT64_MAX.
+ *
+ * Examples:
+ *
+ * ut64 address = 0x59d;
+ * ut64 padding = rz_mem_align_padding(address, 4);
+ * assert(padding == 3);
+ * assert(address + padding == 0x5a0);
+ */
+RZ_API ut64 rz_mem_align_padding(const ut64 address, ut64 alignment) {
+	size_t c = rz_bits_count_ones_ut64(alignment);
+	if (c != 1) {
+		rz_warn_if_reached();
+		return UT64_MAX;
+	}
+	return (alignment - (address % alignment)) % alignment;
+}
+
 RZ_API void rz_mem_memzero(void *dst, size_t l) {
 #ifdef _MSC_VER
 	RtlSecureZeroMemory(dst, l);

test/unit/meson.build

@@ -27,6 +27,7 @@ if get_option('enable_tests')
     'bin_lines',
     'bin_mach0',
     'bitvector',
+    'bits',
     'buf',
     'cmd',
     'compare',
@@ -73,6 +74,7 @@ if get_option('enable_tests')
     'list',
     'log',
     'lzma',
+    'mem',
     'ovf',
     'pj',
     'rbtree',

test/unit/test_bits.c

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2025 Rot127 <[email protected]>
+// SPDX-License-Identifier: LGPL-3.0-only
+
+#include <rz_util.h>
+#include "minunit.h"
+
+bool test_rz_bits_count(void) {
+	mu_assert_eq(rz_bits_count_ones_ut64(0xffffffffffffffff), 64, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0), 0, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(1), 1, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x8000000000000000), 1, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x7fffffffffffffff), 63, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0xfffffffffffffffe), 63, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0xffffffffffefffff), 63, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0fffffffffffffff), 60, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0xf0ffffffffffffff), 60, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0xffffffffff0fffff), 60, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0xffffffff00000000), 32, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x00000000ffffffff), 32, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0000010000000000), 1, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0000000000001000), 1, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0100000100001000), 3, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0400000100002000), 3, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0400008100002000), 4, "Bit count mismatch.");
+	mu_assert_eq(rz_bits_count_ones_ut64(0x0400008100002008), 5, "Bit count mismatch.");
+
+	for (size_t i = 0; i <= 0xff; i++) {
+		size_t naive_count = 0;
+		for (size_t k = 0; k < 8; k++) {
+			naive_count += i & (1 << k) ? 1 : 0;
+		}
+		mu_assert_eq(rz_bits_count_ones_ut8(i), naive_count, "Bit count mismatch.");
+	}
+
+	mu_end;
+}
+
+bool all_tests() {
+	mu_run_test(test_rz_bits_count);
+
+	return tests_passed != tests_run;
+}
+
+mu_main(all_tests)

test/unit/test_mem.c

@@ -0,0 +1,36 @@
+// SPDX-FileCopyrightText: 2025 Rot127 <[email protected]>
+// SPDX-License-Identifier: LGPL-3.0-only
+
+#include <rz_util.h>
+#include "minunit.h"
+
+bool test_rz_mem_align_padding(void) {
+	mu_assert_eq(rz_mem_align_padding(0x0, 0), UT64_MAX, "Error case failed.");
+	mu_assert_eq(rz_mem_align_padding(0x0, 3), UT64_MAX, "Error case failed.");
+	mu_assert_eq(rz_mem_align_padding(0x0, UT64_MAX), UT64_MAX, "Error case failed.");
+
+	mu_assert_eq(rz_mem_align_padding(0x0, 1), 0, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x1, 1), 0, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x800000, 1), 0, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(UT64_MAX, 1), 0, "Padding mismatch.");
+
+	mu_assert_eq(rz_mem_align_padding(0x0, 2), 0, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x1, 2), 1, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x0, 0x8000000000000000), 0, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x1, 0x8000000000000000), 0x7fffffffffffffff, "Padding mismatch.");
+
+	mu_assert_eq(rz_mem_align_padding(0x59d, 4), 3, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x7fffe, 8), 2, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x7fffe, 0x80000), 2, "Padding mismatch.");
+	mu_assert_eq(rz_mem_align_padding(0x7fffe, 0x800000), 0x780002, "Padding mismatch.");
+
+	mu_end;
+}
+
+bool all_tests() {
+	mu_run_test(test_rz_mem_align_padding);
+
+	return tests_passed != tests_run;
+}
+
+mu_main(all_tests)