mem.h File Reference

#include <rz_util.h>

Go to the source code of this file.

Classes
struct	rz_il_mem_t
	A single memory as part of the RzIL VM. More...

Typedefs
typedef ut32	RzILMemIndex
typedef struct rz_il_mem_t	RzILMem
	A single memory as part of the RzIL VM. More...

Functions
RZ_API RzILMem *	rz_il_mem_new (RzBuffer *buf, ut32 key_len)
RZ_API void	rz_il_mem_free (RzILMem *mem)
RZ_API ut32	rz_il_mem_key_len (RzILMem *mem)
	Get the bit-size of a key (address) into the memory. More...
RZ_API ut32	rz_il_mem_value_len (RzILMem *mem)
	Get the bit-size of a value in the memory. More...
RZ_API RzBitVector *	rz_il_mem_load (RzILMem *mem, RzBitVector *key)
RZ_API bool	rz_il_mem_store (RzILMem *mem, RzBitVector *key, RzBitVector *value)
RZ_API RzBitVector *	rz_il_mem_loadw (RzILMem *mem, RzBitVector *key, ut32 n_bits, bool big_endian)
RZ_API bool	rz_il_mem_storew (RzILMem *mem, RzBitVector *key, RzBitVector *value, bool big_endian)

Typedef Documentation

RzILMem

typedef struct rz_il_mem_t RzILMem

A single memory as part of the RzIL VM.

This can be seen as an array of bitvectors, indexed by bitvector keys, covering a certain address space. It corresponds to ('a, 'b) mem in bap where 'a and 'b statically determine the size of all keys and values, respectively. Because currently our memory can only bind to an RzBuffer, the key size is limited to a maximum of 64bits and the value size is always 8, but this can be extended in the future if necessary.

RzILMemIndex

typedef ut32 RzILMemIndex

Definition at line 14 of file mem.h.

Function Documentation

rz_il_mem_free()

RZ_API void rz_il_mem_free

(

RzILMem *

mem

)

Free a Mem

Parameters

mem	memory to be free

Definition at line 34 of file mem.c.

                                         {
    if (!mem) {
        return;
    }
    rz_buf_free(mem->buf);
    free(mem);
}

References free(), mem, and rz_buf_free().

Referenced by rz_il_vm_init().

rz_il_mem_key_len()

RZ_API ut32 rz_il_mem_key_len

(

RzILMem *

mem

)

Get the bit-size of a key (address) into the memory.

For all k, rz_bv_len(rz_il_mem_load(mem, k)) == rz_il_mem_value_len(mem). So this could be seen as the size of a byte. Because we only support RzBuffer-based mems at the moment, this is always 8, but more options may be available in the future.

Definition at line 49 of file mem.c.

                                            {
    return mem->key_len;
}

References mem.

Referenced by rz_il_validate_global_context_new_from_vm().

rz_il_mem_load()

RZ_API RzBitVector* rz_il_mem_load	(	RzILMem *	mem,
		RzBitVector *	key
	)

Load a single memory value (bitvector) from current address (bitvector)

Parameters

mem	Memory
key	address (bitvector)

Returns

data (bitvector)

Definition at line 79 of file mem.c.

                                                                   {
    rz_return_val_if_fail(mem && key, NULL);
    return_val_if_key_len_wrong(mem, key, NULL);
    ut8 v = 0;
    rz_buf_read_at(mem->buf, rz_bv_to_ut64(key), &v, 1);
    return rz_bv_new_from_ut64(rz_il_mem_value_len(mem), v);
}

References key, mem, NULL, return_val_if_key_len_wrong, rz_buf_read_at(), rz_bv_new_from_ut64(), rz_bv_to_ut64(), rz_il_mem_value_len(), rz_return_val_if_fail, and v.

Referenced by rz_il_vm_mem_load(), and rz_il_vm_mem_store().

rz_il_mem_loadw()

RZ_API RzBitVector* rz_il_mem_loadw	(	RzILMem *	mem,
		RzBitVector *	key,
		ut32	n_bits,
		bool	big_endian
	)

Load an entire work of the given size from the given address

Parameters

key	address (bitvector)
n_bits	How many bits to read. This also determines the size of the returned bitvector

Returns

data (bitvector)

Definition at line 157 of file mem.c.

                                                                                                  {
    rz_return_val_if_fail(mem && key && n_bits, NULL);
    return_val_if_key_len_wrong(mem, key, NULL);
    return read_n_bits(mem->buf, n_bits, key, big_endian);
}

References key, mem, NULL, read_n_bits(), return_val_if_key_len_wrong, and rz_return_val_if_fail.

Referenced by rz_il_vm_mem_loadw(), and rz_il_vm_mem_storew().

rz_il_mem_new()

RZ_API RzILMem* rz_il_mem_new	(	RzBuffer *	buf,
		ut32	key_len
	)

Create a memory for accessing the given buffer.

Definition at line 13 of file mem.c.

                                                           {
    rz_return_val_if_fail(buf && key_len, NULL);
    if (key_len > KEY_LEN_MAX) {
        // no assertion because it's not stricly a programming error to call this
        // with a higher len. It's just not supported.
        return NULL;
    }
    RzILMem *ret = RZ_NEW0(RzILMem);
    if (!ret) {
        return NULL;
    }
    rz_buf_ref(buf);
    ret->buf = buf;
    ret->key_len = key_len;
    return ret;
}

References rz_il_mem_t::buf, rz_il_mem_t::key_len, KEY_LEN_MAX, NULL, rz_buf_ref(), RZ_NEW0, and rz_return_val_if_fail.

Referenced by setup_vm_from_config().

rz_il_mem_store()

RZ_API bool rz_il_mem_store	(	RzILMem *	mem,
		RzBitVector *	key,
		RzBitVector *	value
	)

Store a single memory value (bitvector) into an address (bitvector)

Parameters

key	address
value	data

Returns

whether the store succeeded

Definition at line 93 of file mem.c.

                                                                                {
    rz_return_val_if_fail(mem && key && value, false);
    return_val_if_key_len_wrong(mem, key, false);
    if (rz_bv_len(value) != rz_il_mem_value_len(mem)) {
        RZ_LOG_ERROR("RzIL: Memory write value size mismatch (expected size = %u, but got %u)\n",
            (unsigned int)rz_il_mem_value_len(mem), (unsigned int)rz_bv_len(value));
        return false;
    }
    ut8 v = rz_bv_to_ut8(value);
    return rz_buf_write_at(mem->buf, rz_bv_to_ut64(key), &v, 1) == 1;
}

References key, mem, return_val_if_key_len_wrong, rz_buf_write_at(), rz_bv_len(), rz_bv_to_ut64(), rz_bv_to_ut8(), rz_il_mem_value_len(), RZ_LOG_ERROR, rz_return_val_if_fail, v, and value.

Referenced by rz_il_vm_mem_store().

rz_il_mem_storew()

RZ_API bool rz_il_mem_storew	(	RzILMem *	mem,
		RzBitVector *	key,
		RzBitVector *	value,
		bool	big_endian
	)

Store an entire word or arbitrary size at an address

Parameters

key	address
value	data

Returns

whether the store succeeded

Definition at line 169 of file mem.c.

                                                                                                  {
    rz_return_val_if_fail(mem && key && value, false);
    return_val_if_key_len_wrong(mem, key, false);
    return write_n_bits(mem->buf, key, value, big_endian);
}

References key, mem, return_val_if_key_len_wrong, rz_return_val_if_fail, value, and write_n_bits().

Referenced by rz_il_vm_mem_storew().

rz_il_mem_value_len()

RZ_API ut32 rz_il_mem_value_len

(

RzILMem *

mem

)

Get the bit-size of a value in the memory.

For all k, rz_bv_len(rz_il_mem_load(mem, k)) == rz_il_mem_value_len(mem). So this could be seen as the size of a byte. Because we only support RzBuffer-based mems at the moment, this is always 8, but more options may be available in the future.

Definition at line 60 of file mem.c.

                                              {
    return 8;
}

Referenced by rz_il_mem_load(), rz_il_mem_store(), and rz_il_validate_global_context_new_from_vm().