denuvo-ref/rizin
1
0
Fork 0
mirror of https://github.com/rizinorg/rizin synced 2026-08-22 20:26:16 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Speed up rz_bv_set_from functions

Browse source
This commit is contained in:
Rot127 2026-04-07 18:29:51 +02:00 • committed by Florian Märkl
parent 5353b06952
commit d2d6846e58
2 changed files with 66 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

27
librz/util/bitvector.c
View file

@ -1810,14 +1810,10 @@ RZ_API bool rz_bv_set_from_ut64(RZ_NONNULL RzBitVector *bv, ut64 value) {
bv->bits.small_u &= (UT64_MAX >> (64 - bv->len));
return true;
}
if (value == 0) {
memset(bv->bits.large_a, 0, bv->_elem_len);
return true;
}
for (ut32 i = 0; i < bv->len; ++i) {
rz_bv_set(bv, i, value & 1);
value >>= 1;
memset(bv->bits.large_a, 0, bv->_elem_len);
for (size_t i = 0; i < 8 && value; ++i, value >>= 8) {
bv->bits.large_a[i] = value & 0xff;
}
return true;
}
@ -1839,10 +1835,21 @@ RZ_API bool rz_bv_set_from_st64(RZ_NONNULL RzBitVector *bv, st64 value) {
return true;
}
for (ut32 i = 0; i < bv->len; ++i) {
rz_bv_set(bv, i, value & 1);
value >>= 1;
ut64 uval = (ut64)value;
for (size_t i = 0; i < 8; ++i, uval >>= 8) {
bv->bits.large_a[i] = uval & 0xff;
}
if (value >= 0) {
memset(bv->bits.large_a + 8, 0x00, bv->_elem_len - 8);
return true;
}
memset(bv->bits.large_a + 8, 0xff, bv->_elem_len - 8 - 1);
// set high bits
size_t min_bytes_needed = ((bv->len + 7) / 8);
size_t unset_bits = (min_bytes_needed * 8) - bv->len;
bv->bits.large_a[min_bytes_needed - 1] = 0xff >> unset_bits;
return true;
}

60
test/unit/test_bitvector.c
View file

@ -87,17 +87,6 @@ bool test_rz_bv_init128(void) {
s = rz_bv_as_hex_string(bits, true);
mu_assert_streq_free(s, "0x00000000000000000000000000000064", "string hex value of bv");
rz_bv_set_from_ut64(bits, 0);
mu_assert_eq(rz_bv_to_ut64(bits), 0, "Did not set to zero");
rz_bv_set(bits, 2, true);
rz_bv_set(bits, 5, true);
rz_bv_set(bits, 6, true);
mu_assert("new from 128", is_equal_bv(bits, bits_cmp));
rz_bv_set_from_st64(bits, 0);
mu_assert_eq(rz_bv_to_ut64(bits), 0, "Did not set to zero");
rz_bv_free(bits);
rz_bv_free(bits_cmp);
rz_bv_free(bits_dup);
@ -187,6 +176,54 @@ bool test_rz_bv_init_signed(void) {
mu_end;
}
bool test_rz_bv_set_from(void) {
char *s = NULL;
RzBitVector *bits_128 = rz_bv_new_from_ut64(128, 100);
RzBitVector *bits_128_cmp = rz_bv_new(128);
rz_bv_set(bits_128_cmp, 2, true);
rz_bv_set(bits_128_cmp, 5, true);
rz_bv_set(bits_128_cmp, 6, true);
rz_bv_set_from_ut64(bits_128, 0);
mu_assert_eq(rz_bv_to_ut64(bits_128), 0, "Did not set to zero");
rz_bv_set(bits_128, 2, true);
rz_bv_set(bits_128, 5, true);
rz_bv_set(bits_128, 6, true);
mu_assert("new from 128", is_equal_bv(bits_128, bits_128_cmp));
rz_bv_set_from_st64(bits_128, 0);
mu_assert_eq(rz_bv_to_ut64(bits_128), 0, "Did not set to zero");
rz_bv_set(bits_128, 2, true);
rz_bv_set(bits_128, 67, true);
rz_bv_set_from_ut64(bits_128, 0x7766554433221100ull);
s = rz_bv_as_hex_string(bits_128, true);
mu_assert_streq_free(s, "0x00000000000000007766554433221100", "string hex value of bv");
rz_bv_set_from_st64(bits_128, (st64)0xffeeddccbbaa9988ull);
s = rz_bv_as_hex_string(bits_128, true);
mu_assert_streq_free(s, "0xffffffffffffffffffeeddccbbaa9988", "string hex value of bv");
rz_bv_free(bits_128);
rz_bv_free(bits_128_cmp);
RzBitVector *bits_67 = rz_bv_new_from_st64(67, -1);
s = rz_bv_as_hex_string(bits_67, true);
mu_assert_streq_free(s, "0x07ffffffffffffffff", "string hex value of bv");
rz_bv_cast_inplace(bits_67, 69, rz_bv_msb(bits_67));
s = rz_bv_as_hex_string(bits_67, true);
mu_assert_streq_free(s, "0x1fffffffffffffffff", "string hex value of bv");
rz_bv_set_from_st64(bits_67, 9);
s = rz_bv_as_hex_string(bits_67, false);
mu_assert_streq_free(s, "0x9", "string hex value of bv");
rz_bv_free(bits_67);
mu_end;
}
bool test_rz_bv_logic_large(void) {
RzBitVector *x, *y, *z;
RzBitVector *result;
@ -1986,6 +2023,7 @@ bool all_tests() {
mu_run_test(test_rz_bv_init128);
mu_run_test(test_rz_bv_init70);
mu_run_test(test_rz_bv_init_signed);
mu_run_test(test_rz_bv_set_from);
mu_run_test(test_rz_bv_cmp);
mu_run_test(test_rz_bv_eq);
mu_run_test(test_rz_bv_cast);