mem.c File Reference

#include <rz_il/definitions/mem.h>

Go to the source code of this file.

Macros
#define	KEY_LEN_MAX   64
#define	return_val_if_key_len_wrong(mem, key, ret)

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)
static RzBitVector *	read_n_bits (RzBuffer *buf, ut32 n_bits, RzBitVector *key, bool big_endian)
static bool	write_n_bits (RzBuffer *buf, RzBitVector *key, RzBitVector *value, bool big_endian)
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)

Macro Definition Documentation

KEY_LEN_MAX

#define KEY_LEN_MAX   64

Definition at line 8 of file mem.c.

return_val_if_key_len_wrong

#define return_val_if_key_len_wrong	(		mem,
			key,
			ret
	)

Value:

    do { \
        if (rz_bv_len(key) != rz_il_mem_key_len(mem)) { \
            RZ_LOG_ERROR("RzIL: Memory key size mismatch (expected size = %u, but got %u)\n", \
                (unsigned int)rz_il_mem_key_len(mem), (unsigned int)rz_bv_len(key)); \
            return ret; \
        } \
    } while (0);

Definition at line 64 of file mem.c.

Function Documentation

read_n_bits()

static RzBitVector* read_n_bits ( RzBuffer *  buf, ut32  n_bits, RzBitVector *  key, bool  big_endian  )

static

Definition at line 105 of file mem.c.

                                                                                               {
    RzBitVector *value = rz_bv_new_zero(n_bits);
    if (!value) {
        rz_warn_if_reached();
        return NULL;
    }
 
    ut64 address = rz_bv_to_ut64(key);
    ut32 n_bytes = rz_bv_len_bytes(value);
 
    ut8 *data = calloc(n_bytes, 1);
    if (!data) {
        return value;
    }
 
    // we ignore bad reads. RzBuffer fills up with its "overflow byte" on failure.
    rz_buf_read_at(buf, address, data, n_bytes);
    if (big_endian) {
        rz_bv_set_from_bytes_be(value, data, 0, n_bits);
    } else {
        rz_bv_set_from_bytes_le(value, data, 0, n_bits);
    }
    free(data);
    return value;
}

References calloc(), free(), key, NULL, rz_buf_read_at(), rz_bv_len_bytes(), rz_bv_new_zero, rz_bv_set_from_bytes_be(), rz_bv_set_from_bytes_le(), rz_bv_to_ut64(), rz_warn_if_reached, ut64(), and value.

Referenced by rz_il_mem_loadw().

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

write_n_bits()

static bool write_n_bits ( RzBuffer *  buf, RzBitVector *  key, RzBitVector *  value, bool  big_endian  )

static

Definition at line 131 of file mem.c.

                                                                                               {
    ut64 address = rz_bv_to_ut64(key);
    ut32 n_bytes = rz_bv_len_bytes(value);
 
    ut8 *data = calloc(n_bytes, 1);
    if (!data) {
        return false;
    }
 
    if (big_endian) {
        rz_bv_set_to_bytes_be(value, data);
    } else {
        rz_bv_set_to_bytes_le(value, data);
    }
 
    bool succ = rz_buf_write_at(buf, address, data, n_bytes) == n_bytes;
    free(data);
    return succ;
}

References calloc(), free(), key, rz_buf_write_at(), rz_bv_len_bytes(), rz_bv_set_to_bytes_be(), rz_bv_set_to_bytes_le(), rz_bv_to_ut64(), ut64(), and value.

Referenced by rz_il_mem_storew().