theory_bitv.c File Reference

#include <rz_il/rz_il_opcodes.h>
#include <rz_il/rz_il_vm.h>

Go to the source code of this file.

Functions
void *	rz_il_handler_msb (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_lsb (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_is_zero (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_neg (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_logical_not (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_eq (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_sle (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_ule (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_add (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_append (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_logical_and (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_logical_or (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_logical_xor (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_sub (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_mul (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_div (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_sdiv (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_mod (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_smod (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_shiftl (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_shiftr (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_bitv (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)
void *	rz_il_handler_cast (RzILVM *vm, RzILOpBitVector *op, RzILTypePure *type)

Function Documentation

rz_il_handler_add()

void* rz_il_handler_add	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 114 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsAdd *op_add = &op->op.add;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_add->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_add->y);
    RzBitVector *result = x && y ? rz_bv_add(x, y, NULL) : NULL;
 
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_add(), rz_bv_free(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_append()

void* rz_il_handler_append	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 130 of file theory_bitv.c.

                                                                                {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsAppend *op_append = &op->op.append;
 
    RzBitVector *high = rz_il_evaluate_bitv(vm, op_append->high);
    RzBitVector *low = rz_il_evaluate_bitv(vm, op_append->low);
    RzBitVector *result = high && low ? rz_bv_append(high, low) : NULL;
    rz_bv_free(low);
    rz_bv_free(high);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References rz_il_op_args_append_t::high, rz_il_op_args_append_t::low, NULL, rz_bv_append(), rz_bv_free(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, and type.

rz_il_handler_bitv()

void* rz_il_handler_bitv	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 336 of file theory_bitv.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
    RzILOpArgsBv *op_bitv = &op->op.bitv;
 
    RzBitVector *bv = rz_bv_dup(op_bitv->value);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return bv;
}

References NULL, rz_bv_dup(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, and rz_il_op_args_bv_t::value.

rz_il_handler_cast()

void* rz_il_handler_cast	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 346 of file theory_bitv.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsCast *op_cast = &op->op.cast;
    RzILBool *fill = rz_il_evaluate_bool(vm, op_cast->fill);
    if (!fill) {
        return NULL;
    }
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_cast->val);
    if (!bv) {
        return NULL;
    }
 
    RzBitVector *ret = rz_bv_new(op_cast->length);
    rz_bv_set_all(ret, fill->b);
    rz_bv_copy_nbits(bv, 0, ret, 0, RZ_MIN(bv->len, ret->len));
 
    rz_il_bool_free(fill);
    rz_bv_free(bv);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return ret;
}

References rz_il_bool_t::b, rz_il_op_args_cast_t::fill, bitvector_t::len, rz_il_op_args_cast_t::length, NULL, rz_bv_copy_nbits(), rz_bv_free(), rz_bv_new(), rz_bv_set_all(), rz_il_bool_free(), rz_il_evaluate_bitv(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BITVECTOR, RZ_MIN, rz_return_val_if_fail, type, and rz_il_op_args_cast_t::val.

rz_il_handler_div()

void* rz_il_handler_div	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 221 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsDiv *op_div = &op->op.div;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_div->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_div->y);
    RzBitVector *result = NULL;
    if (x && y) {
        if (rz_bv_is_zero_vector(y)) {
            result = rz_bv_new(y->len);
            rz_bv_set_all(result, true);
            rz_il_vm_event_add(vm, rz_il_event_exception_new("division by zero"));
        } else {
            result = rz_bv_div(x, y);
        }
    }
 
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References bitvector_t::len, NULL, rz_bv_div(), rz_bv_free(), rz_bv_is_zero_vector(), rz_bv_new(), rz_bv_set_all(), rz_il_evaluate_bitv(), rz_il_event_exception_new(), RZ_IL_TYPE_PURE_BITVECTOR, rz_il_vm_event_add(), rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_eq()

void* rz_il_handler_eq	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 69 of file theory_bitv.c.

                                                                            {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsSle *op_sle = &op->op.sle;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_sle->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_sle->y);
    RzILBool *result = x && y ? rz_il_bool_new(rz_bv_eq(x, y)) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_bv_eq(), rz_bv_free(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_cmp_t::x, and rz_il_op_args_cmp_t::y.

rz_il_handler_is_zero()

void* rz_il_handler_is_zero	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 31 of file theory_bitv.c.

                                                                                 {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsLsb *op_lsb = &op->op.lsb;
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_lsb->bv);
    RzILBool *result = bv ? rz_il_bool_new(rz_bv_is_zero_vector(bv)) : NULL;
    rz_bv_free(bv);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References rz_il_op_args_un_bv_b_t::bv, NULL, rz_bv_free(), rz_bv_is_zero_vector(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, and type.

rz_il_handler_logical_and()

void* rz_il_handler_logical_and	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 145 of file theory_bitv.c.

                                                                                     {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsAdd *op_add = &op->op.add;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_add->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_add->y);
    RzBitVector *result = x && y ? rz_bv_and(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_and(), rz_bv_free(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_logical_not()

void* rz_il_handler_logical_not	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 56 of file theory_bitv.c.

                                                                                     {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsLogNot *op_not = &op->op.lognot;
 
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_not->bv);
    RzBitVector *result = bv ? rz_bv_not(bv) : NULL;
    rz_bv_free(bv);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References rz_il_op_args_bv_unop_t::bv, NULL, rz_bv_free(), rz_bv_not, rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, and type.

rz_il_handler_logical_or()

void* rz_il_handler_logical_or	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 160 of file theory_bitv.c.

                                                                                    {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsAdd *op_add = &op->op.add;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_add->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_add->y);
    RzBitVector *result = x && y ? rz_bv_or(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_or(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_logical_xor()

void* rz_il_handler_logical_xor	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 175 of file theory_bitv.c.

                                                                                     {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsAdd *op_add = &op->op.add;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_add->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_add->y);
    RzBitVector *result = x && y ? rz_bv_xor(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_xor(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_lsb()

void* rz_il_handler_lsb	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 19 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsLsb *op_lsb = &op->op.lsb;
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_lsb->bv);
    RzILBool *result = bv ? rz_il_bool_new(rz_bv_lsb(bv)) : NULL;
    rz_bv_free(bv);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References rz_il_op_args_un_bv_b_t::bv, NULL, rz_bv_free(), rz_bv_lsb(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, and type.

rz_il_handler_mod()

void* rz_il_handler_mod	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 261 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsMod *op_mod = &op->op.mod;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_mod->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_mod->y);
    RzBitVector *result = x && y ? rz_bv_mod(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_mod(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_msb()

void* rz_il_handler_msb	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 7 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsMsb *op_msb = &op->op.msb;
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_msb->bv);
    RzILBool *result = bv ? rz_il_bool_new(rz_bv_msb(bv)) : NULL;
    rz_bv_free(bv);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References rz_il_op_args_un_bv_b_t::bv, NULL, rz_bv_free(), rz_bv_msb(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, and type.

rz_il_handler_mul()

void* rz_il_handler_mul	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 205 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsMul *op_mul = &op->op.mul;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_mul->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_mul->y);
    RzBitVector *result = x && y ? rz_bv_mul(x, y) : NULL;
 
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_mul(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_neg()

void* rz_il_handler_neg	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 43 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsNeg *neg = &op->op.neg;
 
    RzBitVector *bv_arg = rz_il_evaluate_bitv(vm, neg->bv);
    RzBitVector *bv_result = bv_arg ? rz_bv_neg(bv_arg) : NULL;
    rz_bv_free(bv_arg);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return bv_result;
}

References neg(), NULL, rz_bv_free(), rz_bv_neg, rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, and type.

rz_il_handler_sdiv()

void* rz_il_handler_sdiv	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 246 of file theory_bitv.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsSdiv *op_sdiv = &op->op.sdiv;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_sdiv->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_sdiv->y);
    RzBitVector *result = x && y ? rz_bv_sdiv(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_sdiv(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_shiftl()

void* rz_il_handler_shiftl	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 291 of file theory_bitv.c.

                                                                                {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsShiftLeft *op_shiftl = &op->op.shiftl;
 
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_shiftl->x);
    RzBitVector *shift = rz_il_evaluate_bitv(vm, op_shiftl->y);
    RzILBool *fill_bit = rz_il_evaluate_bool(vm, op_shiftl->fill_bit);
 
    RzBitVector *result = NULL;
    if (bv && shift && fill_bit) {
        result = rz_bv_dup(bv);
        rz_bv_lshift_fill(result, rz_bv_to_ut32(shift), fill_bit->b);
    }
    rz_bv_free(shift);
    rz_bv_free(bv);
    rz_il_bool_free(fill_bit);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References rz_il_bool_t::b, rz_il_op_args_shift_t::fill_bit, NULL, rz_bv_dup(), rz_bv_free(), rz_bv_lshift_fill(), rz_bv_to_ut32(), rz_il_bool_free(), rz_il_evaluate_bitv(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, shift(), type, rz_il_op_args_shift_t::x, and rz_il_op_args_shift_t::y.

rz_il_handler_shiftr()

void* rz_il_handler_shiftr	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 313 of file theory_bitv.c.

                                                                                {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsShiftRight *op_shr = &op->op.shiftr;
 
    RzBitVector *bv = rz_il_evaluate_bitv(vm, op_shr->x);
    RzBitVector *shift = rz_il_evaluate_bitv(vm, op_shr->y);
    RzILBool *fill_bit = rz_il_evaluate_bool(vm, op_shr->fill_bit);
 
    RzBitVector *result = NULL;
    if (bv && shift && fill_bit) {
        result = rz_bv_dup(bv);
        rz_bv_rshift_fill(result, rz_bv_to_ut32(shift), fill_bit->b);
    }
 
    rz_bv_free(shift);
    rz_bv_free(bv);
    rz_il_bool_free(fill_bit);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References rz_il_bool_t::b, rz_il_op_args_shift_t::fill_bit, NULL, rz_bv_dup(), rz_bv_free(), rz_bv_rshift_fill(), rz_bv_to_ut32(), rz_il_bool_free(), rz_il_evaluate_bitv(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, shift(), type, rz_il_op_args_shift_t::x, and rz_il_op_args_shift_t::y.

rz_il_handler_sle()

void* rz_il_handler_sle	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 84 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsSle *op_sle = &op->op.sle;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_sle->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_sle->y);
    RzILBool *result = x && y ? rz_il_bool_new(rz_bv_sle(x, y)) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_bv_free(), rz_bv_sle(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_cmp_t::x, and rz_il_op_args_cmp_t::y.

rz_il_handler_smod()

void* rz_il_handler_smod	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 276 of file theory_bitv.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsSmod *op_smod = &op->op.smod;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_smod->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_smod->y);
    RzBitVector *result = x && y ? rz_bv_smod(x, y) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_smod(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_sub()

void* rz_il_handler_sub	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 190 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsSub *op_sub = &op->op.sub;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_sub->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_sub->y);
    RzBitVector *result = x && y ? rz_bv_sub(x, y, NULL) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return result;
}

References NULL, rz_bv_free(), rz_bv_sub(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_return_val_if_fail, type, x, rz_il_op_args_alg_log_operations_t::x, and rz_il_op_args_alg_log_operations_t::y.

rz_il_handler_ule()

void* rz_il_handler_ule	(	RzILVM *	vm,
		RzILOpBitVector *	op,
		RzILTypePure *	type
	)

Definition at line 99 of file theory_bitv.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsUle *op_ule = &op->op.ule;
 
    RzBitVector *x = rz_il_evaluate_bitv(vm, op_ule->x);
    RzBitVector *y = rz_il_evaluate_bitv(vm, op_ule->y);
    RzILBool *result = x && y ? rz_il_bool_new(rz_bv_ule(x, y)) : NULL;
    rz_bv_free(x);
    rz_bv_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_bv_free(), rz_bv_ule(), rz_il_bool_new(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_cmp_t::x, and rz_il_op_args_cmp_t::y.