bitvector.c File Reference

#include "rz_util.h"
#include <stdlib.h>
#include <stdio.h>

Go to the source code of this file.

Macros
#define	NELEM(N, ELEMPER)   ((N + (ELEMPER)-1) / (ELEMPER))
#define	BV_ELEM_SIZE   8U
#define	reverse_byte(x)   ((((x)*0x0802LU & 0x22110LU) | ((x)*0x8020LU & 0x88440LU)) * 0x10101LU >> 16)

Functions
ut8	reverse_lt_8bits (ut8 x, ut8 w)
RZ_API bool	rz_bv_init (RZ_NONNULL RzBitVector *bv, ut32 length)
	Initialize a RzBitVector structure. More...
RZ_API void	rz_bv_fini (RZ_NONNULL RzBitVector *bv)
	Clear a RzBitVector structure. More...
RZ_API RZ_OWN RzBitVector *	rz_bv_new (ut32 length)
RZ_API void	rz_bv_free (RZ_NULLABLE RzBitVector *bv)
RZ_API RZ_OWN char *	rz_bv_as_string (RZ_NONNULL RzBitVector *bv)
RZ_API RZ_OWN char *	rz_bv_as_hex_string (RZ_NONNULL RzBitVector *bv, bool pad)
RZ_API RZ_OWN RzBitVector *	rz_bv_dup (const RZ_NONNULL RzBitVector *bv)
RZ_API ut32	rz_bv_copy (RZ_NONNULL const RzBitVector *src, RZ_NONNULL RzBitVector *dst)
RZ_API ut32	rz_bv_copy_nbits (RZ_NONNULL const RzBitVector *src, ut32 src_start_pos, RZ_NONNULL RzBitVector *dst, ut32 dst_start_pos, ut32 nbit)
RZ_API RZ_OWN RzBitVector *	rz_bv_prepend_zero (RZ_NONNULL RzBitVector *bv, ut32 delta_len)
RZ_API RZ_OWN RzBitVector *	rz_bv_append_zero (RZ_NONNULL RzBitVector *bv, ut32 delta_len)
RZ_API RZ_OWN RzBitVector *	rz_bv_cut_head (RZ_NONNULL RzBitVector *bv, ut32 delta_len)
RZ_API RZ_OWN RzBitVector *	rz_bv_cut_tail (RZ_NONNULL RzBitVector *bv, ut32 delta_len)
RZ_API RZ_OWN RzBitVector *	rz_bv_append (RZ_NONNULL RzBitVector *high, RZ_NONNULL RzBitVector *low)
RZ_API bool	rz_bv_set (RZ_NONNULL RzBitVector *bv, ut32 pos, bool b)
RZ_API bool	rz_bv_set_all (RZ_NONNULL RzBitVector *bv, bool b)
RZ_API bool	rz_bv_toggle (RZ_NONNULL RzBitVector *bv, ut32 pos)
RZ_API bool	rz_bv_toggle_all (RZ_NONNULL RzBitVector *bv)
RZ_API bool	rz_bv_get (RZ_NONNULL const RzBitVector *bv, ut32 pos)
RZ_API bool	rz_bv_lshift (RZ_NONNULL RzBitVector *bv, ut32 size)
RZ_API bool	rz_bv_rshift (RZ_NONNULL RzBitVector *bv, ut32 size)
RZ_API bool	rz_bv_lshift_fill (RZ_NONNULL RzBitVector *bv, ut32 size, bool fill_bit)
RZ_API bool	rz_bv_rshift_fill (RZ_NONNULL RzBitVector *bv, ut32 size, bool fill_bit)
RZ_API RZ_OWN RzBitVector *	rz_bv_and (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_or (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_xor (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_complement_1 (RZ_NONNULL RzBitVector *bv)
RZ_API RZ_OWN RzBitVector *	rz_bv_complement_2 (RZ_NONNULL RzBitVector *bv)
RZ_API RZ_OWN RzBitVector *	rz_bv_add (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y, RZ_NULLABLE bool *carry)
RZ_API RZ_OWN RzBitVector *	rz_bv_sub (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y, RZ_NULLABLE bool *borrow)
RZ_API RZ_OWN RzBitVector *	rz_bv_mul (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
int	bv_unsigned_cmp (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_div (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_mod (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_sdiv (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API RZ_OWN RzBitVector *	rz_bv_smod (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API bool	rz_bv_msb (RZ_NONNULL RzBitVector *bv)
RZ_API bool	rz_bv_lsb (RZ_NONNULL RzBitVector *bv)
RZ_API bool	rz_bv_is_zero_vector (RZ_NONNULL const RzBitVector *x)
RZ_API bool	rz_bv_eq (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API bool	rz_bv_ule (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API bool	rz_bv_sle (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API bool	rz_bv_cmp (RZ_NONNULL RzBitVector *x, RZ_NONNULL RzBitVector *y)
RZ_API ut32	rz_bv_clz (RZ_NONNULL RzBitVector *bv)
RZ_API ut32	rz_bv_ctz (RZ_NONNULL RzBitVector *bv)
RZ_API ut32	rz_bv_len (RZ_NONNULL const RzBitVector *bv)
RZ_API ut32	rz_bv_len_bytes (RZ_NONNULL const RzBitVector *bv)
RZ_API RZ_OWN RzBitVector *	rz_bv_new_from_ut64 (ut32 length, ut64 value)
RZ_API RZ_OWN RzBitVector *	rz_bv_new_from_st64 (ut32 length, st64 value)
RZ_API RZ_OWN RzBitVector *	rz_bv_new_from_bytes_le (RZ_IN RZ_NONNULL const ut8 *buf, ut32 bit_offset, ut32 size)
RZ_API RZ_OWN RzBitVector *	rz_bv_new_from_bytes_be (RZ_IN RZ_NONNULL const ut8 *buf, ut32 bit_offset, ut32 size)
RZ_API bool	rz_bv_set_from_ut64 (RZ_NONNULL RzBitVector *bv, ut64 value)
RZ_API bool	rz_bv_set_from_st64 (RZ_NONNULL RzBitVector *bv, st64 value)
RZ_API void	rz_bv_set_from_bytes_le (RZ_NONNULL RzBitVector *bv, RZ_IN RZ_NONNULL const ut8 *buf, ut32 bit_offset, ut32 size)
RZ_API void	rz_bv_set_from_bytes_be (RZ_NONNULL RzBitVector *bv, RZ_IN RZ_NONNULL const ut8 *buf, ut32 bit_offset, ut32 size)
	Set the bitvector's contents from the given bits. The bitvector's size is unchanged. If bv->len < size, additional bits are cut off, if bv->len > size, the rest is filled up with 0. More...
RZ_API void	rz_bv_set_to_bytes_le (RZ_NONNULL const RzBitVector *bv, RZ_OUT RZ_NONNULL ut8 *buf)
	Set the buffer contents from the given bitvector's bits in little endian format. More...
RZ_API void	rz_bv_set_to_bytes_be (RZ_NONNULL const RzBitVector *bv, RZ_OUT RZ_NONNULL ut8 *buf)
	Set the buffer contents from the given bitvector's bits in big endian format. More...
RZ_API ut32	rz_bv_hash (RZ_NULLABLE RzBitVector *x)
RZ_API ut8	rz_bv_to_ut8 (RZ_NONNULL const RzBitVector *x)
RZ_API ut16	rz_bv_to_ut16 (RZ_NONNULL const RzBitVector *x)
RZ_API ut32	rz_bv_to_ut32 (RZ_NONNULL const RzBitVector *x)
RZ_API ut64	rz_bv_to_ut64 (RZ_NONNULL const RzBitVector *x)

Macro Definition Documentation

BV_ELEM_SIZE

#define BV_ELEM_SIZE   8U

Definition at line 9 of file bitvector.c.

NELEM

#define NELEM	(		N,
			ELEMPER
	)		((N + (ELEMPER)-1) / (ELEMPER))

Definition at line 8 of file bitvector.c.

reverse_byte

#define reverse_byte

(

x

)

((((x)*0x0802LU & 0x22110LU) | ((x)*0x8020LU & 0x88440LU)) * 0x10101LU >> 16)

Definition at line 13 of file bitvector.c.

Function Documentation

bv_unsigned_cmp()

int bv_unsigned_cmp	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Definition at line 775 of file bitvector.c.

                                                                          {
    rz_return_val_if_fail(x && y, 0);
 
    if (x->len != y->len) {
        rz_warn_if_reached();
        return 0;
    }
 
    ut32 len = x->len;
    int pos;
    bool x_bit, y_bit;
    for (ut32 i = 0; i < len; ++i) {
        pos = len - 1 - i;
        x_bit = rz_bv_get(x, pos);
        y_bit = rz_bv_get(y, pos);
        if (x_bit ^ y_bit) {
            return x_bit ? 1 : -1;
        }
    }
 
    // equal
    return 0;
}

References i, len, pos, rz_bv_get(), rz_return_val_if_fail, rz_warn_if_reached, and x.

Referenced by rz_bv_div(), rz_bv_eq(), and rz_bv_ule().

reverse_lt_8bits()

ut8 reverse_lt_8bits	(	ut8	x,
		ut8	w
	)

Definition at line 17 of file bitvector.c.

                                   {
    ut8 m = ~(UT8_MAX << w); // values bitmask
    ut8 v = (x & m); // input bits to be reversed
    ut8 r = v; // r will be reversed bits of v; first get LSB of v
    int s = w - 1; // extra shift needed at end
 
    for (v >>= 1; v; v >>= 1) {
        r <<= 1;
        r |= v & 1;
        s--;
    }
    r <<= s; // shift when v's highest bits are zero
    return r;
}

References regress::m, r, s, UT8_MAX, v, w, and x.

Referenced by rz_bv_set_from_bytes_be().

rz_bv_add()

RZ_API RZ_OWN RzBitVector* rz_bv_add	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y,
		RZ_NULLABLE bool *	carry
	)

Result of (x + y) mod 2^length Both operands must have the same length.

Parameters

x	RzBitVector, Operand
y	RzBitVector, Operand
carry	bool*, bool pointer to where to save the carry value.

Returns

ret RzBitVector, point to the new bitvector

Definition at line 683 of file bitvector.c.

                                                                                                                    {
    rz_return_val_if_fail(x && y, NULL);
 
    if (x->len != y->len) {
        rz_warn_if_reached();
        return NULL;
    }
 
    bool a = false, b = false, _carry = false;
    RzBitVector *ret = rz_bv_new(x->len);
 
    for (ut32 pos = 0; pos < x->len; ++pos) {
        a = rz_bv_get(x, pos);
        b = rz_bv_get(y, pos);
        rz_bv_set(ret, pos, a ^ b ^ _carry);
        _carry = ((a & b) | (a & _carry)) | (b & _carry);
    }
    if (carry) {
        *carry = _carry;
    }
 
    return ret;
}

References a, b, NULL, pos, rz_bv_get(), rz_bv_new(), rz_bv_set(), rz_return_val_if_fail, rz_warn_if_reached, and x.

Referenced by rz_bv_mul(), rz_bv_sub(), and rz_il_handler_add().

rz_bv_and()

RZ_API RZ_OWN RzBitVector* rz_bv_and	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of x AND y (and operation to every bits) Both operands must have the same length.

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret RzBitVector, a new bitvector, which is the result of AND

Definition at line 546 of file bitvector.c.

                                                                                           {
    rz_return_val_if_fail(x && y, NULL);
    if (x->len != y->len) {
        return NULL;
    }
 
    RzBitVector *ret = rz_bv_new(x->len);
    if (!ret) {
        return NULL;
    } else if (x->len <= 64) {
        ret->bits.small_u = x->bits.small_u & y->bits.small_u;
        return ret;
    }
 
    for (ut32 i = 0; i < ret->_elem_len; ++i) {
        ret->bits.large_a[i] = x->bits.large_a[i] & y->bits.large_a[i];
    }
    return ret;
}

References bitvector_t::_elem_len, bitvector_t::bits, i, bitvector_t::large_a, NULL, rz_bv_new(), rz_return_val_if_fail, bitvector_t::small_u, and x.

Referenced by rz_il_handler_logical_and().

rz_bv_append()

RZ_API RZ_OWN RzBitVector* rz_bv_append	(	RZ_NONNULL RzBitVector *	high,
		RZ_NONNULL RzBitVector *	low
	)

Append bv2 to bv1 to get new bitvector

Parameters

high	bitvector to occupy the most significant part of the result
low	bitvector to occupy the least significant part of the result

Returns

ret RzBitVector, the new bitvector

Definition at line 326 of file bitvector.c.

                                                                                                   {
    rz_return_val_if_fail(high && low, NULL);
    RzBitVector *ret = rz_bv_new(high->len + low->len);
    rz_bv_copy_nbits(low, 0, ret, 0, low->len);
    rz_bv_copy_nbits(high, 0, ret, low->len, high->len);
    return ret;
}

References bitvector_t::len, NULL, rz_bv_copy_nbits(), rz_bv_new(), and rz_return_val_if_fail.

Referenced by rz_il_handler_append().

rz_bv_append_zero()

RZ_API RZ_OWN RzBitVector* rz_bv_append_zero	(	RZ_NONNULL RzBitVector *	bv,
		ut32	delta_len
	)

Return a new bitvector appended with n zero bits

Parameters

bv	RzBitVector, pointer to bitvector
delta_len,the	number of zero bits

Returns

ret RzBitVector, pointert to the new btivector

Definition at line 258 of file bitvector.c.

                                                                                         {
    rz_return_val_if_fail(bv, NULL);
 
    ut32 new_len = bv->len + delta_len;
    RzBitVector *ret = rz_bv_new(new_len);
    if (ret == NULL) {
        return NULL;
    }
 
    ut32 pos = delta_len;
    for (ut32 i = 0; i < bv->len; ++i, ++pos) {
        rz_bv_set(ret, pos, rz_bv_get(bv, i));
    }
 
    return ret;
}

References i, NULL, pos, rz_bv_get(), rz_bv_new(), rz_bv_set(), and rz_return_val_if_fail.

rz_bv_as_hex_string()

RZ_API RZ_OWN char* rz_bv_as_hex_string	(	RZ_NONNULL RzBitVector *	bv,
		bool	pad
	)

Return bitvector string in hexadecimal format

Parameters

bv	RzBitVector, pointer to bitvector
pad	whether to prepend leading zeroes to indicate the bitvector size

Returns

str char*, bitvector string in hexadecimal format

Definition at line 121 of file bitvector.c.

                                                                              {
    rz_return_val_if_fail(bv, NULL);
 
    if (bv->len <= 64) {
        if (pad) {
            char format[32] = { 0 };
            rz_strf(format, "0x%%0%d" PFMT64x, (bv->len + 3) / 4);
            return rz_str_newf(format, bv->bits.small_u);
        } else {
            return rz_str_newf("0x%" PFMT64x, bv->bits.small_u);
        }
    }
 
    const char *hex = "0123456789abcdef";
    size_t str_len = (bv->_elem_len << 1) + 3; // 0x + \0
    char *str = (char *)malloc(str_len);
    if (!str) {
        return NULL;
    }
 
    str[0] = '0';
    str[1] = 'x';
    ut32 j = 2;
    for (ut32 i = 0; i < bv->_elem_len; i++) {
        ut8 b8 = bv->bits.large_a[bv->_elem_len - i - 1];
        ut8 high = b8 >> 4;
        ut8 low = b8 & 15;
        if (pad || high) {
            str[j++] = hex[high];
            pad = true; // pad means "print all" from now on
        }
        if (pad || low || i == bv->_elem_len - 1) {
            str[j++] = hex[low];
            pad = true; // pad means "print all" from now on
        }
    }
    str[j] = '\0';
 
    return str;
}

References hex, i, malloc(), NULL, pad(), PFMT64x, rz_return_val_if_fail, rz_str_newf(), rz_strf, and cmd_descs_generate::str.

Referenced by il_opdmp_bitv(), rz_il_event_json(), rz_il_event_stringify(), rz_il_value_stringify(), and rzil_print_register_bitv().

rz_bv_as_string()

RZ_API RZ_OWN char* rz_bv_as_string

(

RZ_NONNULL RzBitVector *

bv

)

Return bitvector string

Parameters

bv	RzBitVector, pointer to bitvector

Returns

str char*, bitvector string

Definition at line 98 of file bitvector.c.

                                                                {
    rz_return_val_if_fail(bv, NULL);
 
    char *str = (char *)malloc(bv->len + 1);
    if (!str) {
        return NULL;
    }
 
    for (ut32 i = bv->len - 1, j = 0; i > 0; --i, j++) {
        str[j] = rz_bv_get(bv, i) ? '1' : '0';
    }
    str[bv->len - 1] = rz_bv_get(bv, 0) ? '1' : '0';
    str[bv->len] = '\0';
 
    return str;
}

References i, malloc(), NULL, rz_bv_get(), rz_return_val_if_fail, and cmd_descs_generate::str.

Referenced by rz_il_handler_empty().

rz_bv_clz()

RZ_API ut32 rz_bv_clz

(

RZ_NONNULL RzBitVector *

bv

)

Count leading (most significant) zeroes All bits are considered leading zeroes for a zero bitvector.

Definition at line 1107 of file bitvector.c.

                                                  {
    rz_return_val_if_fail(bv, 0);
    ut32 r = 0;
    for (ut32 i = rz_bv_len(bv); i; i--) {
        if (rz_bv_get(bv, i - 1)) {
            break;
        }
        r++;
    }
    return r;
}

References i, r, rz_bv_get(), rz_bv_len(), and rz_return_val_if_fail.

Referenced by rz_bv_div().

rz_bv_cmp()

RZ_API bool rz_bv_cmp	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Check if x equals to y Both operands must have the same length.

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret int, return 1 if x != y, return 0 if x == y

Definition at line 1086 of file bitvector.c.

                                                                            {
    rz_return_val_if_fail(x && y, 0);
 
    if (x->len != y->len) {
        rz_warn_if_reached();
        return true;
    }
 
    for (ut32 i = 0; i < x->len; ++i) {
        if (rz_bv_get(x, i) != rz_bv_get(y, i)) {
            return true;
        }
    }
 
    return false;
}

References i, rz_bv_get(), rz_return_val_if_fail, rz_warn_if_reached, and x.

rz_bv_complement_1()

RZ_API RZ_OWN RzBitVector* rz_bv_complement_1

(

RZ_NONNULL RzBitVector *

bv

)

Get the 1's complement of bv

Parameters

bv	RzBitVector, operand

Returns

ret RzBitVector, a new bitvector, which is the 1's complement of bv

Definition at line 625 of file bitvector.c.

                                                                          {
    rz_return_val_if_fail(bv, NULL);
 
    RzBitVector *ret = rz_bv_new(bv->len);
    if (!ret) {
        return NULL;
    } else if (ret->len <= 64) {
        ret->bits.small_u = ~bv->bits.small_u;
        ret->bits.small_u &= UT64_MAX >> (64 - ret->len);
        return ret;
    }
 
    if (!(ret->bits.large_a && bv->bits.large_a)) {
        rz_bv_free(ret);
        rz_return_val_if_reached(NULL);
    }
    for (ut32 i = 0; i < bv->_elem_len; ++i) {
        ret->bits.large_a[i] = ~bv->bits.large_a[i];
    }
    return ret;
}

References bitvector_t::bits, i, bitvector_t::large_a, bitvector_t::len, NULL, rz_bv_free(), rz_bv_new(), rz_return_val_if_fail, rz_return_val_if_reached, bitvector_t::small_u, and UT64_MAX.

rz_bv_complement_2()

RZ_API RZ_OWN RzBitVector* rz_bv_complement_2

(

RZ_NONNULL RzBitVector *

bv

)

Get the 2's complement of bv

Parameters

bv	RzBitVector, operand

Returns

ret RzBitVector, a new bitvector, which is the 2's complement of bv

Definition at line 652 of file bitvector.c.

                                                                          {
    rz_return_val_if_fail(bv, NULL);
 
    // from right side to left, find the 1st 1 bit
    // flip/toggle every bit before it
    RzBitVector *ret = rz_bv_dup(bv);
 
    ut32 i;
    for (i = 0; i < bv->len; ++i) {
        if (rz_bv_get(bv, i) == true) {
            break;
        }
    }
 
    // assert bv[i] == true now
    i += 1;
    for (; i < bv->len; ++i) {
        rz_bv_toggle(ret, i);
    }
 
    return ret;
}

References i, NULL, rz_bv_dup(), rz_bv_get(), rz_bv_toggle(), and rz_return_val_if_fail.

rz_bv_copy()

RZ_API ut32 rz_bv_copy	(	RZ_NONNULL const RzBitVector *	src,
		RZ_NONNULL RzBitVector *	dst
	)

Copy from source bitvector to destination bitvector the maximum copied size depends on MIN(src_len, dst_len)

Parameters

src	RzBitVector, the source bitvector
dst	RzBitVector, the destination bitvector

Returns

Actual size of copy

Definition at line 186 of file bitvector.c.

                                                                                       {
    rz_return_val_if_fail(src && dst, 0);
 
    if (dst->len != src->len) {
        return 0;
    } else if (dst->len <= 64) {
        dst->bits.small_u = src->bits.small_u;
        return sizeof(dst->bits.small_u);
    }
 
    rz_return_val_if_fail(src->bits.large_a && dst->bits.large_a, 0);
    memcpy(dst->bits.large_a, src->bits.large_a, dst->_elem_len);
    return dst->_elem_len;
}

References dst, memcpy(), rz_return_val_if_fail, and src.

Referenced by rz_bv_dup(), rz_bv_lshift_fill(), rz_bv_mul(), and rz_bv_rshift_fill().

rz_bv_copy_nbits()

RZ_API ut32 rz_bv_copy_nbits	(	RZ_NONNULL const RzBitVector *	src,
		ut32	src_start_pos,
		RZ_NONNULL RzBitVector *	dst,
		ut32	dst_start_pos,
		ut32	nbit
	)

Copy n bits from start position of source to start position of dest, return num of copied bits

Parameters

src	RzBitVector, data source
src_start_pos	ut32, start position in source bitvector of copy
dst	RzBitVector, destination of copy
dst_start_pos	ut32, start position in destination bitvector
nbit	ut32, control the size of copy (in bits)

Returns

copied_size ut32, Actual copied size

Definition at line 210 of file bitvector.c.

                                                                                                                                                {
    rz_return_val_if_fail(src && dst, 0);
 
    ut32 max_nbit = RZ_MIN((src->len - src_start_pos),
        (dst->len - dst_start_pos));
 
    // prevent overflow
    if (max_nbit < nbit) {
        return 0;
    }
 
    // normal case here
    for (ut32 i = 0; i < nbit; ++i) {
        bool c = rz_bv_get(src, src_start_pos + i);
        rz_bv_set(dst, dst_start_pos + i, c);
    }
 
    return nbit;
}

References c, dst, i, rz_bv_get(), rz_bv_set(), RZ_MIN, rz_return_val_if_fail, and src.

Referenced by rz_bv_append(), rz_bv_lshift_fill(), rz_bv_rshift_fill(), rz_il_handler_cast(), rz_il_vm_sync_from_reg(), and rz_il_vm_sync_to_reg().

rz_bv_ctz()

RZ_API ut32 rz_bv_ctz

(

RZ_NONNULL RzBitVector *

bv

)

Count trailing (least significant) zeroes All bits are considered trailing zeroes for a zero bitvector.

Definition at line 1123 of file bitvector.c.

                                                  {
    rz_return_val_if_fail(bv, 0);
    ut32 r = 0;
    for (ut32 i = 0; i < rz_bv_len(bv); i++) {
        if (rz_bv_get(bv, i)) {
            break;
        }
        r++;
    }
    return r;
}

References i, r, rz_bv_get(), rz_bv_len(), and rz_return_val_if_fail.

rz_bv_cut_head()

RZ_API RZ_OWN RzBitVector* rz_bv_cut_head	(	RZ_NONNULL RzBitVector *	bv,
		ut32	delta_len
	)

Return a new bitvector, cut n zero bits from head

Parameters

bv	RzBitVector, pointer to bitvector
delta_len,the	number of zero bits

Returns

ret RzBitVector, pointert to the new btivector

Definition at line 281 of file bitvector.c.

                                                                                      {
    rz_return_val_if_fail(bv, NULL);
 
    ut32 new_len = bv->len - delta_len;
    RzBitVector *ret = rz_bv_new(new_len);
    if (!ret) {
        return NULL;
    }
 
    for (ut32 pos = 0; pos < new_len; ++pos) {
        rz_bv_set(ret, pos, rz_bv_get(bv, pos));
    }
 
    return ret;
}

References NULL, pos, rz_bv_get(), rz_bv_new(), rz_bv_set(), and rz_return_val_if_fail.

rz_bv_cut_tail()

RZ_API RZ_OWN RzBitVector* rz_bv_cut_tail	(	RZ_NONNULL RzBitVector *	bv,
		ut32	delta_len
	)

Return a new bitvector, cut n zero bits from tail

Parameters

bv	RzBitVector, pointer to bitvector
delta_len,the	number of zero bits

Returns

ret RzBitVector, pointert to the new btivector

Definition at line 303 of file bitvector.c.

                                                                                      {
    rz_return_val_if_fail(bv, NULL);
 
    ut32 new_len = bv->len - delta_len;
    RzBitVector *ret = rz_bv_new(new_len);
    if (!ret) {
        return NULL;
    }
 
    ut32 pos, i;
    for (pos = 0, i = delta_len; pos < new_len; ++i, ++pos) {
        rz_bv_set(ret, pos, rz_bv_get(bv, i));
    }
 
    return ret;
}

References i, NULL, pos, rz_bv_get(), rz_bv_new(), rz_bv_set(), and rz_return_val_if_fail.

rz_bv_div()

RZ_API RZ_OWN RzBitVector* rz_bv_div	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of (x / y) mod 2^length Both operands must have the same length. If y is a zero vector, the result defined as a vector of all ones.

Parameters

x	dividend
y	divisor

Returns

ret quotient, of the same length as the operands

Definition at line 808 of file bitvector.c.

                                                                                           {
    rz_return_val_if_fail(x && y && x->len == y->len, NULL);
 
    if (rz_bv_is_zero_vector(y)) {
        RzBitVector *ret = rz_bv_new(y->len);
        rz_bv_set_all(ret, true);
        return ret;
    }
 
    if (x->len <= 64) {
        return rz_bv_new_from_ut64(x->len, rz_bv_to_ut64(x) / rz_bv_to_ut64(y));
    }
 
    int compare_result = bv_unsigned_cmp(x, y);
    // dividend < divisor
    // remainder = dividend, quotient = 0
    if (compare_result < 0) {
        return rz_bv_new(x->len);
    }
    // dividend == divisor
    // remainder = 0, quotient = 1
    if (compare_result == 0) {
        return rz_bv_new_one(rz_bv_len(x));
    }
 
    // dividend > divisor
    // do typical division by shift and subtract
    RzBitVector *dend = rz_bv_dup(x);
    RzBitVector *sor = rz_bv_dup(y);
    // shift the divisor left to align both highest bits
    ut32 sorlz = rz_bv_clz(sor);
    ut32 shift = sorlz - rz_bv_clz(dend);
    rz_bv_lshift(sor, shift);
    RzBitVector *quot = rz_bv_new_zero(rz_bv_len(x));
    for (ut32 b = shift + 1; b; b--) {
        if (rz_bv_ule(sor, dend)) {
            rz_bv_set(quot, b - 1, true);
            RzBitVector *tmp = rz_bv_sub(dend, sor, NULL);
            rz_bv_free(dend);
            dend = tmp;
        }
        rz_bv_rshift(sor, 1);
    }
    rz_bv_free(dend);
    rz_bv_free(sor);
    return quot;
}

References b, bv_unsigned_cmp(), NULL, rz_bv_clz(), rz_bv_dup(), rz_bv_free(), rz_bv_is_zero_vector(), rz_bv_len(), rz_bv_lshift(), rz_bv_new(), rz_bv_new_from_ut64(), rz_bv_new_one, rz_bv_new_zero, rz_bv_rshift(), rz_bv_set(), rz_bv_set_all(), rz_bv_sub(), rz_bv_to_ut64(), rz_bv_ule(), rz_return_val_if_fail, shift(), autogen_x86imm::tmp, and x.

Referenced by rz_bv_mod(), rz_bv_sdiv(), and rz_il_handler_div().

rz_bv_dup()

RZ_API RZ_OWN RzBitVector* rz_bv_dup

(

const RZ_NONNULL RzBitVector *

bv

)

Clone a bitvector

Parameters

bv	RzBitVector, pointer to the source bitvector

Returns

dup RzBitVector, pointer to a new bitvector, which is a copy of source

Definition at line 167 of file bitvector.c.

                                                                       {
    rz_return_val_if_fail(bv, NULL);
 
    RzBitVector *new_bv = rz_bv_new(bv->len);
    if (!new_bv || !rz_bv_copy(bv, new_bv)) {
        rz_bv_free(new_bv);
        return NULL;
    }
 
    return new_bv;
}

References NULL, rz_bv_copy(), rz_bv_free(), rz_bv_new(), and rz_return_val_if_fail.

Referenced by rz_bv_complement_2(), rz_bv_div(), rz_bv_mod(), rz_il_effect_label_dup(), rz_il_event_mem_read_new(), rz_il_event_mem_write_new(), rz_il_event_pc_write_new(), rz_il_handler_bitv(), rz_il_handler_goto(), rz_il_handler_shiftl(), rz_il_handler_shiftr(), rz_il_handler_var(), rz_il_op_pure_dup(), rz_il_value_dup(), rz_il_value_to_bv(), rz_il_vm_create_label(), and rz_il_vm_update_label().

rz_bv_eq()

RZ_API bool rz_bv_eq	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Check if x == y

Definition at line 1041 of file bitvector.c.

                                                                           {
    rz_return_val_if_fail(x && y, false);
    return rz_bv_len(x) == rz_bv_len(y) && bv_unsigned_cmp(x, y) == 0;
}

References bv_unsigned_cmp(), rz_bv_len(), rz_return_val_if_fail, and x.

Referenced by rz_il_handler_eq(), and rz_il_value_eq().

rz_bv_fini()

RZ_API void rz_bv_fini

(

RZ_NONNULL RzBitVector *

bv

)

Clear a RzBitVector structure.

Definition at line 58 of file bitvector.c.

                                                   {
    rz_return_if_fail(bv);
    if (bv->len > 64) {
        free(bv->bits.large_a);
    }
    memset(bv, 0, sizeof(RzBitVector));
}

References free(), memset(), and rz_return_if_fail.

Referenced by rz_bv_free(), rz_bv_lshift_fill(), rz_bv_mul(), and rz_bv_rshift_fill().

rz_bv_free()

RZ_API void rz_bv_free

(

RZ_NULLABLE RzBitVector *

bv

)

Free a bitvector

Parameters

bv	RzBitVector, pointer to the bitvector you want to free

Definition at line 85 of file bitvector.c.

                                                    {
    if (!bv) {
        return;
    }
    rz_bv_fini(bv);
    free(bv);
}

References free(), and rz_bv_fini().

Referenced by bf_syscall_read(), bf_syscall_write(), perform_jump(), rz_bv_complement_1(), rz_bv_div(), rz_bv_dup(), rz_bv_mod(), rz_bv_mul(), rz_bv_sdiv(), rz_bv_smod(), rz_bv_sub(), rz_core_analysis_il_vm_set(), rz_il_effect_label_free(), rz_il_event_free(), rz_il_handler_add(), rz_il_handler_append(), rz_il_handler_cast(), rz_il_handler_div(), rz_il_handler_eq(), rz_il_handler_is_zero(), rz_il_handler_load(), rz_il_handler_loadw(), rz_il_handler_logical_and(), rz_il_handler_logical_not(), rz_il_handler_logical_or(), rz_il_handler_logical_xor(), rz_il_handler_lsb(), rz_il_handler_mod(), rz_il_handler_msb(), rz_il_handler_mul(), rz_il_handler_neg(), rz_il_handler_sdiv(), rz_il_handler_shiftl(), rz_il_handler_shiftr(), rz_il_handler_sle(), rz_il_handler_smod(), rz_il_handler_store(), rz_il_handler_storew(), rz_il_handler_sub(), rz_il_handler_ule(), rz_il_op_new_bitv_from_st64(), rz_il_op_new_bitv_from_ut64(), rz_il_op_pure_free(), rz_il_value_free(), rz_il_value_stringify(), rz_il_vm_fini(), rz_il_vm_mem_store(), rz_il_vm_mem_storew(), rz_il_vm_step(), rz_il_vm_sync_from_reg(), rz_il_vm_sync_to_reg(), and rz_il_vm_update_label().

rz_bv_get()

RZ_API bool rz_bv_get	(	RZ_NONNULL const RzBitVector *	bv,
		ut32	pos
	)

Get bit at position from bitvector

Parameters

bv	RzBitVector, pointer to bv
pos	int, position

Returns

ret bit, bool value of bit

Definition at line 429 of file bitvector.c.

                                                                  {
    rz_return_val_if_fail(bv && pos < bv->len, false);
    if (bv->len <= 64) {
        return (bv->bits.small_u >> pos) & 1;
    }
 
    rz_return_val_if_fail(bv->bits.large_a, false);
    return ((bv->bits.large_a)[pos / BV_ELEM_SIZE] & (1u << (pos % BV_ELEM_SIZE)));
}

References BV_ELEM_SIZE, len, pos, and rz_return_val_if_fail.

Referenced by bv_unsigned_cmp(), rz_bv_add(), rz_bv_append_zero(), rz_bv_as_string(), rz_bv_clz(), rz_bv_cmp(), rz_bv_complement_2(), rz_bv_copy_nbits(), rz_bv_ctz(), rz_bv_cut_head(), rz_bv_cut_tail(), rz_bv_lsb(), rz_bv_msb(), rz_bv_mul(), rz_bv_prepend_zero(), rz_bv_to_ut16(), rz_bv_to_ut32(), rz_bv_to_ut64(), rz_bv_to_ut8(), and rz_bv_toggle().

rz_bv_hash()

RZ_API ut32 rz_bv_hash

(

RZ_NULLABLE RzBitVector *

x

)

Calculates the hash from the bitvector data

Parameters

x

BitVector

Returns

ut32 bitvector hash

Definition at line 1372 of file bitvector.c.

                                                   {
    ut32 h = 5381;
    if (!x) {
        return h;
    }
 
    ut32 size = (x->len > 64) ? x->_elem_len : sizeof(x->bits.small_u);
    ut8 *bits = (x->len > 64) ? x->bits.large_a : (ut8 *)&x->bits.small_u;
    if (!size || !bits) {
        return h;
    }
 
    for (ut32 i = 0; i < size; ++i) {
        h = (h + (h << 5)) ^ bits[i];
    }
 
    h ^= x->len;
    return h;
}

References bits(), h, i, and x.

rz_bv_init()

RZ_API bool rz_bv_init	(	RZ_NONNULL RzBitVector *	bv,
		ut32	length
	)

Initialize a RzBitVector structure.

Parameters

bv	Pointer to a uninitialized RzBitVector instance
length	int, the length of bitvector

Returns

true if succeed

Definition at line 38 of file bitvector.c.

                                                                {
    rz_return_val_if_fail(bv && length, false);
    memset(bv, 0, sizeof(RzBitVector));
    if (length > 64) {
        // how much ut8 do we need to represent `length` bits ?
        size_t real_elem_cnt = NELEM(length, BV_ELEM_SIZE);
        ut8 *tmp = RZ_NEWS0(ut8, real_elem_cnt);
        if (!tmp) {
            return false;
        }
        bv->bits.large_a = tmp;
        bv->_elem_len = real_elem_cnt;
    }
    bv->len = length;
    return true;
}

References BV_ELEM_SIZE, length, memset(), NELEM, RZ_NEWS0, rz_return_val_if_fail, and autogen_x86imm::tmp.

Referenced by rz_bv_lshift_fill(), rz_bv_mul(), rz_bv_new(), and rz_bv_rshift_fill().

rz_bv_is_zero_vector()

RZ_API bool rz_bv_is_zero_vector

(

RZ_NONNULL const RzBitVector *

x

)

Check if the bitvector is zero

Parameters

x	RzBitVector, pointer to bv

Returns

ret bool, return true if bv is a zero bitvector, false if not

Definition at line 1021 of file bitvector.c.

                                                                  {
    rz_return_val_if_fail(x, false);
 
    if (x->len <= 64) {
        return x->bits.small_u == 0;
    }
 
    rz_return_val_if_fail(x->bits.large_a, false);
 
    for (ut32 i = 0; i < x->_elem_len; ++i) {
        if (x->bits.large_a[i] != 0) {
            return false;
        }
    }
    return true;
}

References i, rz_return_val_if_fail, and x.

Referenced by rz_bv_div(), rz_bv_mod(), rz_il_handler_div(), rz_il_handler_is_zero(), and rz_il_vm_sync_to_reg().

rz_bv_len()

RZ_API ut32 rz_bv_len

(

RZ_NONNULL const RzBitVector *

bv

)

Get the length of bitvector in bits

Parameters

bv	RzBitVector

Returns

len ut32, length of bitvector in bits

Definition at line 1140 of file bitvector.c.

                                                        {
    rz_return_val_if_fail(bv, 0);
    return bv->len;
}

References rz_return_val_if_fail.

Referenced by adjust_unsigned(), rz_bv_clz(), rz_bv_ctz(), rz_bv_div(), rz_bv_eq(), rz_il_mem_store(), rz_il_value_get_sort(), rz_il_vm_get_pc_len(), rz_il_vm_mem_storew(), rz_il_vm_sync_from_reg(), rz_il_vm_sync_to_reg(), rz_reg_set_bv(), and VALIDATOR_PURE().

rz_bv_len_bytes()

RZ_API ut32 rz_bv_len_bytes

(

RZ_NONNULL const RzBitVector *

bv

)

Get the length of bitvector in bytes

Parameters

bv	RzBitVector

Returns

len ut32, length of bitvector in bytes

Definition at line 1150 of file bitvector.c.

                                                              {
    rz_return_val_if_fail(bv, 0);
    return (bv->len + 7) >> 3;
}

References rz_return_val_if_fail.

Referenced by read_n_bits(), rz_bv_set_to_bytes_be(), rz_bv_set_to_bytes_le(), and write_n_bits().

rz_bv_lsb()

RZ_API bool rz_bv_lsb

(

RZ_NONNULL RzBitVector *

bv

)

Get the least significant bit of bitvector

Parameters

bv	RzBitVector, operand

Returns

b bit, bool value of LSB

Definition at line 1012 of file bitvector.c.

                                                  {
    return rz_bv_get(bv, 0);
}

References rz_bv_get().

Referenced by rz_il_handler_lsb().

rz_bv_lshift()

RZ_API bool rz_bv_lshift	(	RZ_NONNULL RzBitVector *	bv,
		ut32	size
	)

Left shift bitvector (WARN : This operation will change the bitvector in argument) Fill with zero bits when shift

Parameters

bv	RzBitVector, pointert to bv
size	int, shift bits

Returns

flag bool, success or not

Definition at line 446 of file bitvector.c.

                                                                {
    return rz_bv_lshift_fill(bv, size, false);
}

References rz_bv_lshift_fill().

Referenced by rz_bv_div(), and rz_bv_mul().

rz_bv_lshift_fill()

RZ_API bool rz_bv_lshift_fill	(	RZ_NONNULL RzBitVector *	bv,
		ut32	size,
		bool	fill_bit
	)

Left shift bitvector (WARN : This operation will change the bitvector in argument) Fill the bitvector with fill_bit

Parameters

bv	RzBitVector, pointert to bv
size	int, shift bits
fill_bit	bool, bit used in filling

Returns

flag bool, success or not

Definition at line 469 of file bitvector.c.

                                                                                    {
    rz_return_val_if_fail(bv, false);
 
    // left shift
    if (size == 0) {
        return false;
    }
 
    if (size >= bv->len) {
        rz_bv_set_all(bv, fill_bit);
        return true;
    }
 
    RzBitVector tmp;
    if (!rz_bv_init(&tmp, bv->len)) {
        return false;
    }
    rz_bv_set_all(&tmp, fill_bit);
 
    int copied_size = rz_bv_copy_nbits(bv, 0, &tmp, size, bv->len - size);
    if (copied_size == 0) {
        rz_bv_fini(&tmp);
        return false;
    }
 
    rz_bv_copy(&tmp, bv);
    rz_bv_fini(&tmp);
 
    return true;
}

References rz_bv_copy(), rz_bv_copy_nbits(), rz_bv_fini(), rz_bv_init(), rz_bv_set_all(), rz_return_val_if_fail, and autogen_x86imm::tmp.

Referenced by rz_bv_lshift(), and rz_il_handler_shiftl().

rz_bv_mod()

RZ_API RZ_OWN RzBitVector* rz_bv_mod	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of (x mod y) mod 2^length Both operands must have the same length. If y == 0, the result is x

Parameters

x	dividend
y	divisor

Returns

x - ((x / y) * y)

Definition at line 865 of file bitvector.c.

                                                                                           {
    rz_return_val_if_fail(x && y && x->len == y->len, NULL);
    if (rz_bv_is_zero_vector(y)) {
        return rz_bv_dup(x);
    }
    RzBitVector *quot = rz_bv_div(x, y);
    RzBitVector *remul = rz_bv_mul(quot, y);
    RzBitVector *r = rz_bv_sub(x, remul, NULL);
    rz_bv_free(quot);
    rz_bv_free(remul);
    return r;
}

References NULL, r, rz_bv_div(), rz_bv_dup(), rz_bv_free(), rz_bv_is_zero_vector(), rz_bv_mul(), rz_bv_sub(), rz_return_val_if_fail, and x.

Referenced by rz_bv_smod(), and rz_il_handler_mod().

rz_bv_msb()

RZ_API bool rz_bv_msb

(

RZ_NONNULL RzBitVector *

bv

)

Get the most significant bit of bitvector

Parameters

bv	RzBitVector, operand

Returns

b bit, bool value of MSB

Definition at line 1003 of file bitvector.c.

                                                  {
    return rz_bv_get(bv, bv->len - 1);
}

References rz_bv_get().

Referenced by rz_bv_sdiv(), rz_bv_sle(), rz_bv_smod(), and rz_il_handler_msb().

rz_bv_mul()

RZ_API RZ_OWN RzBitVector* rz_bv_mul	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of (x * y) mod 2^length Both operands must have the same length.

Parameters

x	RzBitVector, Operand
y	RzBitVector, Operand

Returns

ret RzBitVector, point to the new bitvector

Definition at line 734 of file bitvector.c.

                                                                                           {
    rz_return_val_if_fail(x && y, NULL);
 
    RzBitVector dump;
    bool cur_bit = false;
 
    if (x->len != y->len) {
        rz_warn_if_reached();
        return NULL;
    }
 
    if (!rz_bv_init(&dump, x->len)) {
        return NULL;
    }
    RzBitVector *result = rz_bv_new(x->len);
    if (!result) {
        goto exit;
    }
    rz_bv_copy(x, &dump);
 
    for (ut32 i = 0; i < y->len; ++i) {
        cur_bit = rz_bv_get(y, i);
        if (cur_bit) {
            RzBitVector *tmp = rz_bv_add(result, &dump, NULL);
            rz_bv_free(result);
            result = tmp;
        }
        rz_bv_lshift(&dump, 1);
    }
 
exit:
    rz_bv_fini(&dump);
    return result;
}

References test-lz4-list::exit, i, NULL, rz_bv_add(), rz_bv_copy(), rz_bv_fini(), rz_bv_free(), rz_bv_get(), rz_bv_init(), rz_bv_lshift(), rz_bv_new(), rz_return_val_if_fail, rz_warn_if_reached, autogen_x86imm::tmp, and x.

Referenced by rz_bv_mod(), and rz_il_handler_mul().

rz_bv_new()

RZ_API RZ_OWN RzBitVector* rz_bv_new

(

ut32

length

)

New a length-bits bitvector

Parameters

length

int, the length of bitvector

Returns

bv RzBitVector, pointer to the new bitvector instance

Definition at line 71 of file bitvector.c.

                                                  {
    rz_return_val_if_fail(length, NULL);
    RzBitVector *bv = RZ_NEW(RzBitVector);
    if (!bv || !rz_bv_init(bv, length)) {
        free(bv);
        return NULL;
    }
    return bv;
}

References free(), length, NULL, rz_bv_init(), RZ_NEW, and rz_return_val_if_fail.

Referenced by rz_bv_add(), rz_bv_and(), rz_bv_append(), rz_bv_append_zero(), rz_bv_complement_1(), rz_bv_cut_head(), rz_bv_cut_tail(), rz_bv_div(), rz_bv_dup(), rz_bv_mul(), rz_bv_new_from_bytes_be(), rz_bv_new_from_bytes_le(), rz_bv_new_from_st64(), rz_bv_new_from_ut64(), rz_bv_or(), rz_bv_prepend_zero(), rz_bv_xor(), rz_il_handler_cast(), and rz_il_handler_div().

rz_bv_new_from_bytes_be()

RZ_API RZ_OWN RzBitVector* rz_bv_new_from_bytes_be	(	RZ_IN RZ_NONNULL const ut8 *	buf,
		ut32	bit_offset,
		ut32	size
	)

Create a new bitvector of size bits and apply rz_bv_set_from_bytes_be() to it

Definition at line 1207 of file bitvector.c.

                                                                                                                {
    rz_return_val_if_fail(buf, NULL);
    RzBitVector *bv = rz_bv_new(size);
    if (!bv) {
        return NULL;
    }
    rz_bv_set_from_bytes_be(bv, buf, bit_offset, size);
    return bv;
}

References NULL, rz_bv_new(), rz_bv_set_from_bytes_be(), and rz_return_val_if_fail.

Referenced by rz_reg_get_bv().

rz_bv_new_from_bytes_le()

RZ_API RZ_OWN RzBitVector* rz_bv_new_from_bytes_le	(	RZ_IN RZ_NONNULL const ut8 *	buf,
		ut32	bit_offset,
		ut32	size
	)

Create a new bitvector of size bits and apply rz_bv_set_from_bytes_le() to it

Definition at line 1194 of file bitvector.c.

                                                                                                                {
    rz_return_val_if_fail(buf, NULL);
    RzBitVector *bv = rz_bv_new(size);
    if (!bv) {
        return NULL;
    }
    rz_bv_set_from_bytes_le(bv, buf, bit_offset, size);
    return bv;
}

References NULL, rz_bv_new(), rz_bv_set_from_bytes_le(), and rz_return_val_if_fail.

Referenced by rz_reg_get_bv().

rz_bv_new_from_st64()

RZ_API RZ_OWN RzBitVector* rz_bv_new_from_st64	(	ut32	length,
		st64	value
	)

Convert st64 to length-bits bitvector

Parameters

length	ut32, length of bitvector
value	st64, the value to convert

Returns

bv RzBitVector, pointer to new bitvector

Definition at line 1179 of file bitvector.c.

                                                                        {
    rz_return_val_if_fail(length > 0, NULL);
 
    RzBitVector *bv = rz_bv_new(length);
    if (!bv) {
        RZ_LOG_ERROR("RzIL: failed to allocate RzBitVector\n");
        return NULL;
    }
    rz_bv_set_from_st64(bv, value);
    return bv;
}

References length, NULL, rz_bv_new(), rz_bv_set_from_st64(), RZ_LOG_ERROR, rz_return_val_if_fail, and value.

Referenced by rz_il_op_new_bitv_from_st64().

rz_bv_new_from_ut64()

RZ_API RZ_OWN RzBitVector* rz_bv_new_from_ut64	(	ut32	length,
		ut64	value
	)

Convert ut64 to length-bits bitvector

Parameters

length	ut32, length of bitvector
value	ut64, the value to convert

Returns

bv RzBitVector, pointer to new bitvector

Definition at line 1161 of file bitvector.c.

                                                                        {
    rz_return_val_if_fail(length > 0, NULL);
 
    RzBitVector *bv = rz_bv_new(length);
    if (!bv) {
        RZ_LOG_ERROR("RzIL: failed to allocate RzBitVector\n");
        return NULL;
    }
    rz_bv_set_from_ut64(bv, value);
    return bv;
}

References length, NULL, rz_bv_new(), rz_bv_set_from_ut64(), RZ_LOG_ERROR, rz_return_val_if_fail, and value.

Referenced by bf_syscall_read(), il_config(), rz_bv_div(), rz_core_analysis_il_vm_set(), rz_il_mem_load(), rz_il_op_new_bitv_from_ut64(), rz_il_value_to_bv(), rz_il_vm_init(), and rz_il_vm_step().

rz_bv_or()

RZ_API RZ_OWN RzBitVector* rz_bv_or	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of x OR y (or operation to every bits) Both operands must have the same length.

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret RzBitVector, a new bitvector, which is the result of OR

Definition at line 573 of file bitvector.c.

                                                                                          {
    rz_return_val_if_fail(x && y, NULL);
    if (x->len != y->len) {
        return NULL;
    }
 
    RzBitVector *ret = rz_bv_new(x->len);
    if (!ret) {
        return NULL;
    } else if (x->len <= 64) {
        ret->bits.small_u = x->bits.small_u | y->bits.small_u;
        return ret;
    }
 
    for (ut32 i = 0; i < ret->_elem_len; ++i) {
        ret->bits.large_a[i] = x->bits.large_a[i] | y->bits.large_a[i];
    }
    return ret;
}

References bitvector_t::_elem_len, bitvector_t::bits, i, bitvector_t::large_a, NULL, rz_bv_new(), rz_return_val_if_fail, bitvector_t::small_u, and x.

Referenced by rz_il_handler_logical_or().

rz_bv_prepend_zero()

RZ_API RZ_OWN RzBitVector* rz_bv_prepend_zero	(	RZ_NONNULL RzBitVector *	bv,
		ut32	delta_len
	)

Return a new bitvector prepended with bv with n zero bits

Parameters

bv	RzBitVector, pointer to bitvector instance
delta_len	ut32, the number of zero bits

Returns

ret RzBitVector, pointer to the new bitvector instance

Definition at line 236 of file bitvector.c.

                                                                                          {
    rz_return_val_if_fail(bv, NULL);
 
    ut32 new_len = bv->len + delta_len;
    RzBitVector *ret = rz_bv_new(new_len);
    if (ret == NULL) {
        return NULL;
    }
 
    for (ut32 i = 0; i < bv->len; ++i) {
        rz_bv_set(ret, i, rz_bv_get(bv, i));
    }
 
    return ret;
}

References i, NULL, rz_bv_get(), rz_bv_new(), rz_bv_set(), and rz_return_val_if_fail.

rz_bv_rshift()

RZ_API bool rz_bv_rshift	(	RZ_NONNULL RzBitVector *	bv,
		ut32	size
	)

Right shift bitvector (WARN : This operation will change the bitvector in argument) Fill with zero bits when shift

Parameters

bv	RzBitVector, pointert to bv
size	int, shift bits

Returns

flag bool, success or not

Definition at line 457 of file bitvector.c.

                                                                {
    return rz_bv_rshift_fill(bv, size, false);
}

References rz_bv_rshift_fill().

Referenced by rz_bv_div().

rz_bv_rshift_fill()

RZ_API bool rz_bv_rshift_fill	(	RZ_NONNULL RzBitVector *	bv,
		ut32	size,
		bool	fill_bit
	)

Right shift bitvector (WARN : This operation will change the bitvector in argument) Fill the bitvector with fill_bit

Parameters

bv	RzBitVector, pointert to bv
size	int, shift bits
fill_bit	bool, bit used in filling

Returns

flag bool, success or not

Definition at line 508 of file bitvector.c.

                                                                                    {
    rz_return_val_if_fail(bv, false);
 
    // left shift
    if (size == 0) {
        return false;
    }
 
    if (size >= bv->len) {
        rz_bv_set_all(bv, fill_bit);
        return true;
    }
 
    RzBitVector tmp;
    if (!rz_bv_init(&tmp, bv->len)) {
        return false;
    }
    rz_bv_set_all(&tmp, fill_bit);
 
    int copied_size = rz_bv_copy_nbits(bv, size, &tmp, 0, bv->len - size);
    if (copied_size == 0) {
        rz_bv_fini(&tmp);
        return false;
    }
 
    rz_bv_copy(&tmp, bv);
    rz_bv_fini(&tmp);
 
    return true;
}

References rz_bv_copy(), rz_bv_copy_nbits(), rz_bv_fini(), rz_bv_init(), rz_bv_set_all(), rz_return_val_if_fail, and autogen_x86imm::tmp.

Referenced by rz_bv_rshift(), and rz_il_handler_shiftr().

rz_bv_sdiv()

RZ_API RZ_OWN RzBitVector* rz_bv_sdiv	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of (x / y) mod 2^length (signed algorithm) / | div x y : if not mx /\ not my | neg (div (neg x) y) if mx /\ not my x sdiv y = < | neg (div x (neg y)) if not mx /\ my | div (neg x) (neg y) if mx /\ my \

where mx = msb x, and my = msb y.

Parameters

x	RzBitVector, Operand
y	RzBitVector, Operand

Returns

ret RzBitVector, point to the new bitvector

Definition at line 893 of file bitvector.c.

                                                                                            {
    rz_return_val_if_fail(x && y, NULL);
    bool mx = rz_bv_msb(x);
    bool my = rz_bv_msb(y);
 
    RzBitVector *neg_x, *neg_y, *tmp, *ret;
 
    if ((!mx) && (!my)) {
        return rz_bv_div(x, y);
    }
 
    if ((mx) && (!my)) {
        neg_x = rz_bv_neg(x);
        tmp = rz_bv_div(neg_x, y);
        ret = rz_bv_neg(tmp);
 
        rz_bv_free(tmp);
        rz_bv_free(neg_x);
        return ret;
    }
 
    if ((!mx) && (my)) {
        neg_y = rz_bv_neg(y);
        tmp = rz_bv_div(x, neg_y);
        ret = rz_bv_neg(tmp);
 
        rz_bv_free(tmp);
        rz_bv_free(neg_y);
        return ret;
    }
 
    if (mx && my) {
        neg_x = rz_bv_neg(x);
        neg_y = rz_bv_neg(y);
 
        ret = rz_bv_div(neg_x, neg_y);
        rz_bv_free(neg_x);
        rz_bv_free(neg_y);
        return ret;
    }
 
    return NULL; // something wrong
}

References NULL, rz_bv_div(), rz_bv_free(), rz_bv_msb(), rz_bv_neg, rz_return_val_if_fail, autogen_x86imm::tmp, and x.

Referenced by rz_il_handler_sdiv().

rz_bv_set()

RZ_API bool rz_bv_set	(	RZ_NONNULL RzBitVector *	bv,
		ut32	pos,
		bool	b
	)

Set a bit at position to true or false

Parameters

bv	RzBitVector, pointer to bv
pos	ut32, position
b	bit, true or false (set or unset)

Returns

ret bool, bool value at pos after this operation

Definition at line 341 of file bitvector.c.

                                                                    {
    rz_return_val_if_fail(bv && pos < bv->len, false);
    if (bv->len <= 64) {
        if (b) {
            bv->bits.small_u |= (1ull << pos);
        } else {
            bv->bits.small_u &= ~(1ull << pos);
        }
        return b;
    }
    rz_return_val_if_fail(bv->bits.large_a, false);
 
    if (b) {
        bv->bits.large_a[pos / BV_ELEM_SIZE] |= (1u << (pos % BV_ELEM_SIZE));
    } else {
        bv->bits.large_a[pos / BV_ELEM_SIZE] &= ~(1u << (pos % BV_ELEM_SIZE));
    }
    return b;
}

References b, BV_ELEM_SIZE, len, pos, and rz_return_val_if_fail.

Referenced by rz_bv_add(), rz_bv_append_zero(), rz_bv_copy_nbits(), rz_bv_cut_head(), rz_bv_cut_tail(), rz_bv_div(), rz_bv_prepend_zero(), rz_bv_set_from_bytes_be(), rz_bv_set_from_bytes_le(), rz_bv_set_from_st64(), rz_bv_set_from_ut64(), and rz_bv_toggle().

rz_bv_set_all()

RZ_API bool rz_bv_set_all	(	RZ_NONNULL RzBitVector *	bv,
		bool	b
	)

Set all bits to true or false

Parameters

bv	RzBitVector, pointer to bv
b	bit, true or false (set or unset)

Returns

ret bool, bool value at every positions after this operation

Definition at line 367 of file bitvector.c.

                                                              {
    rz_return_val_if_fail(bv, false);
 
    if (bv->len <= 64) {
        bv->bits.small_u = b ? UT64_MAX >> (64 - bv->len) : 0;
        return b;
    }
 
    rz_return_val_if_fail(bv->bits.large_a, false);
    if (b) {
        memset(bv->bits.large_a, 0xff, bv->_elem_len);
        ut32 mod = bv->len % BV_ELEM_SIZE;
        if (mod) {
            bv->bits.large_a[bv->len / BV_ELEM_SIZE] = rz_num_bitmask(mod);
        }
    } else {
        memset(bv->bits.large_a, 0, bv->_elem_len);
    }
 
    return b;
}

References b, BV_ELEM_SIZE, memset(), mod(), rz_num_bitmask(), rz_return_val_if_fail, and UT64_MAX.

Referenced by rz_bv_div(), rz_bv_lshift_fill(), rz_bv_rshift_fill(), rz_il_handler_cast(), rz_il_handler_div(), and rz_il_vm_sync_from_reg().

rz_bv_set_from_bytes_be()

RZ_API void rz_bv_set_from_bytes_be	(	RZ_NONNULL RzBitVector *	bv,
		RZ_IN RZ_NONNULL const ut8 *	buf,
		ut32	bit_offset,
		ut32	size
	)

Set the bitvector's contents from the given bits. The bitvector's size is unchanged. If bv->len < size, additional bits are cut off, if bv->len > size, the rest is filled up with 0.

Parameters

buf	big endian buffer of at least (bit_offset + size + 7) / 8 bytes
bit_offset	offset inside buf to start reading from, in bits
size	number of bits to read from buf

Definition at line 1296 of file bitvector.c.

                                                                                                                             {
    rz_return_if_fail(buf && size);
    size = RZ_MIN(size, bv->len);
    // upper bits goes always in the upper bit of the bitv
    for (ut32 i = 0; i < bv->len; i++) {
        bool bit = false;
        if (i < size) {
            ut32 idx = (bit_offset + i) >> 3;
            ut32 sh = ((bit_offset + i) & 7);
            ut8 b8 = buf[idx];
            b8 = (size < 8) ? reverse_lt_8bits(b8, size) : (ut8)reverse_byte(b8);
            bit = (b8 >> sh) & 1;
        }
        rz_bv_set(bv, bv->len - 1 - i, bit);
    }
}

References bit, i, setup::idx, reverse_byte, reverse_lt_8bits(), rz_bv_set(), RZ_MIN, rz_return_if_fail, and ut8.

Referenced by read_n_bits(), and rz_bv_new_from_bytes_be().

rz_bv_set_from_bytes_le()

RZ_API void rz_bv_set_from_bytes_le	(	RZ_NONNULL RzBitVector *	bv,
		RZ_IN RZ_NONNULL const ut8 *	buf,
		ut32	bit_offset,
		ut32	size
	)

Set the bitvector's contents from the given bits. The bitvector's size is unchanged. If bv->len < size, additional bits are cut off, if bv->len > size, the rest is filled up with 0.

Parameters

buf	little endian buffer of at least (bit_offset + size + 7) / 8 bytes
bit_offset	offset inside buf to start reading from, in bits
size	number of bits to read from buf

Definition at line 1265 of file bitvector.c.

                                                                                                                             {
    rz_return_if_fail(buf && size);
    size = RZ_MIN(size, bv->len);
    if (!bit_offset && size <= 64) {
        ut64 val = 0;
        for (ut32 i = 0; i < (size + 7) / 8; i++) {
            val |= (ut64)buf[i] << (i * 8);
        }
        val &= (UT64_MAX >> (64 - size));
        rz_bv_set_from_ut64(bv, val);
        return;
    }
    for (ut32 i = 0; i < bv->len; i++) {
        bool bit = false;
        if (i < size) {
            ut32 idx = (bit_offset + i) >> 3;
            ut32 sh = (bit_offset + i) & 7;
            bit = (buf[idx] >> sh) & 1;
        }
        rz_bv_set(bv, i, bit);
    }
}

References bit, i, setup::idx, rz_bv_set(), rz_bv_set_from_ut64(), RZ_MIN, rz_return_if_fail, ut64(), UT64_MAX, and val.

Referenced by read_n_bits(), and rz_bv_new_from_bytes_le().

rz_bv_set_from_st64()

RZ_API bool rz_bv_set_from_st64	(	RZ_NONNULL RzBitVector *	bv,
		st64	value
	)

Convert st64 to N-bits bitvector

Parameters

bv	RzBitVector, pointer to bitvector
value	st64, the value to convert

Definition at line 1243 of file bitvector.c.

                                                                        {
    rz_return_val_if_fail(bv, false);
    if (bv->len <= 64) {
        bv->bits.small_u = *((ut64 *)&value);
        bv->bits.small_u &= (UT64_MAX >> (64 - bv->len));
        return true;
    }
 
    for (ut32 i = 0; i < bv->len; ++i) {
        rz_bv_set(bv, i, value & 1);
        value >>= 1;
    }
    return true;
}

References i, rz_bv_set(), rz_return_val_if_fail, ut64(), UT64_MAX, and value.

Referenced by rz_bv_new_from_st64().

rz_bv_set_from_ut64()

RZ_API bool rz_bv_set_from_ut64	(	RZ_NONNULL RzBitVector *	bv,
		ut64	value
	)

Convert ut64 to N-bits bitvector

Parameters

bv	RzBitVector, pointer to bitvector
value	ut64, the value to convert

Definition at line 1222 of file bitvector.c.

                                                                        {
    rz_return_val_if_fail(bv, false);
 
    if (bv->len <= 64) {
        bv->bits.small_u = value;
        bv->bits.small_u &= (UT64_MAX >> (64 - bv->len));
        return true;
    }
 
    for (ut32 i = 0; i < bv->len; ++i) {
        rz_bv_set(bv, i, value & 1);
        value >>= 1;
    }
    return true;
}

References i, rz_bv_set(), rz_return_val_if_fail, UT64_MAX, and value.

Referenced by rz_bv_new_from_ut64(), rz_bv_set_from_bytes_le(), and rz_il_vm_sync_to_reg().

rz_bv_set_to_bytes_be()

RZ_API void rz_bv_set_to_bytes_be	(	RZ_NONNULL const RzBitVector *	bv,
		RZ_OUT RZ_NONNULL ut8 *	buf
	)

Set the buffer contents from the given bitvector's bits in big endian format.

Parameters

bv	BitVector to use as source of the bits
buf	buffer to write big endian data.

Definition at line 1349 of file bitvector.c.

                                                                                                {
    rz_return_if_fail(bv && buf);
    ut32 bytes = rz_bv_len_bytes(bv);
    if (bv->len > 64) {
        ut32 end = bytes - 1;
        for (ut32 i = 0; i < bytes; i++) {
            buf[end - i] = bv->bits.large_a[i];
        }
        return;
    }
    ut64 val = bv->bits.small_u;
    for (ut32 i = bytes - 1; i; i--) {
        buf[i] = val & 0xFF;
        val >>= 8;
    }
    buf[0] = val & 0xFF;
}

References bytes, test_evm::end, i, rz_bv_len_bytes(), rz_return_if_fail, ut64(), and val.

Referenced by rz_reg_set_bv(), and write_n_bits().

rz_bv_set_to_bytes_le()

RZ_API void rz_bv_set_to_bytes_le	(	RZ_NONNULL const RzBitVector *	bv,
		RZ_OUT RZ_NONNULL ut8 *	buf
	)

Set the buffer contents from the given bitvector's bits in little endian format.

Parameters

bv	BitVector to use as source of the bits
buf	buffer to write little endian data.

Definition at line 1318 of file bitvector.c.

                                                                                                {
    rz_return_if_fail(bv && buf);
    ut32 bytes = rz_bv_len_bytes(bv);
    if (bv->len > 64) {
        for (ut32 i = 0; i < bytes; i++) {
            if (i + 1 == bytes && bv->len % 8) {
                buf[i] &= (0xff << (bv->len % 8)) & 0xff;
                buf[i] |= bv->bits.large_a[i];
            } else {
                buf[i] = bv->bits.large_a[i];
            }
        }
        return;
    }
    ut64 val = bv->bits.small_u;
    for (ut32 i = 0; i < bytes; i++) {
        if (i + 1 == bytes && bv->len % 8) {
            buf[i] &= (0xff << (bv->len % 8)) & 0xff;
            buf[i] |= val & 0xff;
        } else {
            buf[i] = val & 0xff;
        }
        val >>= 8;
    }
}

References bytes, i, rz_bv_len_bytes(), rz_return_if_fail, ut64(), and val.

Referenced by rz_reg_set_bv(), and write_n_bits().

rz_bv_sle()

RZ_API bool rz_bv_sle	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Check if x <= y (as signed value)

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret bool, return true if x <= y, else return false

Definition at line 1064 of file bitvector.c.

                                                                            {
    rz_return_val_if_fail(x && y, false);
    bool x_msb = rz_bv_msb(x);
    bool y_msb = rz_bv_msb(y);
 
    if (x_msb == y_msb) {
        return rz_bv_ule(x, y);
    }
 
    // if x_msb set, y_msb unset => x < y
    // if x_msb unset, y_msb set => x > y
    // x != y when reaches here
    return x_msb;
}

References rz_bv_msb(), rz_bv_ule(), rz_return_val_if_fail, and x.

Referenced by rz_il_handler_sle().

rz_bv_smod()

RZ_API RZ_OWN RzBitVector* rz_bv_smod	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of (x mod y) mod 2^length (signed algorithm) / | x % y : if not mx /\ not my | neg (neg x % y) if mx /\ not my x smodulo y = < | neg (x % (neg y)) if not mx /\ my | neg (neg x % neg y) mod m if mx /\ my \

where mx = msb x and my = msb y.

Parameters

x	RzBitVector, Operand
y	RzBitVector, Operand

Returns

ret RzBitVector, point to the new bitvector

Definition at line 952 of file bitvector.c.

                                                                                            {
    rz_return_val_if_fail(x && y, NULL);
    bool mx = rz_bv_msb(x);
    bool my = rz_bv_msb(y);
 
    RzBitVector *neg_x, *neg_y, *tmp, *ret;
 
    if ((!mx) && (!my)) {
        return rz_bv_mod(x, y);
    }
 
    if ((mx) && (!my)) {
        neg_x = rz_bv_neg(x);
        tmp = rz_bv_mod(neg_x, y);
        ret = rz_bv_neg(tmp);
 
        rz_bv_free(tmp);
        rz_bv_free(neg_x);
        return ret;
    }
 
    if ((!mx) && (my)) {
        neg_y = rz_bv_neg(y);
        tmp = rz_bv_mod(x, neg_y);
        ret = rz_bv_neg(tmp);
 
        rz_bv_free(tmp);
        rz_bv_free(neg_y);
        return ret;
    }
 
    if (mx && my) {
        neg_x = rz_bv_neg(x);
        neg_y = rz_bv_neg(y);
 
        tmp = rz_bv_mod(neg_x, neg_y);
        ret = rz_bv_neg(tmp);
        rz_bv_free(neg_x);
        rz_bv_free(neg_y);
        rz_bv_free(tmp);
        return ret;
    }
 
    return NULL; // something wrong
}

References NULL, rz_bv_free(), rz_bv_mod(), rz_bv_msb(), rz_bv_neg, rz_return_val_if_fail, autogen_x86imm::tmp, and x.

Referenced by rz_il_handler_smod().

rz_bv_sub()

RZ_API RZ_OWN RzBitVector* rz_bv_sub	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y,
		RZ_NULLABLE bool *	borrow
	)

Result of (x - y) mod 2^length Both operands must have the same length.

Parameters

x	RzBitVector, Operand
y	RzBitVector, Operand
borrow	bool*, bool pointer to where to save the borrow value.

Returns

ret RzBitVector, point to the new bitvector

Definition at line 715 of file bitvector.c.

                                                                                                                     {
    rz_return_val_if_fail(x && y, NULL);
 
    RzBitVector *ret;
    RzBitVector *neg_y;
 
    neg_y = rz_bv_neg(y);
    ret = rz_bv_add(x, neg_y, borrow);
    rz_bv_free(neg_y);
    return ret;
}

References NULL, rz_bv_add(), rz_bv_free(), rz_bv_neg, rz_return_val_if_fail, and x.

Referenced by rz_bv_div(), rz_bv_mod(), and rz_il_handler_sub().

rz_bv_to_ut16()

RZ_API ut16 rz_bv_to_ut16

(

RZ_NONNULL const RzBitVector *

x

)

Convert bitv to ut16 value

Parameters

x

BitVector

Returns

ut16 value

Definition at line 1416 of file bitvector.c.

                                                           {
    rz_return_val_if_fail(x, 0);
    if (x->len <= 64) {
        return (ut16)x->bits.small_u & UT16_MAX;
    }
    ut16 ret = 0;
    for (ut32 i = 0; i < x->len && i < 16; ++i) {
        if (rz_bv_get(x, i)) {
            ret |= 1 << i;
        }
    }
    return ret;
}

References i, rz_bv_get(), rz_return_val_if_fail, UT16_MAX, and x.

rz_bv_to_ut32()

RZ_API ut32 rz_bv_to_ut32

(

RZ_NONNULL const RzBitVector *

x

)

Convert bitv to ut32 value

Parameters

x

BitVector

Returns

ut32 value

Definition at line 1435 of file bitvector.c.

                                                           {
    rz_return_val_if_fail(x, 0);
    if (x->len <= 64) {
        return (ut32)x->bits.small_u & UT32_MAX;
    }
    ut32 ret = 0;
    for (ut32 i = 0; i < x->len && i < 32; ++i) {
        if (rz_bv_get(x, i)) {
            ret |= 1 << i;
        }
    }
    return ret;
}

References i, rz_bv_get(), rz_return_val_if_fail, UT32_MAX, and x.

Referenced by bf_syscall_write(), rz_il_handler_shiftl(), and rz_il_handler_shiftr().

rz_bv_to_ut64()

RZ_API ut64 rz_bv_to_ut64

(

RZ_NONNULL const RzBitVector *

x

)

Convert RzBitVector to ut64

Parameters

x	RzBitVector, pointer to the bitvector

Returns

ret ut64, num value of bitvector

Definition at line 1454 of file bitvector.c.

                                                           {
    rz_return_val_if_fail(x, 0);
    if (x->len <= 64) {
        return x->bits.small_u;
    }
    ut64 ret = 0;
    for (ut32 i = 0; i < x->len && i < 64; ++i) {
        if (rz_bv_get(x, i)) {
            ret |= 1ULL << i;
        }
    }
    return ret;
}

References i, rz_bv_get(), rz_return_val_if_fail, ut64(), and x.

Referenced by read_n_bits(), rz_analysis_il_vm_step(), rz_bv_div(), rz_il_mem_load(), rz_il_mem_store(), rz_reg_set_bv(), and write_n_bits().

rz_bv_to_ut8()

RZ_API ut8 rz_bv_to_ut8

(

RZ_NONNULL const RzBitVector *

x

)

Convert bitv to a ut8 value

Parameters

x

BitVector

Returns

ut8 value

Definition at line 1397 of file bitvector.c.

                                                         {
    rz_return_val_if_fail(x, 0);
    if (x->len <= 64) {
        return (ut8)x->bits.small_u & UT8_MAX;
    }
    ut8 ret = 0;
    for (ut32 i = 0; i < x->len && i < 8; ++i) {
        if (rz_bv_get(x, i)) {
            ret |= 1 << i;
        }
    }
    return ret;
}

References i, rz_bv_get(), rz_return_val_if_fail, UT8_MAX, and x.

Referenced by rz_il_mem_store().

rz_bv_toggle()

RZ_API bool rz_bv_toggle	(	RZ_NONNULL RzBitVector *	bv,
		ut32	pos
	)

Invert a bit at position

Parameters

bv	RzBitVector, pointer to bv
pos	ut32, position
b	bit, true or false (set or unset)

Returns

ret bool, bool value at pos after this operation

Definition at line 396 of file bitvector.c.

                                                               {
    rz_return_val_if_fail(bv, false);
    bool cur_bit = rz_bv_get(bv, pos);
    bool new_bit = !cur_bit;
    rz_bv_set(bv, pos, new_bit);
    return new_bit;
}

References pos, rz_bv_get(), rz_bv_set(), and rz_return_val_if_fail.

Referenced by rz_bv_complement_2().

rz_bv_toggle_all()

RZ_API bool rz_bv_toggle_all

(

RZ_NONNULL RzBitVector *

bv

)

Invert all bits

Parameters

bv	RzBitVector, pointer to bv
b	bit, true or false (set or unset)

Returns

ret bool, bool value at every positions after this operation

Definition at line 410 of file bitvector.c.

                                                         {
    rz_return_val_if_fail(bv, false);
    if (bv->len <= 64) {
        bv->bits.small_u = ~(bv->bits.small_u);
    }
 
    rz_return_val_if_fail(bv->bits.large_a, false);
    for (ut32 i = 0; i < bv->_elem_len; ++i) {
        bv->bits.large_a[i] = ~(bv->bits.large_a[i]);
    }
    return true;
}

References i, and rz_return_val_if_fail.

rz_bv_ule()

RZ_API bool rz_bv_ule	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Check if x <= y (as unsigned value)

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret bool, return true if x <= y, else return false

Definition at line 1052 of file bitvector.c.

                                                                            {
    rz_return_val_if_fail(x && y, false);
    // x > y ? return false : return true
    return bv_unsigned_cmp(x, y) <= 0;
}

References bv_unsigned_cmp(), rz_return_val_if_fail, and x.

Referenced by rz_bv_div(), rz_bv_sle(), and rz_il_handler_ule().

rz_bv_xor()

RZ_API RZ_OWN RzBitVector* rz_bv_xor	(	RZ_NONNULL RzBitVector *	x,
		RZ_NONNULL RzBitVector *	y
	)

Result of x XOR y (xor operation to every bits) Both operands must have the same length.

Parameters

x	RzBitVector, operand
y	RzBitVector, operand

Returns

ret RzBitVector, a new bitvector, which is the result of XOR

Definition at line 600 of file bitvector.c.

                                                                                           {
    rz_return_val_if_fail(x && y, NULL);
    if (x->len != y->len) {
        return NULL;
    }
 
    RzBitVector *ret = rz_bv_new(x->len);
    if (!ret) {
        return NULL;
    } else if (x->len <= 64) {
        ret->bits.small_u = x->bits.small_u ^ y->bits.small_u;
        return ret;
    }
 
    for (ut32 i = 0; i < ret->_elem_len; ++i) {
        ret->bits.large_a[i] = x->bits.large_a[i] ^ y->bits.large_a[i];
    }
    return ret;
}

References bitvector_t::_elem_len, bitvector_t::bits, i, bitvector_t::large_a, NULL, rz_bv_new(), rz_return_val_if_fail, bitvector_t::small_u, and x.

Referenced by rz_il_handler_logical_xor().