il_vm_eval.c File Reference

#include <rz_il/rz_il_vm.h>

Go to the source code of this file.

Functions
void *	rz_il_handler_ite (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_var (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_let (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_bitv (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_msb (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_lsb (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_is_zero (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_eq (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_ule (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_sle (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_neg (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_logical_not (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_add (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_sub (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_mul (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_div (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_sdiv (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_mod (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_smod (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_shiftl (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_shiftr (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_logical_and (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_logical_or (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_logical_xor (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_bool_false (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
	also known as b0 More...
void *	rz_il_handler_bool_true (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
	also known as b1 More...
void *	rz_il_handler_bool_and (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_bool_or (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_bool_xor (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_bool_inv (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
	also known as boolean not More...
void *	rz_il_handler_cast (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
void *	rz_il_handler_append (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
bool	rz_il_handler_empty (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_nop (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_set (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_jmp (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_goto (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_seq (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_blk (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_repeat (RzILVM *vm, RzILOpEffect *op)
bool	rz_il_handler_branch (RzILVM *vm, RzILOpEffect *op)
void *	rz_il_handler_load (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
bool	rz_il_handler_store (RzILVM *vm, RzILOpEffect *op)
void *	rz_il_handler_loadw (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
bool	rz_il_handler_storew (RzILVM *vm, RzILOpEffect *op)
void *	rz_il_handler_pure_unimplemented (RzILVM *vm, RzILOpPure *op, RzILTypePure *type)
bool	rz_il_handler_effect_unimplemented (RzILVM *vm, RzILOpEffect *op)
RZ_API RzBitVector *	rz_il_vm_mem_load (RzILVM *vm, RzILMemIndex index, RzBitVector *key)
RZ_API void	rz_il_vm_mem_store (RzILVM *vm, RzILMemIndex index, RzBitVector *key, RzBitVector *value)
RZ_API RzBitVector *	rz_il_vm_mem_loadw (RzILVM *vm, RzILMemIndex index, RzBitVector *key, ut32 n_bits)
RZ_API void	rz_il_vm_mem_storew (RzILVM *vm, RzILMemIndex index, RzBitVector *key, RzBitVector *value)
RZ_API void	rz_il_vm_event_add (RzILVM *vm, RzILEvent *evt)
RZ_API void	rz_il_vm_clear_events (RzILVM *vm)
RZ_API bool	rz_il_vm_step (RzILVM *vm, RzILOpEffect *op, ut64 fallthrough_addr)
static void *	eval_pure (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpPure *op, RZ_NONNULL RzILTypePure *type)
static bool	eval_effect (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpEffect *op)
static const char *	pure_type_name (RzILTypePure type)
RZ_API RZ_NULLABLE RZ_OWN RzBitVector *	rz_il_evaluate_bitv (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpBitVector *op)
RZ_API RZ_NULLABLE RZ_OWN RzILBool *	rz_il_evaluate_bool (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpBool *op)
RZ_API RZ_NULLABLE RZ_OWN RzILVal *	rz_il_evaluate_val (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpPure *op)
RZ_API RZ_NULLABLE RZ_OWN void *	rz_il_evaluate_pure (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpPure *op, RZ_NONNULL RzILTypePure *type)
RZ_API bool	rz_il_evaluate_effect (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILOpEffect *op)

Variables
RZ_IPI RzILOpPureHandler	rz_il_op_handler_pure_table_default [RZ_IL_OP_PURE_MAX]
RZ_IPI RzILOpEffectHandler	rz_il_op_handler_effect_table_default [RZ_IL_OP_EFFECT_MAX]

Detailed Description

RzIL Virtual Machine Evaluation (Emulation)

Definition in file il_vm_eval.c.

Function Documentation

eval_effect()

static bool eval_effect ( RZ_NONNULL RzILVM *  vm, RZ_NONNULL RzILOpEffect *  op  )

static

Definition at line 247 of file il_vm_eval.c.

                                                                            {
    rz_return_val_if_fail(vm && op, NULL);
    RzILOpEffectHandler handler = vm->op_handler_effect_table[op->code];
    rz_return_val_if_fail(handler, NULL);
    return handler(vm, op);
}

References op::code, NULL, and rz_return_val_if_fail.

Referenced by rz_il_evaluate_effect().

eval_pure()

static void* eval_pure ( RZ_NONNULL RzILVM *  vm, RZ_NONNULL RzILOpPure *  op, RZ_NONNULL RzILTypePure *  type  )

static

Definition at line 240 of file il_vm_eval.c.

                                                                                                        {
    rz_return_val_if_fail(vm && op && type, NULL);
    RzILOpPureHandler handler = vm->op_handler_pure_table[op->code];
    rz_return_val_if_fail(handler, NULL);
    return handler(vm, op, type);
}

References op::code, NULL, rz_return_val_if_fail, and type.

Referenced by rz_il_evaluate_bitv(), rz_il_evaluate_bool(), rz_il_evaluate_pure(), and rz_il_evaluate_val().

pure_type_name()

static const char* pure_type_name ( RzILTypePure  type )

static

Definition at line 254 of file il_vm_eval.c.

                                                     {
    switch (type) {
    case RZ_IL_TYPE_PURE_BITVECTOR:
        return "bitvector";
    case RZ_IL_TYPE_PURE_BOOL:
        return "bool";
    default:
        return "unknown";
    }
}

References RZ_IL_TYPE_PURE_BITVECTOR, RZ_IL_TYPE_PURE_BOOL, and type.

Referenced by rz_il_evaluate_bitv(), rz_il_evaluate_bool(), and rz_il_evaluate_val().

rz_il_evaluate_bitv()

RZ_API RZ_NULLABLE RZ_OWN RzBitVector* rz_il_evaluate_bitv	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILOpBitVector *	op
	)

Evaluate the given pure op, asserting it returns a bitvector.

Returns

value in bitvector, or NULL if an error occurred (e.g. the op returned some other type)

Definition at line 269 of file il_vm_eval.c.

                                                                                                                  {
    rz_return_val_if_fail(vm && op, NULL);
    // check type and auto convertion between bitv/bool/val
    RzILTypePure type = -1;
    void *res = eval_pure(vm, op, &type);
    if (!res) {
        // propagate error
        return NULL;
    }
    if (type != RZ_IL_TYPE_PURE_BITVECTOR) {
        RZ_LOG_ERROR("RzIL: type error: expected bitvector, got %s\n", pure_type_name(type));
        return NULL;
    }
    return res;
}

References eval_pure(), NULL, pure_type_name(), RZ_IL_TYPE_PURE_BITVECTOR, RZ_LOG_ERROR, rz_return_val_if_fail, and type.

Referenced by 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_jmp(), 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(), and rz_il_handler_ule().

rz_il_evaluate_bool()

RZ_API RZ_NULLABLE RZ_OWN RzILBool* rz_il_evaluate_bool	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILOpBool *	op
	)

Evaluate the given pure op, asserting it returns a bool.

Returns

value in bool, or NULL if an error occurred (e.g. the op returned some other type)

Definition at line 289 of file il_vm_eval.c.

                                                                                                          {
    rz_return_val_if_fail(vm && op, NULL);
    // check type and auto convertion between bitv/bool/val
    RzILTypePure type = -1;
    void *res = eval_pure(vm, op, &type);
    if (!res) {
        // propagate error
        return NULL;
    }
    if (type != RZ_IL_TYPE_PURE_BOOL) {
        RZ_LOG_ERROR("RzIL: type error: expected bool, got %s\n", pure_type_name(type));
        return NULL;
    }
    return res;
}

References eval_pure(), NULL, pure_type_name(), RZ_IL_TYPE_PURE_BOOL, RZ_LOG_ERROR, rz_return_val_if_fail, and type.

Referenced by rz_il_handler_bool_and(), rz_il_handler_bool_inv(), rz_il_handler_bool_or(), rz_il_handler_bool_xor(), rz_il_handler_branch(), rz_il_handler_cast(), rz_il_handler_ite(), rz_il_handler_repeat(), rz_il_handler_shiftl(), and rz_il_handler_shiftr().

rz_il_evaluate_effect()

RZ_API bool rz_il_evaluate_effect	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILOpEffect *	op
	)

Evaluate (execute) the given effect op

Returns

false if an error occured and the execution should be aborted

Definition at line 341 of file il_vm_eval.c.

                                                                                      {
    rz_return_val_if_fail(vm && op, false);
    return eval_effect(vm, op);
}

References eval_effect(), and rz_return_val_if_fail.

Referenced by rz_il_handler_blk(), rz_il_handler_branch(), rz_il_handler_repeat(), rz_il_handler_seq(), and rz_il_vm_step().

rz_il_evaluate_pure()

RZ_API RZ_NULLABLE RZ_OWN void* rz_il_evaluate_pure	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILOpPure *	op,
		RZ_NONNULL RzILTypePure *	type
	)

Evaluate the given pure op, returning the resulting value and its type.

Definition at line 332 of file il_vm_eval.c.

                                                                                                                                     {
    rz_return_val_if_fail(vm && op, NULL);
    return eval_pure(vm, op, type);
}

References eval_pure(), NULL, rz_return_val_if_fail, and type.

Referenced by rz_il_handler_ite(), and rz_il_handler_let().

rz_il_evaluate_val()

RZ_API RZ_NULLABLE RZ_OWN RzILVal* rz_il_evaluate_val	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILOpPure *	op
	)

Evaluate the given pure op, returning the resulting bool or bitvector.

Returns

val, RzILVal*, RzILVal type value

Definition at line 309 of file il_vm_eval.c.

                                                                                                        {
    rz_return_val_if_fail(vm && op, NULL);
    // check type and auto convertion between bitv/bool/val
    RzILTypePure type = -1;
    void *res = eval_pure(vm, op, &type);
    if (!res) {
        // propagate error
        return NULL;
    }
    switch (type) {
    case RZ_IL_TYPE_PURE_BOOL:
        return rz_il_value_new_bool(res);
    case RZ_IL_TYPE_PURE_BITVECTOR:
        return rz_il_value_new_bitv(res);
    default:
        RZ_LOG_ERROR("RzIL: type error: got %s\n", pure_type_name(type));
        return NULL;
    }
}

References eval_pure(), NULL, pure_type_name(), RZ_IL_TYPE_PURE_BITVECTOR, RZ_IL_TYPE_PURE_BOOL, rz_il_value_new_bitv(), rz_il_value_new_bool(), RZ_LOG_ERROR, rz_return_val_if_fail, and type.

Referenced by rz_il_handler_let(), and rz_il_handler_set().

rz_il_handler_add()

void* rz_il_handler_add	(	RzILVM *	vm,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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_blk()

bool rz_il_handler_blk	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 89 of file theory_effect.c.

                                                     {
    rz_return_val_if_fail(vm && op, false);
 
    RzILOpArgsBlk *op_blk = &op->op.blk;
    if (op_blk->label) {
        rz_il_vm_create_label(vm, op_blk->label, vm->pc); // create the label if `blk` is labelled
    }
 
    return rz_il_evaluate_effect(vm, op_blk->data_eff) && rz_il_evaluate_effect(vm, op_blk->ctrl_eff);
}

References rzil_op_blk_t::ctrl_eff, rzil_op_blk_t::data_eff, rzil_op_blk_t::label, rz_il_vm_t::pc, rz_il_evaluate_effect(), rz_il_vm_create_label(), and rz_return_val_if_fail.

rz_il_handler_bool_and()

void* rz_il_handler_bool_and	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 29 of file theory_bool.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsBoolAnd *op_and = &op->op.booland;
    RzILBool *x = rz_il_evaluate_bool(vm, op_and->x);
    RzILBool *y = rz_il_evaluate_bool(vm, op_and->y);
 
    RzILBool *result = x && y ? rz_il_bool_and(x, y) : NULL;
    rz_il_bool_free(x);
    rz_il_bool_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_il_bool_and(), rz_il_bool_free(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_bool_operation_t::x, and rz_il_op_args_bool_operation_t::y.

rz_il_handler_bool_false()

void* rz_il_handler_bool_false	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

also known as b0

Definition at line 10 of file theory_bool.c.

                                                                               {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILBool *ret = rz_il_bool_new(false);
    *type = RZ_IL_TYPE_PURE_BOOL;
    return ret;
}

References NULL, rz_il_bool_new(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, and type.

rz_il_handler_bool_inv()

void* rz_il_handler_bool_inv	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

also known as boolean not

Definition at line 77 of file theory_bool.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsBoolInv *op_inv = &op->op.boolinv;
    RzILBool *x = rz_il_evaluate_bool(vm, op_inv->x);
    RzILBool *result = x ? rz_il_bool_not(x) : NULL;
    rz_il_bool_free(x);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_il_bool_free(), rz_il_bool_not(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, and rz_il_op_args_bool_inv_t::x.

rz_il_handler_bool_or()

void* rz_il_handler_bool_or	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 44 of file theory_bool.c.

                                                                            {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsBoolOr *op_or = &op->op.boolor;
    RzILBool *x = rz_il_evaluate_bool(vm, op_or->x);
    RzILBool *y = rz_il_evaluate_bool(vm, op_or->y);
 
    RzILBool *result = x && y ? rz_il_bool_or(x, y) : NULL;
    rz_il_bool_free(x);
    rz_il_bool_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_il_bool_free(), rz_il_bool_or(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_bool_operation_t::x, and rz_il_op_args_bool_operation_t::y.

rz_il_handler_bool_true()

void* rz_il_handler_bool_true	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

also known as b1

Definition at line 21 of file theory_bool.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILBool *ret = rz_il_bool_new(true);
    *type = RZ_IL_TYPE_PURE_BOOL;
    return ret;
}

References NULL, rz_il_bool_new(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, and type.

rz_il_handler_bool_xor()

void* rz_il_handler_bool_xor	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 59 of file theory_bool.c.

                                                                             {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsBoolXor *op_xor = &op->op.boolxor;
    RzILBool *x = rz_il_evaluate_bool(vm, op_xor->x);
    RzILBool *y = rz_il_evaluate_bool(vm, op_xor->y);
 
    RzILBool *result = x && y ? rz_il_bool_xor(x, y) : NULL;
    rz_il_bool_free(x);
    rz_il_bool_free(y);
 
    *type = RZ_IL_TYPE_PURE_BOOL;
    return result;
}

References NULL, rz_il_bool_free(), rz_il_bool_xor(), rz_il_evaluate_bool(), RZ_IL_TYPE_PURE_BOOL, rz_return_val_if_fail, type, x, rz_il_op_args_bool_operation_t::x, and rz_il_op_args_bool_operation_t::y.

rz_il_handler_branch()

bool rz_il_handler_branch	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 118 of file theory_effect.c.

                                                        {
    rz_return_val_if_fail(vm && op, false);
 
    RzILOpArgsBranch *op_branch = &op->op.branch;
 
    RzILBool *condition = rz_il_evaluate_bool(vm, op_branch->condition);
    if (!condition) {
        return false;
    }
    bool ret;
    if (condition->b) {
        ret = rz_il_evaluate_effect(vm, op_branch->true_eff);
    } else {
        ret = rz_il_evaluate_effect(vm, op_branch->false_eff);
    }
    rz_il_bool_free(condition);
 
    return ret;
}

References rz_il_bool_t::b, rz_il_op_args_branch_t::condition, rz_il_op_args_branch_t::false_eff, rz_il_bool_free(), rz_il_evaluate_bool(), rz_il_evaluate_effect(), rz_return_val_if_fail, and rz_il_op_args_branch_t::true_eff.

rz_il_handler_cast()

void* rz_il_handler_cast	(	RzILVM *	vm,
		RzILOpPure *	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,
		RzILOpPure *	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_effect_unimplemented()

bool rz_il_handler_effect_unimplemented	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 76 of file theory_init.c.

                                                                      {
    rz_return_val_if_fail(vm && op, NULL);
    RZ_LOG_ERROR("RzIL: unimplemented op handler (%d).\n", (int)op->code);
    return false;
}

References op::code, NULL, RZ_LOG_ERROR, and rz_return_val_if_fail.

rz_il_handler_empty()

bool rz_il_handler_empty	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 28 of file theory_effect.c.

                                                       {
    rz_return_val_if_fail(vm && op, false);
    RZ_LOG_WARN("Encountered an empty instruction at %s", rz_bv_as_string(vm->pc))
    return true;
}

References rz_il_vm_t::pc, rz_bv_as_string(), RZ_LOG_WARN, and rz_return_val_if_fail.

rz_il_handler_eq()

void* rz_il_handler_eq	(	RzILVM *	vm,
		RzILOpPure *	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_goto()

bool rz_il_handler_goto	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 66 of file theory_effect.c.

                                                      {
    rz_return_val_if_fail(vm && op, false);
    RzILOpArgsGoto *op_goto = &op->op.goto_;
    const char *lname = op_goto->lbl;
    RzILEffectLabel *label = rz_il_vm_find_label_by_name(vm, lname);
    if (!label) {
        return false;
    }
    if (label->type == EFFECT_LABEL_SYSCALL || label->type == EFFECT_LABEL_HOOK) {
        RzILVmHook internal_hook = (RzILVmHook)label->hook;
        internal_hook(vm, op);
    } else {
        perform_jump(vm, rz_bv_dup(label->addr));
    }
    return true;
}

References EFFECT_LABEL_HOOK, EFFECT_LABEL_SYSCALL, rz_il_op_args_goto_t::lbl, perform_jump(), rz_bv_dup(), rz_il_vm_find_label_by_name(), and rz_return_val_if_fail.

rz_il_handler_is_zero()

void* rz_il_handler_is_zero	(	RzILVM *	vm,
		RzILOpPure *	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_ite()

void* rz_il_handler_ite	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 7 of file theory_init.c.

                                                                        {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsIte *op_ite = &op->op.ite;
 
    RzILBool *condition = rz_il_evaluate_bool(vm, op_ite->condition);
    if (!condition) {
        return NULL;
    }
    RzILVal *ret;
    if (condition->b) {
        ret = rz_il_evaluate_pure(vm, op_ite->x, type); // true branch
    } else {
        ret = rz_il_evaluate_pure(vm, op_ite->y, type); // false branch
    }
    rz_il_bool_free(condition);
    return ret;
}

References rz_il_bool_t::b, rz_il_op_args_ite_t::condition, NULL, rz_il_bool_free(), rz_il_evaluate_bool(), rz_il_evaluate_pure(), rz_return_val_if_fail, type, rz_il_op_args_ite_t::x, and rz_il_op_args_ite_t::y.

rz_il_handler_jmp()

bool rz_il_handler_jmp	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 56 of file theory_effect.c.

                                                     {
    rz_return_val_if_fail(vm && op, false);
    RzBitVector *dst = rz_il_evaluate_bitv(vm, op->op.jmp.dst);
    if (!dst) {
        return false;
    }
    perform_jump(vm, dst);
    return true;
}

References dst, perform_jump(), rz_il_evaluate_bitv(), and rz_return_val_if_fail.

rz_il_handler_let()

void* rz_il_handler_let	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 57 of file theory_init.c.

                                                                        {
    rz_return_val_if_fail(vm && op && type, NULL);
    RzILOpArgsLet *args = &op->op.let;
    RzILVal *v = rz_il_evaluate_val(vm, args->exp);
    if (!v) {
        return NULL;
    }
    RzILLocalPurePrev prev = rz_il_vm_push_local_pure_var(vm, args->name, v);
    void *r = rz_il_evaluate_pure(vm, args->body, type);
    rz_il_vm_pop_local_pure_var(vm, args->name, prev);
    return r;
}

References args, NULL, r, rz_il_evaluate_pure(), rz_il_evaluate_val(), rz_il_vm_pop_local_pure_var(), rz_il_vm_push_local_pure_var(), rz_return_val_if_fail, type, and v.

rz_il_handler_load()

void* rz_il_handler_load	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 8 of file theory_mem.c.

                                                                              {
    rz_return_val_if_fail(vm && op && type, NULL);
    RzILOpArgsLoad *op_load = &op->op.load;
 
    RzBitVector *addr = rz_il_evaluate_bitv(vm, op_load->key);
    if (!addr) {
        return NULL;
    }
    RzBitVector *ret = rz_il_vm_mem_load(vm, op_load->mem, addr);
    rz_bv_free(addr);
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return ret;
}

References addr, rz_il_op_args_load_t::key, rz_il_op_args_load_t::mem, NULL, rz_bv_free(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_il_vm_mem_load(), rz_return_val_if_fail, and type.

rz_il_handler_loadw()

void* rz_il_handler_loadw	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 41 of file theory_mem.c.

                                                                               {
    rz_return_val_if_fail(vm && op && type, NULL);
    RzILOpArgsLoadW *op_loadw = &op->op.loadw;
 
    RzBitVector *addr = rz_il_evaluate_bitv(vm, op_loadw->key);
    if (!addr) {
        return NULL;
    }
    RzBitVector *ret = rz_il_vm_mem_loadw(vm, op_loadw->mem, addr, op_loadw->n_bits);
    rz_bv_free(addr);
    *type = RZ_IL_TYPE_PURE_BITVECTOR;
    return ret;
}

References addr, rz_il_op_args_loadw_t::key, rz_il_op_args_loadw_t::mem, rz_il_op_args_loadw_t::n_bits, NULL, rz_bv_free(), rz_il_evaluate_bitv(), RZ_IL_TYPE_PURE_BITVECTOR, rz_il_vm_mem_loadw(), rz_return_val_if_fail, and type.

rz_il_handler_logical_and()

void* rz_il_handler_logical_and	(	RzILVM *	vm,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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_nop()

bool rz_il_handler_nop	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 34 of file theory_effect.c.

                                                     {
    rz_return_val_if_fail(vm && op, false);
    return true;
}

References rz_return_val_if_fail.

rz_il_handler_pure_unimplemented()

void* rz_il_handler_pure_unimplemented	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 70 of file theory_init.c.

                                                                                       {
    rz_return_val_if_fail(vm && op && type, NULL);
    RZ_LOG_ERROR("RzIL: unimplemented op handler (%d).\n", (int)op->code);
    return NULL;
}

References op::code, NULL, RZ_LOG_ERROR, rz_return_val_if_fail, and type.

rz_il_handler_repeat()

bool rz_il_handler_repeat	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 100 of file theory_effect.c.

                                                        {
    rz_return_val_if_fail(vm && op, NULL);
 
    RzILOpArgsRepeat *op_repeat = &op->op.repeat;
    bool res = true;
    RzILBool *condition;
    while ((condition = rz_il_evaluate_bool(vm, op_repeat->condition))) {
        if (!condition->b) {
            break;
        }
        res = res && rz_il_evaluate_effect(vm, op_repeat->data_eff);
        rz_il_bool_free(condition);
    }
    rz_il_bool_free(condition);
 
    return res;
}

References rz_il_bool_t::b, rzil_op_repeat_t::condition, rzil_op_repeat_t::data_eff, NULL, rz_il_bool_free(), rz_il_evaluate_bool(), rz_il_evaluate_effect(), and rz_return_val_if_fail.

rz_il_handler_sdiv()

void* rz_il_handler_sdiv	(	RzILVM *	vm,
		RzILOpPure *	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_seq()

bool rz_il_handler_seq	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 83 of file theory_effect.c.

                                                     {
    rz_return_val_if_fail(vm && op, false);
    RzILOpArgsSeq *op_seq = &op->op.seq;
    return rz_il_evaluate_effect(vm, op_seq->x) && rz_il_evaluate_effect(vm, op_seq->y);
}

References rz_il_evaluate_effect(), rz_return_val_if_fail, rz_il_op_args_seq_t::x, and rz_il_op_args_seq_t::y.

rz_il_handler_set()

bool rz_il_handler_set	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 39 of file theory_effect.c.

                                                     {
    rz_return_val_if_fail(vm && op, false);
    RzILOpArgsSet *set_op = &op->op.set;
    RzILVal *val = rz_il_evaluate_val(vm, set_op->x);
    if (!val) {
        return false;
    }
    rz_il_set(vm, set_op->v, set_op->is_local, val);
    return true;
}

References rz_il_op_args_set_t::is_local, rz_il_evaluate_val(), rz_il_set(), rz_return_val_if_fail, rz_il_op_args_set_t::v, val, and rz_il_op_args_set_t::x.

rz_il_handler_shiftl()

void* rz_il_handler_shiftl	(	RzILVM *	vm,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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,
		RzILOpPure *	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_store()

bool rz_il_handler_store	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 22 of file theory_mem.c.

                                                       {
    rz_return_val_if_fail(vm && op, NULL);
 
    RzILOpArgsStore *op_store = &op->op.store;
 
    RzBitVector *addr = rz_il_evaluate_bitv(vm, op_store->key);
    RzBitVector *value = rz_il_evaluate_bitv(vm, op_store->value);
 
    bool ret = false;
    if (addr && value) {
        ret = true;
        rz_il_vm_mem_store(vm, op_store->mem, addr, value);
    }
    rz_bv_free(addr);
    rz_bv_free(value);
 
    return ret;
}

References addr, rz_il_op_args_store_t::key, rz_il_op_args_store_t::mem, NULL, rz_bv_free(), rz_il_evaluate_bitv(), rz_il_vm_mem_store(), rz_return_val_if_fail, value, and rz_il_op_args_store_t::value.

rz_il_handler_storew()

bool rz_il_handler_storew	(	RzILVM *	vm,
		RzILOpEffect *	op
	)

Definition at line 55 of file theory_mem.c.

                                                        {
    rz_return_val_if_fail(vm && op, NULL);
 
    RzILOpArgsStoreW *op_storew = &op->op.storew;
 
    RzBitVector *addr = rz_il_evaluate_bitv(vm, op_storew->key);
    RzBitVector *value = rz_il_evaluate_bitv(vm, op_storew->value);
 
    bool ret = false;
    if (addr && value) {
        ret = true;
        rz_il_vm_mem_storew(vm, op_storew->mem, addr, value);
    }
 
    rz_bv_free(addr);
    rz_bv_free(value);
 
    return ret;
}

References addr, rz_il_op_args_storew_t::key, rz_il_op_args_storew_t::mem, NULL, rz_bv_free(), rz_il_evaluate_bitv(), rz_il_vm_mem_storew(), rz_return_val_if_fail, value, and rz_il_op_args_storew_t::value.

rz_il_handler_sub()

void* rz_il_handler_sub	(	RzILVM *	vm,
		RzILOpPure *	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,
		RzILOpPure *	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.

rz_il_handler_var()

void* rz_il_handler_var	(	RzILVM *	vm,
		RzILOpPure *	op,
		RzILTypePure *	type
	)

Definition at line 26 of file theory_init.c.

                                                                        {
    rz_return_val_if_fail(vm && op && type, NULL);
 
    RzILOpArgsVar *var_op = &op->op.var;
    RzILVal *val = rz_il_vm_get_var_value(vm, var_op->kind, var_op->v);
    if (!val) {
        RZ_LOG_ERROR("RzIL: reading value of variable \"%s\" of kind %s failed.\n",
            var_op->v, rz_il_var_kind_name(var_op->kind));
        return NULL;
    }
 
    if (var_op->kind == RZ_IL_VAR_KIND_GLOBAL) {
        rz_il_vm_event_add(vm, rz_il_event_var_read_new(var_op->v, val));
    }
 
    void *ret = NULL;
    switch (val->type) {
    case RZ_IL_TYPE_PURE_BOOL:
        *type = RZ_IL_TYPE_PURE_BOOL;
        ret = rz_il_bool_new(val->data.b->b);
        break;
    case RZ_IL_TYPE_PURE_BITVECTOR:
        *type = RZ_IL_TYPE_PURE_BITVECTOR;
        ret = rz_bv_dup(val->data.bv);
        break;
    default:
        break;
    }
    return ret;
}

References rz_il_op_args_var_t::kind, NULL, rz_bv_dup(), rz_il_bool_new(), rz_il_event_var_read_new(), RZ_IL_TYPE_PURE_BITVECTOR, RZ_IL_TYPE_PURE_BOOL, RZ_IL_VAR_KIND_GLOBAL, rz_il_var_kind_name(), rz_il_vm_event_add(), rz_il_vm_get_var_value(), RZ_LOG_ERROR, rz_return_val_if_fail, type, rz_il_op_args_var_t::v, and val.

rz_il_vm_clear_events()

RZ_API void rz_il_vm_clear_events

(

RzILVM *

vm

)

Remove any recorded events from vm->events

Definition at line 212 of file il_vm_eval.c.

                                              {
    rz_list_purge(vm->events);
}

References rz_il_vm_t::events, and rz_list_purge().

Referenced by rz_il_vm_step().

rz_il_vm_event_add()

RZ_API void rz_il_vm_event_add	(	RzILVM *	vm,
		RzILEvent *	evt
	)

Adds to the VM a new event into the VM event list

Parameters

vm,RzILVM,pointer	to the VM
evt,RzILEvent,pointer	to the event

Definition at line 201 of file il_vm_eval.c.

                                                           {
    rz_return_if_fail(vm && vm->events && evt);
    if (!rz_list_append(vm->events, evt)) {
        rz_warn_if_reached();
        rz_il_event_free(evt);
    }
}

References rz_il_vm_t::events, rz_il_event_free(), rz_list_append(), rz_return_if_fail, and rz_warn_if_reached.

Referenced by perform_jump(), rz_il_handler_div(), rz_il_handler_var(), rz_il_set(), rz_il_vm_mem_load(), rz_il_vm_mem_loadw(), rz_il_vm_mem_store(), rz_il_vm_mem_storew(), and rz_il_vm_step().

rz_il_vm_mem_load()

RZ_API RzBitVector* rz_il_vm_mem_load	(	RzILVM *	vm,
		RzILMemIndex	index,
		RzBitVector *	key
	)

Load data from memory by given key and generates an RZ_IL_EVENT_MEM_READ event

Parameters

vm	RzILVM, pointer to VM
key	RzBitVector, aka address, a key to load data from memory

Returns

val Bitvector, data at the address, has vm->min_unit_size length

Definition at line 124 of file il_vm_eval.c.

                                                                                        {
    rz_return_val_if_fail(vm && key, NULL);
    RzILMem *mem = rz_il_vm_get_mem(vm, index);
    if (!mem) {
        RZ_LOG_ERROR("Non-existent mem %u referenced\n", (unsigned int)index);
        return NULL;
    }
    RzBitVector *value = rz_il_mem_load(mem, key);
    rz_il_vm_event_add(vm, rz_il_event_mem_read_new(key, value));
    return value;
}

References key, mem, NULL, rz_il_event_mem_read_new(), rz_il_mem_load(), rz_il_vm_event_add(), rz_il_vm_get_mem(), RZ_LOG_ERROR, rz_return_val_if_fail, and value.

Referenced by bf_syscall_write(), and rz_il_handler_load().

rz_il_vm_mem_loadw()

RZ_API RzBitVector* rz_il_vm_mem_loadw	(	RzILVM *	vm,
		RzILMemIndex	index,
		RzBitVector *	key,
		ut32	n_bits
	)

Load data from memory by given key and generates an RZ_IL_EVENT_MEM_READ event

Parameters

vm	RzILVM, pointer to VM
key	RzBitVector, aka address, a key to load data from memory

Returns

val Bitvector, data at the address, has vm->min_unit_size length

Definition at line 163 of file il_vm_eval.c.

                                                                                                      {
    rz_return_val_if_fail(vm && key, NULL);
    RzILMem *mem = rz_il_vm_get_mem(vm, index);
    if (!mem) {
        RZ_LOG_ERROR("Non-existent mem %u referenced\n", (unsigned int)index);
        return NULL;
    }
    RzBitVector *value = rz_il_mem_loadw(mem, key, n_bits, vm->big_endian);
    rz_il_vm_event_add(vm, rz_il_event_mem_read_new(key, value));
    return value;
}

References rz_il_vm_t::big_endian, key, mem, NULL, rz_il_event_mem_read_new(), rz_il_mem_loadw(), rz_il_vm_event_add(), rz_il_vm_get_mem(), RZ_LOG_ERROR, rz_return_val_if_fail, and value.

Referenced by rz_il_handler_loadw().

rz_il_vm_mem_store()

RZ_API void rz_il_vm_mem_store	(	RzILVM *	vm,
		RzILMemIndex	index,
		RzBitVector *	key,
		RzBitVector *	value
	)

Store data to memory by key, will create a key-value pair or update the key-value pair if key existed; also generates an RZ_IL_EVENT_MEM_WRITE event

Parameters

vm	RzILVM* pointer to VM
key	RzBitVector, aka address, a key to store data from memory
value	RzBitVector, aka value to store in memory

Definition at line 144 of file il_vm_eval.c.

                                                                                                     {
    rz_return_if_fail(vm && key && value);
    RzILMem *mem = rz_il_vm_get_mem(vm, index);
    if (!mem) {
        RZ_LOG_ERROR("Non-existent mem %u referenced\n", (unsigned int)index);
        return;
    }
    RzBitVector *old_value = rz_il_mem_load(mem, key);
    rz_il_mem_store(mem, key, value);
    rz_il_vm_event_add(vm, rz_il_event_mem_write_new(key, old_value, value));
    rz_bv_free(old_value);
}

References key, mem, rz_bv_free(), rz_il_event_mem_write_new(), rz_il_mem_load(), rz_il_mem_store(), rz_il_vm_event_add(), rz_il_vm_get_mem(), RZ_LOG_ERROR, rz_return_if_fail, and value.

Referenced by bf_syscall_read(), and rz_il_handler_store().

rz_il_vm_mem_storew()

RZ_API void rz_il_vm_mem_storew	(	RzILVM *	vm,
		RzILMemIndex	index,
		RzBitVector *	key,
		RzBitVector *	value
	)

Store data to memory by key, will create a key-value pair or update the key-value pair if key existed; also generates an RZ_IL_EVENT_MEM_WRITE event

Parameters

vm	RzILVM* pointer to VM
key	RzBitVector, aka address, a key to store data from memory
value	RzBitVector, aka value to store in memory

Definition at line 183 of file il_vm_eval.c.

                                                                                                      {
    rz_return_if_fail(vm && key && value);
    RzILMem *mem = rz_il_vm_get_mem(vm, index);
    if (!mem) {
        RZ_LOG_ERROR("Non-existent mem %u referenced\n", (unsigned int)index);
        return;
    }
    RzBitVector *old_value = rz_il_mem_loadw(mem, key, rz_bv_len(value), vm->big_endian);
    rz_il_mem_storew(mem, key, value, vm->big_endian);
    rz_il_vm_event_add(vm, rz_il_event_mem_write_new(key, old_value, value));
    rz_bv_free(old_value);
}

References rz_il_vm_t::big_endian, key, mem, rz_bv_free(), rz_bv_len(), rz_il_event_mem_write_new(), rz_il_mem_loadw(), rz_il_mem_storew(), rz_il_vm_event_add(), rz_il_vm_get_mem(), RZ_LOG_ERROR, rz_return_if_fail, and value.

Referenced by rz_il_handler_storew().

rz_il_vm_step()

RZ_API bool rz_il_vm_step	(	RzILVM *	vm,
		RzILOpEffect *	op,
		ut64	fallthrough_addr
	)

Execute the opcodes uplifted from raw instructions.A list may contain multiple opcode trees

Parameters

vm	pointer to VM
op_list,a	list of op roots.
fallthrough_addr	initial address to set PC to. Thus also the address to "step to" if no explicit jump occurs.

Definition at line 222 of file il_vm_eval.c.

                                                                               {
    rz_return_val_if_fail(vm && op, false);
 
    rz_il_vm_clear_events(vm);
 
    // Set the successor pc **before** evaluating. Any jmp/goto may then overwrite it again.
    RzBitVector *next_pc = rz_bv_new_from_ut64(vm->pc->len, fallthrough_addr);
    rz_il_vm_event_add(vm, rz_il_event_pc_write_new(vm->pc, next_pc));
    rz_bv_free(vm->pc);
    vm->pc = next_pc;
 
    bool succ = rz_il_evaluate_effect(vm, op);
 
    // remove any local defined variable (local pure vars are unbound automatically)
    rz_il_var_set_reset(&vm->local_vars);
    return succ;
}

References bitvector_t::len, rz_il_vm_t::local_vars, rz_il_vm_t::pc, rz_bv_free(), rz_bv_new_from_ut64(), rz_il_evaluate_effect(), rz_il_event_pc_write_new(), rz_il_var_set_reset(), rz_il_vm_clear_events(), rz_il_vm_event_add(), and rz_return_val_if_fail.

Referenced by rz_analysis_il_vm_step().

Variable Documentation

rz_il_op_handler_effect_table_default

RZ_IPI RzILOpEffectHandler rz_il_op_handler_effect_table_default[RZ_IL_OP_EFFECT_MAX]

Initial value:

= {
    [RZ_IL_OP_EMPTY] = rz_il_handler_empty,
    [RZ_IL_OP_STORE] = rz_il_handler_store,
    [RZ_IL_OP_STOREW] = rz_il_handler_storew,
    [RZ_IL_OP_NOP] = rz_il_handler_nop,
    [RZ_IL_OP_SET] = rz_il_handler_set,
    [RZ_IL_OP_JMP] = rz_il_handler_jmp,
    [RZ_IL_OP_GOTO] = rz_il_handler_goto,
    [RZ_IL_OP_SEQ] = rz_il_handler_seq,
    [RZ_IL_OP_BLK] = rz_il_handler_blk,
    [RZ_IL_OP_REPEAT] = rz_il_handler_repeat,
    [RZ_IL_OP_BRANCH] = rz_il_handler_branch,
}

Definition at line 104 of file il_vm_eval.c.

Referenced by rz_il_vm_init().

rz_il_op_handler_pure_table_default

RZ_IPI RzILOpPureHandler rz_il_op_handler_pure_table_default[RZ_IL_OP_PURE_MAX]

Definition at line 67 of file il_vm_eval.c.

Referenced by rz_il_vm_init().