rz_il_vm.h File Reference

#include <rz_il/definitions/definitions.h>
#include <rz_il/rz_il_opcodes.h>
#include <rz_il/rz_il_events.h>
#include <rz_il/rz_il_reg.h>

Go to the source code of this file.

Classes
struct	rz_il_vm_t
	Low-level VM to execute raw IL code. More...

Typedefs
typedef struct rz_il_vm_t	RzILVM
typedef void *(*	RzILOpPureHandler) (RzILVM *vm, RzILOpPure *op, RZ_NONNULL RZ_OUT RzILTypePure *type)
	Evaluation callback for a single pure opcode. More...
typedef bool(*	RzILOpEffectHandler) (RzILVM *vm, RzILOpEffect *op)
	Evaluation (execution) callback for a single effect opcode. More...
typedef void(*	RzILVmHook) (RzILVM *vm, RzILOpEffect *op)
typedef RZ_NULLABLE RzILVal *	RzILLocalPurePrev

Functions
RZ_API RzILVM *	rz_il_vm_new (ut64 start_addr, ut32 addr_size, bool big_endian)
RZ_API void	rz_il_vm_free (RzILVM *vm)
RZ_API bool	rz_il_vm_init (RzILVM *vm, ut64 start_addr, ut32 addr_size, bool big_endian)
RZ_API void	rz_il_vm_fini (RzILVM *vm)
RZ_API ut32	rz_il_vm_get_pc_len (RzILVM *vm)
RZ_API void	rz_il_vm_event_add (RzILVM *vm, RzILEvent *evt)
RZ_API void	rz_il_vm_clear_events (RzILVM *vm)
RZ_API void	rz_il_vm_add_mem (RzILVM *vm, RzILMemIndex index, RZ_OWN RzILMem *mem)
RZ_API RzILMem *	rz_il_vm_get_mem (RzILVM *vm, RzILMemIndex index)
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 RZ_BORROW RzBitVector *	rz_il_hash_find_addr_by_lblname (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *lbl_name)
RZ_API RZ_BORROW RzILEffectLabel *	rz_il_vm_find_label_by_name (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *lbl_name)
RZ_API void	rz_il_vm_add_label (RZ_NONNULL RzILVM *vm, RZ_NONNULL RzILEffectLabel *label)
RZ_API RZ_BORROW RzILEffectLabel *	rz_il_vm_create_label (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RZ_NONNULL RZ_BORROW RzBitVector *addr)
RZ_API RZ_BORROW RzILEffectLabel *	rz_il_vm_create_label_lazy (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name)
RZ_API RZ_BORROW RzILEffectLabel *	rz_il_vm_update_label (RZ_NONNULL RzILVM *vm, RZ_NONNULL char *name, RZ_NONNULL RZ_BORROW RzBitVector *addr)
RZ_API RZ_BORROW RzILVar *	rz_il_vm_create_global_var (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RzILSortPure sort)
RZ_API void	rz_il_vm_set_global_var (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RZ_OWN RzILVal *val)
RZ_API void	rz_il_vm_set_local_var (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RZ_OWN RzILVal *val)
RZ_API RzILLocalPurePrev	rz_il_vm_push_local_pure_var (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RzILVal *val)
	Create and assign a new local let binding. More...
RZ_API void	rz_il_vm_pop_local_pure_var (RZ_NONNULL RzILVM *vm, RZ_NONNULL const char *name, RzILLocalPurePrev prev)
	Remove a local let binding and restore the state for the outer context. More...
RZ_API RZ_BORROW RzILVar *	rz_il_vm_get_var (RZ_NONNULL RzILVM *vm, RzILVarKind kind, const char *name)
RZ_API RZ_OWN RzPVector *	rz_il_vm_get_all_vars (RZ_NONNULL RzILVM *vm, RzILVarKind kind)
RZ_API RZ_BORROW RzILVal *	rz_il_vm_get_var_value (RZ_NONNULL RzILVM *vm, RzILVarKind kind, const char *name)
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)
RZ_API bool	rz_il_vm_step (RzILVM *vm, RzILOpEffect *op, ut64 fallthrough_addr)

Typedef Documentation

RzILLocalPurePrev

typedef RZ_NULLABLE RzILVal* RzILLocalPurePrev

Definition at line 86 of file rz_il_vm.h.

RzILOpEffectHandler

typedef bool(* RzILOpEffectHandler) (RzILVM *vm, RzILOpEffect *op)

Evaluation (execution) callback for a single effect opcode.

Returns

false if an error occured and the execution should be aborted

Definition at line 30 of file rz_il_vm.h.

RzILOpPureHandler

typedef void*(* RzILOpPureHandler) (RzILVM *vm, RzILOpPure *op, RZ_NONNULL RZ_OUT RzILTypePure *type)

Evaluation callback for a single pure opcode.

Parameters

type	when returning a non-null value, this must be set to the respective type.

Returns

The evaluated value of the type indicated by *type, or NULL if an error occured and the execution should be aborted

Definition at line 24 of file rz_il_vm.h.

RzILVM

typedef struct rz_il_vm_t RzILVM

Definition at line 1 of file rz_il_vm.h.

RzILVmHook

typedef void(* RzILVmHook) (RzILVM *vm, RzILOpEffect *op)

Definition at line 32 of file rz_il_vm.h.

Function Documentation

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_hash_find_addr_by_lblname()

RZ_API RZ_BORROW RzBitVector* rz_il_hash_find_addr_by_lblname	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	lbl_name
	)

Find the bitvector address by given name

Parameters

vm	RzILVM* vm, pointer to VM
lbl_name	string, the name of label

Returns

addr RzBitVector, address which has RzBitVector type

Definition at line 275 of file il_vm.c.

                                                                                                                      {
    rz_return_val_if_fail(vm && lbl_name, NULL);
    bool found = false;
    RzILEffectLabel *label = ht_pp_find(vm->vm_global_label_table, lbl_name, &found);
    if (!found) {
        return NULL;
    }
    return label->addr;
}

References found, NULL, and rz_return_val_if_fail.

rz_il_vm_add_label()

RZ_API void rz_il_vm_add_label	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL RzILEffectLabel *	label
	)

Definition at line 296 of file il_vm.c.

                                                                                         {
    rz_return_if_fail(vm && label);
    ht_pp_update(vm->vm_global_label_table, label->label_id, label);
}

References rz_return_if_fail.

Referenced by rz_il_vm_create_label(), rz_il_vm_create_label_lazy(), and setup_vm_from_config().

rz_il_vm_add_mem()

RZ_API void rz_il_vm_add_mem	(	RzILVM *	vm,
		RzILMemIndex	index,
		RZ_OWN RzILMem *	mem
	)

Add a memory to VM at the given index. Ownership of the memory is transferred to the VM.

Definition at line 153 of file il_vm.c.

                                                                                  {
    if (index < rz_pvector_len(&vm->vm_memory)) {
        rz_mem_free(rz_pvector_at(&vm->vm_memory, index));
    }
    rz_pvector_reserve(&vm->vm_memory, index + 1);
    // Fill up with NULLs until the given index
    while (rz_pvector_len(&vm->vm_memory) < index + 1) {
        rz_pvector_push(&vm->vm_memory, NULL);
    }
    rz_pvector_set(&vm->vm_memory, index, mem);
}

References mem, NULL, rz_mem_free(), rz_pvector_at(), rz_pvector_len(), rz_pvector_push(), rz_pvector_reserve(), rz_pvector_set(), and rz_il_vm_t::vm_memory.

Referenced by setup_vm_from_config().

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_create_global_var()

RZ_API RZ_BORROW RzILVar* rz_il_vm_create_global_var	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RzILSortPure	sort
	)

Create a new global variable of the given sort and assign it to all-zero/false

Definition at line 175 of file il_vm.c.

                                                                                                                            {
    rz_return_val_if_fail(vm && name, NULL);
    RzILVar *var = rz_il_var_set_create_var(&vm->global_vars, name, sort);
    if (!var) {
        return NULL;
    }
    RzILVal *val = rz_il_value_new_zero_of(sort);
    if (!val) {
        return NULL;
    }
    rz_il_var_set_bind(&vm->global_vars, name, val);
    return var;
}

References NULL, rz_il_value_new_zero_of(), rz_il_var_set_bind(), rz_il_var_set_create_var(), rz_return_val_if_fail, and val.

Referenced by rz_il_vm_setup_reg_binding().

rz_il_vm_create_label()

RZ_API RZ_BORROW RzILEffectLabel* rz_il_vm_create_label	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RZ_NONNULL RZ_BORROW RzBitVector *	addr
	)

Create a label in VM

Parameters

vm	RzILVM, pointer to VM
name	string, name of label
addr	RzBitVector, label address

Returns

lbl RzILEffectLabel, pointer to label instance

Definition at line 308 of file il_vm.c.

                                                                                                                                                    {
    rz_return_val_if_fail(vm && name && addr, NULL);
    RzILEffectLabel *lbl = rz_il_effect_label_new(name, EFFECT_LABEL_ADDR);
    lbl->addr = rz_bv_dup(addr);
    rz_il_vm_add_label(vm, lbl);
    return lbl;
}

References addr, rz_il_effect_label_t::addr, EFFECT_LABEL_ADDR, NULL, rz_bv_dup(), rz_il_effect_label_new(), rz_il_vm_add_label(), and rz_return_val_if_fail.

Referenced by rz_il_handler_blk().

rz_il_vm_create_label_lazy()

RZ_API RZ_BORROW RzILEffectLabel* rz_il_vm_create_label_lazy	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name
	)

Create a label without address, use rz_il_vm_update_label to update address for it

Parameters

vm	RzILVM, pointer to VM
name	string, name of this label

Returns

lbl RzILEffectLabel, pointer to label instance

Definition at line 322 of file il_vm.c.

                                                                                                                 {
    rz_return_val_if_fail(vm && name, NULL);
    RzILEffectLabel *lbl = rz_il_effect_label_new(name, EFFECT_LABEL_ADDR);
    lbl->addr = NULL;
    rz_il_vm_add_label(vm, lbl);
    return lbl;
}

References rz_il_effect_label_t::addr, EFFECT_LABEL_ADDR, NULL, rz_il_effect_label_new(), rz_il_vm_add_label(), and rz_return_val_if_fail.

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_find_label_by_name()

RZ_API RZ_BORROW RzILEffectLabel* rz_il_vm_find_label_by_name	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	lbl_name
	)

Find the label instance by name

Parameters

vm	RzILVM, pointer to VM
lbl_name	string, the name of label

Returns

lbl RzILEffectLabel, pointer to label instance

Definition at line 291 of file il_vm.c.

                                                                                                                      {
    rz_return_val_if_fail(vm && lbl_name, NULL);
    return ht_pp_find(vm->vm_global_label_table, lbl_name, NULL);
}

References NULL, and rz_return_val_if_fail.

Referenced by rz_il_handler_goto().

rz_il_vm_fini()

RZ_API void rz_il_vm_fini

(

RzILVM *

vm

)

Close and clean vm

Parameters

vm	RzILVM* pointer to VM

Definition at line 93 of file il_vm.c.

                                      {
    rz_il_var_set_fini(&vm->global_vars);
    rz_il_var_set_fini(&vm->local_vars);
    rz_il_var_set_fini(&vm->local_pure_vars);
 
    rz_pvector_fini(&vm->vm_memory);
 
    ht_pp_free(vm->vm_global_label_table);
    vm->vm_global_label_table = NULL;
 
    free(vm->op_handler_pure_table);
    vm->op_handler_pure_table = NULL;
    free(vm->op_handler_effect_table);
    vm->op_handler_effect_table = NULL;
 
    rz_bv_free(vm->pc);
    vm->pc = NULL;
 
    rz_list_free(vm->events);
    vm->events = NULL;
}

References rz_il_vm_t::events, free(), rz_il_vm_t::global_vars, rz_il_vm_t::local_pure_vars, rz_il_vm_t::local_vars, NULL, rz_il_vm_t::op_handler_effect_table, rz_il_vm_t::op_handler_pure_table, rz_il_vm_t::pc, rz_bv_free(), rz_il_var_set_fini(), rz_list_free(), rz_pvector_fini(), rz_il_vm_t::vm_global_label_table, and rz_il_vm_t::vm_memory.

Referenced by rz_il_vm_free(), and rz_il_vm_init().

rz_il_vm_free()

RZ_API void rz_il_vm_free

(

RzILVM *

vm

)

Close, clean and free vm

Parameters

vm	RzILVM* pointer to VM

Definition at line 134 of file il_vm.c.

                                      {
    if (!vm) {
        return;
    }
    rz_il_vm_fini(vm);
    free(vm);
}

References free(), and rz_il_vm_fini().

Referenced by rz_analysis_il_vm_free(), and setup_vm_from_config().

rz_il_vm_get_all_vars()

RZ_API RZ_OWN RzPVector* rz_il_vm_get_all_vars	(	RZ_NONNULL RzILVM *	vm,
		RzILVarKind	kind
	)

Definition at line 256 of file il_vm.c.

                                                                                          {
    rz_return_val_if_fail(vm, NULL);
    return rz_il_var_set_get_all(var_set_of_kind(vm, kind));
}

References NULL, rz_il_var_set_get_all(), rz_return_val_if_fail, and var_set_of_kind().

Referenced by rz_core_analysis_il_vm_status(), and rz_il_validate_global_context_new_from_vm().

rz_il_vm_get_mem()

RZ_API RzILMem* rz_il_vm_get_mem	(	RzILVM *	vm,
		RzILMemIndex	index
	)

Definition at line 165 of file il_vm.c.

                                                                 {
    if (index >= rz_pvector_len(&vm->vm_memory)) {
        return NULL;
    }
    return rz_pvector_at(&vm->vm_memory, index);
}

References NULL, rz_pvector_at(), rz_pvector_len(), and rz_il_vm_t::vm_memory.

Referenced by rz_il_vm_mem_load(), rz_il_vm_mem_loadw(), rz_il_vm_mem_store(), and rz_il_vm_mem_storew().

rz_il_vm_get_pc_len()

RZ_API ut32 rz_il_vm_get_pc_len

(

RzILVM *

vm

)

Get the number of bits of the program counter bitvector

Definition at line 145 of file il_vm.c.

                                            {
    return rz_bv_len(vm->pc);
}

References rz_il_vm_t::pc, and rz_bv_len().

Referenced by rz_il_validate_global_context_new_from_vm().

rz_il_vm_get_var()

RZ_API RZ_BORROW RzILVar* rz_il_vm_get_var	(	RZ_NONNULL RzILVM *	vm,
		RzILVarKind	kind,
		const char *	name
	)

Definition at line 251 of file il_vm.c.

                                                                                                      {
    rz_return_val_if_fail(vm && name, NULL);
    return rz_il_var_set_get(var_set_of_kind(vm, kind), name);
}

References NULL, rz_il_var_set_get(), rz_return_val_if_fail, and var_set_of_kind().

Referenced by rz_core_analysis_il_vm_set(), rz_il_set(), and rz_il_vm_sync_from_reg().

rz_il_vm_get_var_value()

RZ_API RZ_BORROW RzILVal* rz_il_vm_get_var_value	(	RZ_NONNULL RzILVM *	vm,
		RzILVarKind	kind,
		const char *	name
	)

Get the current value of the variable identified by its name and kind.

Definition at line 264 of file il_vm.c.

                                                                                                            {
    rz_return_val_if_fail(vm && name, NULL);
    return rz_il_var_set_get_value(var_set_of_kind(vm, kind), name);
}

References NULL, rz_il_var_set_get_value(), rz_return_val_if_fail, and var_set_of_kind().

Referenced by bf_syscall_read(), bf_syscall_write(), il_event_new_write_from_var(), rz_core_analysis_il_vm_status(), rz_il_handler_var(), and rz_il_vm_sync_to_reg().

rz_il_vm_init()

RZ_API bool rz_il_vm_init	(	RzILVM *	vm,
		ut64	start_addr,
		ut32	addr_size,
		bool	big_endian
	)

initiate an empty VM

Parameters

vm	RzILVM, pointer to an empty VM
start_addr	ut64, initiation pc address
addr_size	ut32, size of the address in VM

Definition at line 27 of file il_vm.c.

                                                                                        {
    rz_return_val_if_fail(vm, false);
 
    if (!rz_il_var_set_init(&vm->global_vars)) {
        rz_il_vm_fini(vm);
        return false;
    }
    if (!rz_il_var_set_init(&vm->local_vars)) {
        rz_il_vm_fini(vm);
        return false;
    }
    if (!rz_il_var_set_init(&vm->local_pure_vars)) {
        rz_il_vm_fini(vm);
        return false;
    }
    rz_pvector_init(&vm->vm_memory, (RzPVectorFree)rz_il_mem_free);
 
    // Key : string
    // Val : RzILEffectLabel
    // Do not dump it since its single signed here, and will be free in `close`
    HtPPOptions lbl_options = { 0 };
    lbl_options.cmp = (HtPPListComparator)strcmp;
    lbl_options.hashfn = (HtPPHashFunction)sdb_hash;
    lbl_options.dupkey = (HtPPDupKey)strdup;
    lbl_options.dupvalue = NULL;
    lbl_options.freefn = (HtPPKvFreeFunc)free_label_kv;
    lbl_options.elem_size = sizeof(HtPPKv);
    lbl_options.calcsizeK = (HtPPCalcSizeK)strlen;
    vm->vm_global_label_table = ht_pp_new_opt(&lbl_options);
    if (!vm->vm_global_label_table) {
        RZ_LOG_ERROR("RzIL: cannot allocate VM label hashmap\n");
        rz_il_vm_fini(vm);
        return false;
    }
 
    vm->pc = rz_bv_new_from_ut64(addr_size, start_addr);
    if (!vm->pc) {
        RZ_LOG_ERROR("RzIL: cannot allocate VM program counter\n");
        rz_il_vm_fini(vm);
        return false;
    }
 
    // init jump table of labels
    vm->op_handler_pure_table = RZ_NEWS0(RzILOpPureHandler, RZ_IL_OP_PURE_MAX);
    memcpy(vm->op_handler_pure_table, rz_il_op_handler_pure_table_default, sizeof(RzILOpPureHandler) * RZ_IL_OP_PURE_MAX);
    vm->op_handler_effect_table = RZ_NEWS0(RzILOpEffectHandler, RZ_IL_OP_EFFECT_MAX);
    memcpy(vm->op_handler_effect_table, rz_il_op_handler_effect_table_default, sizeof(RzILOpEffectHandler) * RZ_IL_OP_EFFECT_MAX);
 
    vm->lab_count = 0;
    vm->val_count = 0;
    vm->addr_size = addr_size;
    vm->big_endian = big_endian;
 
    vm->events = rz_list_newf((RzListFree)rz_il_event_free);
    if (!vm->events) {
        RZ_LOG_ERROR("RzIL: cannot allocate VM event list\n");
        rz_il_vm_fini(vm);
        return false;
    }
    return true;
}

References rz_il_vm_t::addr_size, rz_il_vm_t::big_endian, rz_il_vm_t::events, free_label_kv(), rz_il_vm_t::global_vars, rz_il_vm_t::lab_count, rz_il_vm_t::local_pure_vars, rz_il_vm_t::local_vars, memcpy(), NULL, rz_il_vm_t::op_handler_effect_table, rz_il_vm_t::op_handler_pure_table, rz_il_vm_t::pc, rz_bv_new_from_ut64(), rz_il_event_free(), rz_il_mem_free(), RZ_IL_OP_EFFECT_MAX, rz_il_op_handler_effect_table_default, rz_il_op_handler_pure_table_default, RZ_IL_OP_PURE_MAX, rz_il_var_set_init(), rz_il_vm_fini(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEWS0, rz_pvector_init(), rz_return_val_if_fail, sdb_hash(), strdup(), rz_il_vm_t::val_count, rz_il_vm_t::vm_global_label_table, and rz_il_vm_t::vm_memory.

Referenced by rz_il_vm_new().

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_new()

RZ_API RzILVM* rz_il_vm_new	(	ut64	start_addr,
		ut32	addr_size,
		bool	big_endian
	)

Create a new empty VM

Parameters

vm	RzILVM, pointer to an empty VM
start_addr	ut64, initiation pc address
addr_size	ut32, size of the address in VM

Definition at line 121 of file il_vm.c.

                                                                              {
    RzILVM *vm = RZ_NEW0(RzILVM);
    if (!vm) {
        return NULL;
    }
    rz_il_vm_init(vm, start_addr, addr_size, big_endian);
    return vm;
}

References NULL, rz_il_vm_init(), and RZ_NEW0.

Referenced by setup_vm_from_config().

rz_il_vm_pop_local_pure_var()

RZ_API void rz_il_vm_pop_local_pure_var	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RzILLocalPurePrev	prev
	)

Remove a local let binding and restore the state for the outer context.

Parameters

prev	pass here the return value of rz_il_vm_push_local_pure_var()

Definition at line 227 of file il_vm.c.

                                                                                                                    {
    rz_return_if_fail(vm && name);
    RzILVal *r = rz_il_var_set_remove_var(&vm->local_pure_vars, name);
    rz_warn_if_fail(r); // the var should always be bound when calling this function
    rz_il_value_free(r);
    if (prev) {
        rz_il_var_set_create_var(&vm->local_pure_vars, name, rz_il_value_get_sort(prev));
        rz_il_var_set_bind(&vm->local_pure_vars, name, prev);
    }
}

References r, rz_il_value_free(), rz_il_value_get_sort(), rz_il_var_set_bind(), rz_il_var_set_create_var(), rz_il_var_set_remove_var(), rz_return_if_fail, and rz_warn_if_fail.

Referenced by rz_il_handler_let().

rz_il_vm_push_local_pure_var()

RZ_API RzILLocalPurePrev rz_il_vm_push_local_pure_var	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RzILVal *	val
	)

Create and assign a new local let binding.

This is meant to be called right before evaluating the body of a let expression. Inside the body, name will then be bound to val. Because there might already exist an outer binding of the same name shadowing this one, the previous value is returned. After evaluating the body, call rz_il_vm_pop_local_pure_var(), passing this value.

Definition at line 215 of file il_vm.c.

                                                                                                                        {
    rz_return_val_if_fail(vm && name && val, NULL);
    RzILVal *r = rz_il_var_set_remove_var(&vm->local_pure_vars, name);
    rz_il_var_set_create_var(&vm->local_pure_vars, name, rz_il_value_get_sort(val));
    rz_il_var_set_bind(&vm->local_pure_vars, name, val);
    return r;
}

References NULL, r, rz_il_value_get_sort(), rz_il_var_set_bind(), rz_il_var_set_create_var(), rz_il_var_set_remove_var(), rz_return_val_if_fail, and val.

Referenced by rz_il_handler_let().

rz_il_vm_set_global_var()

RZ_API void rz_il_vm_set_global_var	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RZ_OWN RzILVal *	val
	)

Set the value of a global variable to the given value. The variable must already exist.

Definition at line 193 of file il_vm.c.

                                                                                                             {
    rz_return_if_fail(vm && name && val);
    rz_il_var_set_bind(&vm->global_vars, name, val);
}

References rz_il_var_set_bind(), rz_return_if_fail, and val.

Referenced by rz_core_analysis_il_vm_set(), rz_il_set(), rz_il_vm_sync_from_reg(), and setup_vm_init_state().

rz_il_vm_set_local_var()

RZ_API void rz_il_vm_set_local_var	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL const char *	name,
		RZ_OWN RzILVal *	val
	)

Set the value of a local variable to the given value. The variable is created with the sort of val if it does not already exist.

Definition at line 202 of file il_vm.c.

                                                                                                            {
    rz_return_if_fail(vm && name && val);
    rz_il_var_set_create_var(&vm->local_vars, name, rz_il_value_get_sort(val));
    rz_il_var_set_bind(&vm->local_vars, name, val);
}

References rz_il_value_get_sort(), rz_il_var_set_bind(), rz_il_var_set_create_var(), rz_return_if_fail, and val.

Referenced by rz_il_set().

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().

rz_il_vm_update_label()

RZ_API RZ_BORROW RzILEffectLabel* rz_il_vm_update_label	(	RZ_NONNULL RzILVM *	vm,
		RZ_NONNULL char *	name,
		RZ_NONNULL RZ_BORROW RzBitVector *	addr
	)

Update the address info of a label

Parameters

vm	RzILVM, pointer to VM
name	string, name of this label

Returns

lbl RzILEffectLabel, pointer to label instance

Definition at line 336 of file il_vm.c.

                                                                                                                                              {
    rz_return_val_if_fail(vm && name && addr, NULL);
    RzILEffectLabel *lbl = ht_pp_find(vm->vm_global_label_table, name, NULL);
    if (lbl->addr) {
        rz_bv_free(lbl->addr);
    }
    lbl->addr = rz_bv_dup(addr);
    return lbl;
}

References addr, rz_il_effect_label_t::addr, NULL, rz_bv_dup(), rz_bv_free(), and rz_return_val_if_fail.