rz_il_reg.h File Reference

#include <rz_reg.h>

Go to the source code of this file.

Classes
struct	rz_il_reg_binding_item_t
struct	rz_il_reg_binding_t

Typedefs
typedef struct rz_il_reg_binding_item_t	RzILRegBindingItem
typedef struct rz_il_reg_binding_t	RzILRegBinding

Functions
RZ_API RzILRegBinding *	rz_il_reg_binding_derive (RZ_NONNULL RzReg *reg)
	Calculate a new binding of IL variables against the profile of the given RzReg. More...
RZ_API RzILRegBinding *	rz_il_reg_binding_exactly (RZ_NONNULL RzReg *reg, size_t regs_count, RZ_NONNULL RZ_BORROW const char **regs)
RZ_API void	rz_il_reg_binding_free (RzILRegBinding *rb)
RZ_API void	rz_il_vm_setup_reg_binding (RZ_NONNULL struct rz_il_vm_t *vm, RZ_NONNULL RZ_BORROW RzILRegBinding *rb)
RZ_API bool	rz_il_vm_sync_to_reg (RZ_NONNULL struct rz_il_vm_t *vm, RZ_NONNULL RzILRegBinding *rb, RZ_NONNULL RzReg *reg)
RZ_API void	rz_il_vm_sync_from_reg (RZ_NONNULL struct rz_il_vm_t *vm, RZ_NONNULL RzILRegBinding *rb, RZ_NONNULL RzReg *reg)

Typedef Documentation

RzILRegBinding

typedef struct rz_il_reg_binding_t RzILRegBinding

An object that describes what registers are bound to variables in an RzILVM. Registers of size 1 are bound as boolean variables, others as bitvector ones.

RzILRegBindingItem

typedef struct rz_il_reg_binding_item_t RzILRegBindingItem

Function Documentation

rz_il_reg_binding_derive()

RZ_API RzILRegBinding* rz_il_reg_binding_derive

(

RZ_NONNULL RzReg *

reg

)

Calculate a new binding of IL variables against the profile of the given RzReg.

Because registers can overlap, not all registers may get a binding. Informally, only the "larger" ones, containing "smaller" ones are bound, except for 1-bit registers, which are always preferred.

More specifically, the set of registers to be bound is determined like this: First, bind all 1-bit registers (flags). Then, bind a (sub)set of the remaining registers like this:

• Begin with the set of all registers.
• Remove all registers overlapping with an already-bound 1-bit register.
• Remove all registers that are covered entirely by another register in the same set and are smaller than it.
• Remove the one marked with RZ_REG_NAME_PC, if it exists.
• While there still exists at least overlap, from the overlap of two registers at the lowest offset, remove the register with the higher offset.

If two registers have the same offset and size, the result is currently undefined.

Definition at line 35 of file il_reg.c.

                                                                       {
    rz_return_val_if_fail(reg, NULL);
    RzILRegBinding *rb = RZ_NEW0(RzILRegBinding);
    if (!rb) {
        return NULL;
    }
    RzVector regs;
    rz_vector_init(&regs, sizeof(RzILRegBindingItem), (RzVectorFree)reg_binding_item_fini, NULL);
    for (int i = 0; i < RZ_REG_TYPE_LAST; i++) {
        // bind all flags (1-bit regs) unconditionally
        RzRegItem *item;
        RzListIter *iter;
        RzList *flags = rz_list_new();
        if (!flags) {
            continue;
        }
        rz_list_foreach (reg->regset[i].regs, iter, item) {
            if (item->size != 1) {
                continue;
            }
            // check for same-offset flag
            RzRegItem *item2;
            RzListIter *iter2;
            rz_list_foreach (flags, iter2, item2) {
                if (item2->offset == item->offset) {
                    goto next_flag;
                }
            }
            // all good, bind it
            rz_list_push(flags, item);
            char *name = strdup(item->name);
            if (!name) {
                rz_list_free(flags);
                goto err;
            }
            RzILRegBindingItem *bitem = rz_vector_push(&regs, NULL);
            if (!bitem) {
                free(name);
                rz_list_free(flags);
                goto err;
            }
            bitem->name = name;
            bitem->size = item->size;
        next_flag:
            continue;
        }
        // for the remaining regs, first filter regs that contain a flag
        RzList *nonflags = rz_list_new();
        if (!nonflags) {
            rz_list_free(flags);
            goto err;
        }
        rz_list_foreach (reg->regset[i].regs, iter, item) {
            RzRegItem *flag;
            RzListIter *fiter;
            rz_list_foreach (flags, fiter, flag) {
                if (flag->offset >= item->offset && flag->offset < item->offset + item->size) {
                    goto next_reg;
                }
            }
            rz_list_push(nonflags, item);
        next_reg:
            continue;
        }
        // then bind the remaining regs, favoring larger ones on overlaps
        RzList *items = rz_reg_filter_items_covered(nonflags);
        rz_list_free(nonflags);
        if (!items) {
            rz_list_free(flags);
            continue;
        }
        rz_list_sort(items, reg_offset_cmp);
        const char *pc = rz_reg_get_name(reg, RZ_REG_NAME_PC);
        RzRegItem *prev = NULL;
        rz_list_foreach (items, iter, item) {
            if (prev && prev->offset + prev->size > item->offset) {
                // overlap where one reg is not fully contained in another.
                // this is not supported yet.
                continue;
            }
            if (pc && !strcmp(item->name, pc)) {
                // pc is handled outside of reg binding
                continue;
            }
            char *name = strdup(item->name);
            if (!name) {
                rz_list_free(flags);
                rz_list_free(items);
                goto err;
            }
            RzILRegBindingItem *bitem = rz_vector_push(&regs, NULL);
            if (!bitem) {
                free(name);
                rz_list_free(flags);
                rz_list_free(items);
                goto err;
            }
            bitem->name = name;
            bitem->size = item->size;
            prev = item;
        }
        rz_list_free(items);
        rz_list_free(flags);
    }
    // from now on, the array should be treated immutable, so we deliberately don't use RzVector anymore.
    rb->regs_count = rz_vector_len(&regs);
    rb->regs = rz_vector_flush(&regs);
    rz_vector_fini(&regs);
    return rb;
err:
    rz_vector_fini(&regs);
    free(rb);
    return NULL;
}

References err, flags, free(), i, name, rz_il_reg_binding_item_t::name, rz_reg_item_t::name, NULL, rz_reg_item_t::offset, pc, reg, reg_binding_item_fini(), reg_offset_cmp(), regs, rz_il_reg_binding_t::regs, rz_il_reg_binding_t::regs_count, rz_list_free(), rz_list_new(), rz_list_push(), rz_list_sort(), RZ_NEW0, rz_reg_filter_items_covered(), rz_reg_get_name(), RZ_REG_NAME_PC, RZ_REG_TYPE_LAST, rz_return_val_if_fail, rz_vector_fini(), rz_vector_flush(), rz_vector_init(), rz_vector_len(), rz_vector_push(), rz_il_reg_binding_item_t::size, rz_reg_item_t::size, and strdup().

Referenced by setup_regs().

rz_il_reg_binding_exactly()

RZ_API RzILRegBinding* rz_il_reg_binding_exactly	(	RZ_NONNULL RzReg *	reg,
		size_t	regs_count,
		RZ_NONNULL RZ_BORROW const char **	regs
	)

Create a new binding that binds exactly the given register names, querying reg for any additionally needed info

Parameters

regs	array of regs_count names of registers. Each of these must be part of reg and they must not overlap.

Definition at line 154 of file il_reg.c.

                                                                                                                                   {
    rz_return_val_if_fail(reg && regs, NULL);
    RzILRegBinding *rb = RZ_NEW(RzILRegBinding);
    if (!rb) {
        return NULL;
    }
    rb->regs_count = regs_count;
    rb->regs = RZ_NEWS0(RzILRegBindingItem, regs_count);
    if (!rb->regs) {
        goto err_rb;
    }
    // all bound items to check for overlaps
    RzRegItem **items = RZ_NEWS(RzRegItem *, regs_count);
    if (!items) {
        goto err_regs;
    }
    for (size_t i = 0; i < regs_count; i++) {
        RzRegItem *ri = rz_reg_get(reg, regs[i], RZ_REG_TYPE_ANY);
        if (!ri) {
            goto err_regs;
        }
        // Check if this item overlaps any already bound registers.
        // Overlaps must not happen because they will confuse the VM and analysis.
        for (size_t j = 0; j < i; j++) {
            if (items[j]->type != ri->type) {
                continue;
            }
            if (items[j]->offset + items[j]->size <= ri->offset || items[j]->offset >= ri->offset + ri->size) {
                continue;
            }
            // overlap detected
            goto err_regs;
        }
        rb->regs[i].name = strdup(regs[i]);
        if (!rb->regs[i].name) {
            goto err_regs;
        }
        rb->regs[i].size = ri->size;
        items[i] = ri;
    }
    free(items);
    return rb;
err_regs:
    for (size_t i = 0; i < regs_count; i++) {
        reg_binding_item_fini(&rb->regs[i], NULL);
    }
    free(rb->regs);
    free(items);
err_rb:
    free(rb);
    return NULL;
}

References free(), i, rz_il_reg_binding_item_t::name, NULL, rz_reg_item_t::offset, reg, reg_binding_item_fini(), regs, rz_il_reg_binding_t::regs, rz_il_reg_binding_t::regs_count, RZ_NEW, RZ_NEWS, RZ_NEWS0, rz_reg_get(), RZ_REG_TYPE_ANY, rz_return_val_if_fail, rz_il_reg_binding_item_t::size, rz_reg_item_t::size, strdup(), type, and rz_reg_item_t::type.

Referenced by setup_regs().

rz_il_reg_binding_free()

RZ_API void rz_il_reg_binding_free

(

RzILRegBinding *

rb

)

Definition at line 207 of file il_reg.c.

                                                       {
    if (!rb) {
        return;
    }
    for (size_t i = 0; i < rb->regs_count; i++) {
        reg_binding_item_fini(&rb->regs[i], NULL);
    }
    free(rb->regs);
    free(rb);
}

References free(), i, NULL, reg_binding_item_fini(), rz_il_reg_binding_t::regs, and rz_il_reg_binding_t::regs_count.

Referenced by rz_analysis_il_vm_free().

rz_il_vm_setup_reg_binding()

RZ_API void rz_il_vm_setup_reg_binding	(	RZ_NONNULL struct rz_il_vm_t *	vm,
		RZ_NONNULL RZ_BORROW RzILRegBinding *	rb
	)

rz_il_vm_sync_from_reg()

RZ_API void rz_il_vm_sync_from_reg	(	RZ_NONNULL struct rz_il_vm_t *	vm,
		RZ_NONNULL RzILRegBinding *	rb,
		RZ_NONNULL RzReg *	reg
	)

rz_il_vm_sync_to_reg()

RZ_API bool rz_il_vm_sync_to_reg	(	RZ_NONNULL struct rz_il_vm_t *	vm,
		RZ_NONNULL RzILRegBinding *	rb,
		RZ_NONNULL RzReg *	reg
	)