il_opcodes.c File Reference

#include <rz_il/rz_il_opcodes.h>

Go to the source code of this file.

Macros
#define	rz_il_op_new_0(sort, id)
#define	rz_il_op_new_1(sort, id, t, s, v0)
#define	rz_il_op_new_2(sort, id, t, s, v0, v1)
#define	rz_il_op_new_3(sort, id, t, s, v0, v1, v2)
#define	DUP_OP1(arg, m0)
#define	DUP_OP2(arg, m0, m1)
#define	DUP_OP3(arg, m0, m1, m2)
#define	rz_il_op_free_1(sort, s, v0)    rz_il_op_##sort##_free(op->op.s.v0);
#define	rz_il_op_free_2(sort, s, v0, v1)
#define	rz_il_op_free_3(sort, s, v0, v1, v2)

Functions
RZ_API RZ_OWN RzILOpPure *	rz_il_op_new_ite (RZ_NONNULL RzILOpPure *condition, RZ_NULLABLE RzILOpPure *x, RZ_NULLABLE RzILOpPure *y)
	op structure for ite (bool -> 'a pure -> 'a pure -> 'a pure) More...
RZ_API RZ_OWN RzILOpPure *	rz_il_op_new_var (RZ_NONNULL const char *v, RzILVarKind kind)
	op structure for var ('a var -> 'a pure) More...
RZ_API RZ_OWN RzILOpPure *	rz_il_op_new_let (RZ_NONNULL const char *name, RZ_NONNULL RzILOpPure *exp, RZ_NONNULL RzILOpPure *body)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_b0 ()
	op structure for bool false More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_b1 ()
	op structure for bool true More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bool_and (RZ_NONNULL RzILOpBool *x, RZ_NONNULL RzILOpBool *y)
	op structure for and (bool -> bool -> bool) More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bool_or (RZ_NONNULL RzILOpBool *x, RZ_NONNULL RzILOpBool *y)
	op structure for or (bool -> bool -> bool) More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bool_xor (RZ_NONNULL RzILOpBool *x, RZ_NONNULL RzILOpBool *y)
	op structure for xor (bool -> bool -> bool) More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bool_inv (RZ_NONNULL RzILOpBool *x)
	op structure for inv (!bool -> bool) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_bitv (RZ_NONNULL RzBitVector *value)
	op structure for bitvector More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bitv_from_ut64 (ut32 length, ut64 number)
	op structure for bitvector converted from ut64 More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_bitv_from_st64 (ut32 length, st64 number)
	op structure for bitvector converted from st64 More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_msb (RZ_NONNULL RzILOpBitVector *bv)
	op structure for msb ('s bitv -> bool) [MSB] msb x is the most significant bit of x. More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_lsb (RZ_NONNULL RzILOpBitVector *bv)
	op structure for lsb ('s bitv -> bool) [LSB] lsb x is the least significant bit of x. More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_is_zero (RZ_NONNULL RzILOpPure *bv)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_non_zero (RZ_NONNULL RzILOpPure *bv)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_eq (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_ule (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for sle/ule ('a bitv -> 'a bitv -> bool) More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_sle (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for sle/ule ('a bitv -> 'a bitv -> bool) More...
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_ult (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_slt (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_uge (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_sge (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_ugt (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBool *	rz_il_op_new_sgt (RZ_NONNULL RzILOpPure *x, RZ_NONNULL RzILOpPure *y)
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_cast (ut32 length, RZ_NONNULL RzILOpBool *fill, RZ_NONNULL RzILOpBitVector *val)
	op structure for casting bitv More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_unsigned (ut32 length, RZ_NONNULL RzILOpBitVector *val)
	Extend val to length bits, filling up with zeroes. More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_signed (ut32 length, RZ_NONNULL RzILOpBitVector *val)
	Extend val to length bits, filling up with val's most significant bit. More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_neg (RZ_NONNULL RzILOpBitVector *bv)
	op structure for neg ('s bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_log_not (RZ_NONNULL RzILOpBitVector *bv)
	op structure for not ('s bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_add (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_sub (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_mul (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_div (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_sdiv (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_smod (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_mod (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_log_and (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_log_or (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_log_xor (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_shiftl (RZ_NONNULL RzILOpBool *fill_bit, RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for left shift (bool -> 's bitv -> 'b bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_shiftr (RZ_NONNULL RzILOpBool *fill_bit, RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	op structure for right shift (bool -> 's bitv -> 'b bitv -> 's bitv) More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_shiftr_arith (RZ_NONNULL RzILOpBitVector *x, RZ_NONNULL RzILOpBitVector *y)
	alias for shiftr (msb x) x d, right-shift filling up with the left operand's msb More...
RZ_API RZ_OWN RzILOpBitVector *	rz_il_op_new_append (RZ_NONNULL RzILOpBitVector *high, RZ_NONNULL RzILOpBitVector *low)
	op structure for appending 2 bitv: MSB:LSB high:low More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_empty ()
	oop structure for an empty effect (val empty : 'a sort -> 'a t) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_nop ()
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_set (RZ_NONNULL const char *v, bool is_local, RZ_NONNULL RzILOpPure *x)
	op structure for set ('a var -> 'a pure -> data eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_jmp (RZ_NONNULL RzILOpBitVector *dst)
	op structure for jmp (_ bitv -> ctrl eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_goto (RZ_NONNULL const char *lbl)
	op structure for goto (label -> ctrl eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_seq (RZ_NONNULL RzILOpEffect *x, RZ_NONNULL RzILOpEffect *y)
	op structure for Seq ('a eff -> 'a eff -> 'a eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_seqn (ut32 n,...)
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_blk (RZ_NONNULL const char *label, RZ_NONNULL RzILOpEffect *data_eff, RZ_NONNULL RzILOpEffect *ctrl_eff)
	op structure for blk (label -> data eff -> ctrl eff -> unit eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_repeat (RZ_NONNULL RzILOpBool *condition, RZ_NONNULL RzILOpEffect *data_eff)
	op structure for repeat (bool -> data eff -> data eff) More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_branch (RZ_NONNULL RzILOpBool *condition, RZ_NULLABLE RzILOpEffect *true_eff, RZ_NULLABLE RzILOpEffect *false_eff)
	op structure for branch (bool -> 'a eff -> 'a eff -> 'a eff) More...
RZ_API RZ_OWN RzILOpPure *	rz_il_op_new_load (RzILMemIndex mem, RZ_NONNULL RzILOpPure *key)
	Helper to create RzILOpArgsLoad. More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_store (RzILMemIndex mem, RZ_NONNULL RzILOpBitVector *key, RZ_NONNULL RzILOpBitVector *value)
	Helper to create RzILOpArgsStoreW. More...
RZ_API RZ_OWN RzILOpPure *	rz_il_op_new_loadw (RzILMemIndex mem, RZ_NONNULL RzILOpBitVector *key, ut32 n_bits)
	Helper to create RzILOpArgsLoadW. More...
RZ_API RZ_OWN RzILOpEffect *	rz_il_op_new_storew (RzILMemIndex mem, RZ_NONNULL RzILOpBitVector *key, RZ_NONNULL RzILOpBitVector *value)
	Helper to create RzILOpArgsStoreW. More...
RZ_API RzILOpPure *	rz_il_op_pure_dup (RZ_NONNULL RzILOpPure *op)
RZ_API void	rz_il_op_pure_free (RZ_NULLABLE RzILOpPure *op)
RZ_API void	rz_il_op_effect_free (RZ_NULLABLE RzILOpEffect *op)

Macro Definition Documentation

DUP_OP1

#define DUP_OP1	(		arg,
			m0
	)

Value:

    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        if (!r->op.arg.m0) { \
            return NULL; \
        } \
    } while (0);

DUP_OP2

#define DUP_OP2	(		arg,
			m0,
			m1
	)

Value:

    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        r->op.arg.m1 = rz_il_op_pure_dup(op->op.arg.m1); \
        if (!r->op.arg.m0 || !r->op.arg.m1) { \
            rz_il_op_pure_free(r->op.arg.m0); \
            rz_il_op_pure_free(r->op.arg.m1); \
            return NULL; \
        } \
    } while (0);

DUP_OP3

#define DUP_OP3	(		arg,
			m0,
			m1,
			m2
	)

Value:

    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        r->op.arg.m1 = rz_il_op_pure_dup(op->op.arg.m1); \
        r->op.arg.m2 = rz_il_op_pure_dup(op->op.arg.m2); \
        if (!r->op.arg.m0 || !r->op.arg.m1 || !r->op.arg.m2) { \
            rz_il_op_pure_free(r->op.arg.m0); \
            rz_il_op_pure_free(r->op.arg.m1); \
            rz_il_op_pure_free(r->op.arg.m2); \
            return NULL; \
        } \
    } while (0);

rz_il_op_free_1

#define rz_il_op_free_1	(		sort,
			s,
			v0
	)		rz_il_op_##sort##_free(op->op.s.v0);

Definition at line 916 of file il_opcodes.c.

rz_il_op_free_2

#define rz_il_op_free_2	(		sort,
			s,
			v0,
			v1
	)

Value:

    rz_il_op_##sort##_free(op->op.s.v0); \
    rz_il_op_##sort##_free(op->op.s.v1);

Definition at line 919 of file il_opcodes.c.

rz_il_op_free_3

#define rz_il_op_free_3	(		sort,
			s,
			v0,
			v1,
			v2
	)

Value:

    rz_il_op_##sort##_free(op->op.s.v0); \
    rz_il_op_##sort##_free(op->op.s.v1); \
    rz_il_op_##sort##_free(op->op.s.v2);

Definition at line 923 of file il_opcodes.c.

rz_il_op_new_0

#define rz_il_op_new_0	(		sort,
			id
	)

Value:

    do { \
        ret = RZ_NEW0(RzILOp##sort); \
        if (!ret) { \
            return NULL; \
        } \
        ret->code = id; \
    } while (0)

Definition at line 6 of file il_opcodes.c.

rz_il_op_new_1

#define rz_il_op_new_1	(		sort,
			id,
			t,
			s,
			v0
	)

Value:

    do { \
        ret = RZ_NEW0(RzILOp##sort); \
        if (!ret) { \
            return NULL; \
        } \
        ret->code = id; \
        ret->op.s.v0 = v0; \
    } while (0)

Definition at line 15 of file il_opcodes.c.

rz_il_op_new_2

#define rz_il_op_new_2	(		sort,
			id,
			t,
			s,
			v0,
			v1
	)

Value:

    do { \
        ret = RZ_NEW0(RzILOp##sort); \
        if (!ret) { \
            return NULL; \
        } \
        ret->code = id; \
        ret->op.s.v0 = v0; \
        ret->op.s.v1 = v1; \
    } while (0)

Definition at line 25 of file il_opcodes.c.

rz_il_op_new_3

#define rz_il_op_new_3	(		sort,
			id,
			t,
			s,
			v0,
			v1,
			v2
	)

Value:

    do { \
        ret = RZ_NEW0(RzILOp##sort); \
        if (!ret) { \
            return NULL; \
        } \
        ret->code = id; \
        ret->op.s.v0 = v0; \
        ret->op.s.v1 = v1; \
        ret->op.s.v2 = v2; \
    } while (0)

Definition at line 36 of file il_opcodes.c.

Function Documentation

rz_il_op_effect_free()

RZ_API void rz_il_op_effect_free

(

RZ_NULLABLE RzILOpEffect *

op

)

Definition at line 1036 of file il_opcodes.c.

                                                               {
    if (!op) {
        return;
    }
    switch (op->code) {
    case RZ_IL_OP_EMPTY:
        break;
    case RZ_IL_OP_STORE:
        rz_il_op_free_2(pure, store, key, value);
        break;
    case RZ_IL_OP_STOREW:
        rz_il_op_free_2(pure, storew, key, value);
        break;
    case RZ_IL_OP_NOP:
        break;
    case RZ_IL_OP_SET:
        rz_il_op_free_1(pure, set, x);
        break;
    case RZ_IL_OP_JMP:
        rz_il_op_free_1(pure, jmp, dst);
        break;
    case RZ_IL_OP_GOTO:
        break;
    case RZ_IL_OP_SEQ:
        rz_il_op_free_2(effect, seq, x, y);
        break;
    case RZ_IL_OP_BLK:
        rz_il_op_free_2(effect, blk, data_eff, ctrl_eff);
        break;
    case RZ_IL_OP_REPEAT:
        rz_il_op_pure_free(op->op.repeat.condition);
        rz_il_op_free_1(effect, repeat, data_eff);
        break;
    case RZ_IL_OP_BRANCH:
        rz_il_op_pure_free(op->op.repeat.condition);
        rz_il_op_free_2(effect, branch, true_eff, false_eff);
        break;
    default:
        rz_warn_if_reached();
        RZ_LOG_ERROR("RzIL: unknown opcode %u\n", op->code);
        break;
    }
    free(op);
}

References test-lz4-speed::branch, op::code, dst, free(), jmp, key, repeat(), RZ_IL_OP_BLK, RZ_IL_OP_BRANCH, RZ_IL_OP_EMPTY, rz_il_op_free_1, rz_il_op_free_2, RZ_IL_OP_GOTO, RZ_IL_OP_JMP, RZ_IL_OP_NOP, rz_il_op_pure_free(), RZ_IL_OP_REPEAT, RZ_IL_OP_SEQ, RZ_IL_OP_SET, RZ_IL_OP_STORE, RZ_IL_OP_STOREW, RZ_LOG_ERROR, rz_warn_if_reached, value, and x.

Referenced by ldm(), ldr(), rz_analysis_op_fini(), smlal(), smlaw(), smuad(), ssat(), ssat16(), stm(), str(), strex(), umaal(), and umull().

rz_il_op_new_add()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_add	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[ADD] add x y addition modulo 2^'s

Definition at line 397 of file il_opcodes.c.

                                                                                                              {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_ADD, RzILOpArgsAdd, add, x, y);
    return ret;
}

References add(), NULL, RZ_IL_OP_ADD, rz_il_op_new_2, rz_return_val_if_fail, and x.

Referenced by bf_inc(), and bf_right_arrow().

rz_il_op_new_append()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_append	(	RZ_NONNULL RzILOpBitVector *	high,
		RZ_NONNULL RzILOpBitVector *	low
	)

op structure for appending 2 bitv: MSB:LSB high:low

Definition at line 547 of file il_opcodes.c.

                                                                                                                      {
    rz_return_val_if_fail(high && low, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_APPEND, RzILOpArgsAppend, append, high, low);
    return ret;
}

References append, NULL, RZ_IL_OP_APPEND, rz_il_op_new_2, and rz_return_val_if_fail.

Referenced by avr_il_get_indirect_address_reg().

rz_il_op_new_b0()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_b0

(

)

op structure for bool false

Definition at line 85 of file il_opcodes.c.

                                            {
    RzILOpPure *ret;
    rz_il_op_new_0(Pure, RZ_IL_OP_B0);
    return ret;
}

References RZ_IL_OP_B0, and rz_il_op_new_0.

Referenced by rz_il_op_new_unsigned().

rz_il_op_new_b1()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_b1

(

)

op structure for bool true

Definition at line 94 of file il_opcodes.c.

                                            {
    RzILOpPure *ret;
    rz_il_op_new_0(Pure, RZ_IL_OP_B1);
    return ret;
}

References RZ_IL_OP_B1, and rz_il_op_new_0.

rz_il_op_new_bitv()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_bitv

(

RZ_NONNULL RzBitVector *

value

)

op structure for bitvector

value is a bitvector constant.

Definition at line 161 of file il_opcodes.c.

                                                                                {
    rz_return_val_if_fail(value, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_1(BitVector, RZ_IL_OP_BITV, RzILOpArgsBv, bitv, value);
    return ret;
}

References NULL, RZ_IL_OP_BITV, rz_il_op_new_1, rz_return_val_if_fail, and value.

rz_il_op_new_bitv_from_st64()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bitv_from_st64	(	ut32	length,
		st64	number
	)

op structure for bitvector converted from st64

value is a bitvector constant.

Definition at line 193 of file il_opcodes.c.

                                                                                {
    RzBitVector *value = rz_bv_new_from_st64(length, number);
    if (!value) {
        return NULL;
    }
    RzILOpBool *ret = RZ_NEW0(RzILOpBool);
    if (!ret) {
        rz_bv_free(value);
        return NULL;
    }
    ret->code = RZ_IL_OP_BITV;
    ret->op.bitv.value = value;
    return ret;
}

References rz_il_op_pure_t::bitv, rz_il_op_pure_t::code, length, NULL, rz_il_op_pure_t::op, rz_bv_free(), rz_bv_new_from_st64(), RZ_IL_OP_BITV, RZ_NEW0, value, and rz_il_op_args_bv_t::value.

rz_il_op_new_bitv_from_ut64()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bitv_from_ut64	(	ut32	length,
		ut64	number
	)

op structure for bitvector converted from ut64

value is a bitvector constant.

Definition at line 173 of file il_opcodes.c.

                                                                                {
    RzBitVector *value = rz_bv_new_from_ut64(length, number);
    if (!value) {
        return NULL;
    }
    RzILOpBool *ret = RZ_NEW0(RzILOpBool);
    if (!ret) {
        rz_bv_free(value);
        return NULL;
    }
    ret->code = RZ_IL_OP_BITV;
    ret->op.bitv.value = value;
    return ret;
}

References rz_il_op_pure_t::bitv, rz_il_op_pure_t::code, length, NULL, rz_il_op_pure_t::op, rz_bv_free(), rz_bv_new_from_ut64(), RZ_IL_OP_BITV, RZ_NEW0, value, and rz_il_op_args_bv_t::value.

Referenced by bf_llimit(), and bf_rlimit().

rz_il_op_new_blk()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_blk	(	RZ_NONNULL const char *	label,
		RZ_NONNULL RzILOpEffect *	data_eff,
		RZ_NONNULL RzILOpEffect *	ctrl_eff
	)

op structure for blk (label -> data eff -> ctrl eff -> unit eff)

blk lbl data ctrl a labeled sequence of effects.

Definition at line 678 of file il_opcodes.c.

                                                                                                                                                 {
    rz_return_val_if_fail(data_eff && ctrl_eff, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_3(Effect, RZ_IL_OP_BLK, RzILOpArgsBlk, blk, label, data_eff, ctrl_eff);
    return ret;
}

References NULL, RZ_IL_OP_BLK, rz_il_op_new_3, and rz_return_val_if_fail.

rz_il_op_new_bool_and()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bool_and	(	RZ_NONNULL RzILOpBool *	x,
		RZ_NONNULL RzILOpBool *	y
	)

op structure for and (bool -> bool -> bool)

BAP equivalent: val and_ : bool -> bool -> bool and(x, y) is a conjunction of x and y.

Definition at line 107 of file il_opcodes.c.

                                                                                                    {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_AND, RzILOpArgsBoolAnd, booland, x, y);
    return ret;
}

References NULL, RZ_IL_OP_AND, rz_il_op_new_2, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_slt(), and rz_il_op_new_ult().

rz_il_op_new_bool_inv()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bool_inv

(

RZ_NONNULL RzILOpBool *

x

)

op structure for inv (!bool -> bool)

BAP equivalent: val inv : bool -> bool inv(x) inverts x (also known as not operation).

Definition at line 149 of file il_opcodes.c.

                                                                          {
    rz_return_val_if_fail(x, NULL);
    RzILOpBool *ret;
    rz_il_op_new_1(Bool, RZ_IL_OP_INV, RzILOpArgsBoolInv, boolinv, x);
    return ret;
}

References NULL, RZ_IL_OP_INV, rz_il_op_new_1, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_non_zero(), rz_il_op_new_sge(), rz_il_op_new_sgt(), rz_il_op_new_slt(), rz_il_op_new_uge(), rz_il_op_new_ugt(), and rz_il_op_new_ult().

rz_il_op_new_bool_or()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bool_or	(	RZ_NONNULL RzILOpBool *	x,
		RZ_NONNULL RzILOpBool *	y
	)

op structure for or (bool -> bool -> bool)

BAP equivalent: val or_ : bool -> bool -> bool or(x, y) is a conjunction of x or y.

Definition at line 121 of file il_opcodes.c.

                                                                                                   {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_OR, RzILOpArgsBoolOr, boolor, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_OR, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_sge(), and rz_il_op_new_uge().

rz_il_op_new_bool_xor()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_bool_xor	(	RZ_NONNULL RzILOpBool *	x,
		RZ_NONNULL RzILOpBool *	y
	)

op structure for xor (bool -> bool -> bool)

BAP equivalent: val xor_ : bool -> bool -> bool xor(x, y) is a conjunction of x xor y.

Definition at line 135 of file il_opcodes.c.

                                                                                                    {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_XOR, RzILOpArgsBoolXor, boolxor, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_XOR, rz_return_val_if_fail, and x.

rz_il_op_new_branch()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_branch	(	RZ_NONNULL RzILOpBool *	condition,
		RZ_NULLABLE RzILOpEffect *	true_eff,
		RZ_NULLABLE RzILOpEffect *	false_eff
	)

op structure for branch (bool -> 'a eff -> 'a eff -> 'a eff)

branch c lhs rhs if c holds then performs lhs else rhs.

Definition at line 702 of file il_opcodes.c.

                                                                                                                                                           {
    rz_return_val_if_fail(condition && (true_eff || false_eff), NULL);
    RzILOpEffect *ret;
    if (!true_eff) {
        true_eff = rz_il_op_new_nop();
    }
    if (!false_eff) {
        false_eff = rz_il_op_new_nop();
    }
    rz_il_op_new_3(Effect, RZ_IL_OP_BRANCH, RzILOpArgsBranch, branch, condition, true_eff, false_eff);
    return ret;
}

References test-lz4-speed::branch, NULL, RZ_IL_OP_BRANCH, rz_il_op_new_3, rz_il_op_new_nop(), and rz_return_val_if_fail.

Referenced by bf_llimit(), and bf_rlimit().

rz_il_op_new_cast()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_cast	(	ut32	length,
		RZ_NONNULL RzILOpBool *	fill,
		RZ_NONNULL RzILOpBitVector *	val
	)

op structure for casting bitv

Definition at line 341 of file il_opcodes.c.

                                                                                                                            {
    rz_return_val_if_fail(length > 0 && val, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_3(BitVector, RZ_IL_OP_CAST, RzILOpArgsCast, cast, length, fill, val);
    return ret;
}

References cast, length, NULL, RZ_IL_OP_CAST, rz_il_op_new_3, rz_return_val_if_fail, and val.

Referenced by rz_il_op_new_signed(), rz_il_op_new_unsigned(), and sh_il_signed().

rz_il_op_new_div()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_div	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[DIV] div x y unsigned division modulo 2^'s truncating towards 0. The division by zero is defined to be a vector of all ones of size 's.

Definition at line 433 of file il_opcodes.c.

                                                                                                              {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_DIV, RzILOpArgsDiv, div, x, y);
    return ret;
}

References NULL, RZ_IL_OP_DIV, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_empty()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_empty

(

)

oop structure for an empty effect (val empty : 'a sort -> 'a t)

empty s creates an empty effect value. The empty effect denotes an absence of any specific knowledge about the effects produced by a term.

Definition at line 560 of file il_opcodes.c.

                                                 {
    RzILOpEffect *ret;
    rz_il_op_new_0(Effect, RZ_IL_OP_EMPTY);
    return ret;
}

References RZ_IL_OP_EMPTY, and rz_il_op_new_0.

rz_il_op_new_eq()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_eq	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

[EQ] eq x y binary predicate for bitwise equality

Definition at line 251 of file il_opcodes.c.

                                                                                                        {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_EQ, RzILOpArgsEq, eq, x, y);
    return ret;
}

References eq, NULL, RZ_IL_OP_EQ, rz_il_op_new_2, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_sge(), rz_il_op_new_slt(), rz_il_op_new_uge(), and rz_il_op_new_ult().

rz_il_op_new_goto()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_goto

(

RZ_NONNULL const char *

lbl

)

op structure for goto (label -> ctrl eff)

goto label passes the control to a program labeled with lbl.

Definition at line 601 of file il_opcodes.c.

                                                                          {
    rz_return_val_if_fail(lbl, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_1(Effect, RZ_IL_OP_GOTO, RzILOpArgsGoto, goto_, lbl);
    return ret;
}

References NULL, RZ_IL_OP_GOTO, rz_il_op_new_1, and rz_return_val_if_fail.

Referenced by bf_in(), and bf_out().

rz_il_op_new_is_zero()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_is_zero

(

RZ_NONNULL RzILOpPure *

bv

)

[IS_ZERO] is_zero x holds if x is a bitvector of all zeros.

Definition at line 233 of file il_opcodes.c.

                                                                          {
    rz_return_val_if_fail(bv, NULL);
    RzILOpBool *ret;
    rz_il_op_new_1(Bool, RZ_IL_OP_IS_ZERO, RzILOpArgsIsZero, is_zero, bv);
    return ret;
}

References NULL, RZ_IL_OP_IS_ZERO, rz_il_op_new_1, and rz_return_val_if_fail.

Referenced by rz_il_op_new_non_zero().

rz_il_op_new_ite()

RZ_API RZ_OWN RzILOpPure* rz_il_op_new_ite	(	RZ_NONNULL RzILOpPure *	condition,
		RZ_NULLABLE RzILOpPure *	x,
		RZ_NULLABLE RzILOpPure *	y
	)

op structure for ite (bool -> 'a pure -> 'a pure -> 'a pure)

ite condition x y is x if condition evaluates to b1 else y.

Definition at line 53 of file il_opcodes.c.

                                                                                                                                   {
    rz_return_val_if_fail(condition && (x || y), NULL);
    RzILOpPure *ret;
    rz_il_op_new_3(Pure, RZ_IL_OP_ITE, RzILOpArgsIte, ite, condition, x, y);
    return ret;
}

References NULL, RZ_IL_OP_ITE, rz_il_op_new_3, rz_return_val_if_fail, and x.

Referenced by avr_il_cpc(), and avr_il_sreg_bit_as_imm().

rz_il_op_new_jmp()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_jmp

(

RZ_NONNULL RzILOpBitVector *

dst

)

op structure for jmp (_ bitv -> ctrl eff)

jmp dst passes the control to a program located at dst.

Definition at line 589 of file il_opcodes.c.

                                                                              {
    rz_return_val_if_fail(dst, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_1(Effect, RZ_IL_OP_JMP, RzILOpArgsJmp, jmp, dst);
    return ret;
}

References dst, jmp, NULL, RZ_IL_OP_JMP, rz_il_op_new_1, and rz_return_val_if_fail.

Referenced by bf_llimit(), and bf_rlimit().

rz_il_op_new_let()

RZ_API RZ_OWN RzILOpPure* rz_il_op_new_let	(	RZ_NONNULL const char *	name,
		RZ_NONNULL RzILOpPure *	exp,
		RZ_NONNULL RzILOpPure *	body
	)

let_ v exp body binds the value of exp to v body.

Definition at line 75 of file il_opcodes.c.

                                                                                                                                 {
    rz_return_val_if_fail(name && exp && body, NULL);
    RzILOpPure *ret;
    rz_il_op_new_3(Pure, RZ_IL_OP_LET, RzILOpArgsLet, let, name, exp, body);
    return ret;
}

References NULL, RZ_IL_OP_LET, rz_il_op_new_3, and rz_return_val_if_fail.

rz_il_op_new_load()

RZ_API RZ_OWN RzILOpPure* rz_il_op_new_load	(	RzILMemIndex	mem,
		RZ_NONNULL RzILOpPure *	key
	)

Helper to create RzILOpArgsLoad.

Definition at line 718 of file il_opcodes.c.

                                                                                          {
    rz_return_val_if_fail(key, NULL);
    RzILOpPure *ret;
    rz_il_op_new_2(Pure, RZ_IL_OP_LOAD, RzILOpArgsLoad, load, mem, key);
    return ret;
}

References key, load(), mem, NULL, RZ_IL_OP_LOAD, rz_il_op_new_2, and rz_return_val_if_fail.

Referenced by bf_dec(), bf_inc(), bf_llimit(), and bf_rlimit().

rz_il_op_new_loadw()

RZ_API RZ_OWN RzILOpPure* rz_il_op_new_loadw	(	RzILMemIndex	mem,
		RZ_NONNULL RzILOpBitVector *	key,
		ut32	n_bits
	)

Helper to create RzILOpArgsLoadW.

Definition at line 738 of file il_opcodes.c.

                                                                                                             {
    rz_return_val_if_fail(key && n_bits, NULL);
    RzILOpPure *ret;
    rz_il_op_new_3(Pure, RZ_IL_OP_LOADW, RzILOpArgsLoadW, loadw, mem, key, n_bits);
    return ret;
}

References key, mem, NULL, RZ_IL_OP_LOADW, rz_il_op_new_3, and rz_return_val_if_fail.

Referenced by avr_il_lpm().

rz_il_op_new_log_and()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_log_and	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[LOGAND] logand x y is a bitwise logical and of x and y.

Definition at line 481 of file il_opcodes.c.

                                                                                                                  {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_LOGAND, RzILOpArgsLogand, logand, x, y);
    return ret;
}

References NULL, RZ_IL_OP_LOGAND, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_log_not()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_log_not

(

RZ_NONNULL RzILOpBitVector *

bv

)

op structure for not ('s bitv -> 's bitv)

not x is one-complement unary minus

Definition at line 385 of file il_opcodes.c.

                                                                                    {
    rz_return_val_if_fail(bv, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_1(BitVector, RZ_IL_OP_LOGNOT, RzILOpArgsLogNot, lognot, bv);
    return ret;
}

References NULL, RZ_IL_OP_LOGNOT, rz_il_op_new_1, and rz_return_val_if_fail.

rz_il_op_new_log_or()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_log_or	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[LOGOR] logor x y is a bitwise logical or of x and y.

Definition at line 493 of file il_opcodes.c.

                                                                                                                 {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_LOGOR, RzILOpArgsLogor, logor, x, y);
    return ret;
}

References NULL, RZ_IL_OP_LOGOR, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_log_xor()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_log_xor	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[LOGXOR] logxor x y is a bitwise logical xor of x and y.

Definition at line 505 of file il_opcodes.c.

                                                                                                                  {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_LOGXOR, RzILOpArgsLogxor, logxor, x, y);
    return ret;
}

References NULL, RZ_IL_OP_LOGXOR, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_lsb()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_lsb

(

RZ_NONNULL RzILOpBitVector *

bv

)

op structure for lsb ('s bitv -> bool) [LSB] lsb x is the least significant bit of x.

Definition at line 223 of file il_opcodes.c.

                                                                           {
    rz_return_val_if_fail(bv, NULL);
    RzILOpBool *ret;
    rz_il_op_new_1(Bool, RZ_IL_OP_LSB, RzILOpArgsMsb, lsb, bv);
    return ret;
}

References NULL, RZ_IL_OP_LSB, rz_il_op_new_1, and rz_return_val_if_fail.

rz_il_op_new_mod()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_mod	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[MOD] modulo x y is the remainder of div x y modulo 2^'s.

Definition at line 469 of file il_opcodes.c.

                                                                                                              {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_SMOD, RzILOpArgsMod, mod, x, y);
    return ret;
}

References mod(), NULL, rz_il_op_new_2, RZ_IL_OP_SMOD, rz_return_val_if_fail, and x.

rz_il_op_new_msb()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_msb

(

RZ_NONNULL RzILOpBitVector *

bv

)

op structure for msb ('s bitv -> bool) [MSB] msb x is the most significant bit of x.

Definition at line 212 of file il_opcodes.c.

                                                                           {
    rz_return_val_if_fail(bv, NULL);
    RzILOpBool *ret;
    rz_il_op_new_1(Bool, RZ_IL_OP_MSB, RzILOpArgsLsb, lsb, bv);
    return ret;
}

References NULL, RZ_IL_OP_MSB, rz_il_op_new_1, and rz_return_val_if_fail.

Referenced by rz_il_op_new_shiftr_arith(), and rz_il_op_new_signed().

rz_il_op_new_mul()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_mul	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[MUL] mul x y multiplication modulo 2^'s

Definition at line 421 of file il_opcodes.c.

                                                                                                              {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_MUL, RzILOpArgsMul, mul, x, y);
    return ret;
}

References mul(), NULL, RZ_IL_OP_MUL, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_neg()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_neg

(

RZ_NONNULL RzILOpBitVector *

bv

)

op structure for neg ('s bitv -> 's bitv)

neg x is two-complement unary minus

Definition at line 373 of file il_opcodes.c.

                                                                                {
    rz_return_val_if_fail(bv, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_1(BitVector, RZ_IL_OP_NEG, RzILOpArgsNeg, neg, bv);
    return ret;
}

References neg(), NULL, RZ_IL_OP_NEG, rz_il_op_new_1, and rz_return_val_if_fail.

rz_il_op_new_non_zero()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_non_zero

(

RZ_NONNULL RzILOpPure *

bv

)

[NON_ZERO] non_zero x holds if x is not a bitvector of all zeroes.

Definition at line 243 of file il_opcodes.c.

                                                                           {
    rz_return_val_if_fail(bv, NULL);
    return rz_il_op_new_bool_inv(rz_il_op_new_is_zero(bv));
}

References NULL, rz_il_op_new_bool_inv(), rz_il_op_new_is_zero(), and rz_return_val_if_fail.

Referenced by bf_llimit(), and bf_rlimit().

rz_il_op_new_nop()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_nop

(

)

Definition at line 566 of file il_opcodes.c.

                                               {
    RzILOpEffect *ret;
    rz_il_op_new_0(Effect, RZ_IL_OP_NOP);
    return ret;
}

References rz_il_op_new_0, and RZ_IL_OP_NOP.

Referenced by _6502_op(), bf_op(), rz_il_op_new_branch(), and rz_il_op_new_seqn().

rz_il_op_new_repeat()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_repeat	(	RZ_NONNULL RzILOpBool *	condition,
		RZ_NONNULL RzILOpEffect *	data_eff
	)

op structure for repeat (bool -> data eff -> data eff)

repeat c data repeats data effects until the condition c holds.

Definition at line 690 of file il_opcodes.c.

                                                                                                                     {
    rz_return_val_if_fail(condition && data_eff, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_2(Effect, RZ_IL_OP_REPEAT, RzILOpArgsRepeat, repeat, condition, data_eff);
    return ret;
}

References NULL, repeat(), rz_il_op_new_2, RZ_IL_OP_REPEAT, and rz_return_val_if_fail.

rz_il_op_new_sdiv()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_sdiv	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[SDIV] sdiv x y is signed division of x by y modulo 2^'s.

Definition at line 445 of file il_opcodes.c.

                                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_SDIV, RzILOpArgsSdiv, sdiv, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_SDIV, rz_return_val_if_fail, sdiv(), and x.

rz_il_op_new_seq()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_seq	(	RZ_NONNULL RzILOpEffect *	x,
		RZ_NONNULL RzILOpEffect *	y
	)

op structure for Seq ('a eff -> 'a eff -> 'a eff)

seq x y performs effect x, after that perform effect y. Pack two effects into one.

Definition at line 613 of file il_opcodes.c.

                                                                                                     {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_2(Effect, RZ_IL_OP_SEQ, RzILOpArgsSeq, seq, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_SEQ, rz_return_val_if_fail, and x.

rz_il_op_new_seqn()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_seqn	(	ut32	n,
			...
	)

Chain n opcodes given as varargs in sequence using seq if necessary

It works exactly like this seq helper from BAP: let rec seq = function | [] -> CT.perform Theory.Effect.Sort.bot | [x] -> x | x :: xs -> CT.seq x @ seq xs

Parameters

n	number of total opcodes given
...	num RzILOpEffect * ops to be executed in sequence

Definition at line 632 of file il_opcodes.c.

                                                           {
    if (!n) {
        return rz_il_op_new_nop();
    }
    RzILOpEffect *root = NULL;
    RzILOpEffect *prev_seq = NULL;
    va_list args;
    va_start(args, n);
    for (ut32 i = 0; i < n; ++i) {
        RzILOpEffect *cur_op = va_arg(args, RzILOpEffect *);
        if (i == n - 1) {
            // last one
            if (prev_seq) {
                prev_seq->op.seq.y = cur_op;
            } else {
                // n == 1, no need for seq at all
                root = cur_op;
            }
            break;
        }
        RzILOpEffect *seq = RZ_NEW0(RzILOpEffect);
        if (!seq) {
            break;
        }
        seq->code = RZ_IL_OP_SEQ;
        seq->op.seq.x = cur_op;
        if (prev_seq) {
            // not the first one
            // We let the seq recurse in the second op because that
            // can enable tail call elimination in the evaluation.
            prev_seq->op.seq.y = seq;
        } else {
            // first one
            root = seq;
        }
        prev_seq = seq;
    }
    va_end(args);
    return root;
}

References args, rz_il_op_effect_t::code, i, n, NULL, rz_il_op_effect_t::op, root, rz_il_op_new_nop(), RZ_IL_OP_SEQ, RZ_NEW0, rz_il_op_effect_t::seq, rz_il_op_args_seq_t::x, and rz_il_op_args_seq_t::y.

rz_il_op_new_set()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_set	(	RZ_NONNULL const char *	v,
		bool	is_local,
		RZ_NONNULL RzILOpPure *	x
	)

op structure for set ('a var -> 'a pure -> data eff)

set v x changes the value stored in v to the value of x.

Definition at line 577 of file il_opcodes.c.

                                                                                                                {
    rz_return_val_if_fail(v && x, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_3(Effect, RZ_IL_OP_SET, RzILOpArgsSet, set, v, is_local, x);
    return ret;
}

References NULL, rz_il_op_new_3, RZ_IL_OP_SET, rz_return_val_if_fail, v, and x.

rz_il_op_new_sge()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_sge	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

signed greater or equal

Definition at line 315 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_or(
        rz_il_op_new_bool_inv(rz_il_op_new_sle(x, y)),
        rz_il_op_new_eq(rz_il_op_pure_dup(x), rz_il_op_pure_dup(y)));
}

References NULL, rz_il_op_new_bool_inv(), rz_il_op_new_bool_or(), rz_il_op_new_eq(), rz_il_op_new_sle(), rz_il_op_pure_dup(), rz_return_val_if_fail, and x.

rz_il_op_new_sgt()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_sgt	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

signed strictly greater than

Definition at line 333 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_inv(rz_il_op_new_sle(x, y));
}

References NULL, rz_il_op_new_bool_inv(), rz_il_op_new_sle(), rz_return_val_if_fail, and x.

rz_il_op_new_shiftl()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_shiftl	(	RZ_NONNULL RzILOpBool *	fill_bit,
		RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for left shift (bool -> 's bitv -> 'b bitv -> 's bitv)

[LSHIFT] shiftl s x m shifts x left by m bits filling with s.

Definition at line 517 of file il_opcodes.c.

                                                                                                                                                  {
    rz_return_val_if_fail(fill_bit && x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_3(BitVector, RZ_IL_OP_SHIFTL, RzILOpArgsShiftLeft, shiftl, fill_bit, x, y);
    return ret;
}

References NULL, rz_il_op_new_3, RZ_IL_OP_SHIFTL, rz_return_val_if_fail, and x.

rz_il_op_new_shiftr()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_shiftr	(	RZ_NONNULL RzILOpBool *	fill_bit,
		RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for right shift (bool -> 's bitv -> 'b bitv -> 's bitv)

[RSHIFT] shiftr s x m shifts x right by m bits filling with s.

Definition at line 529 of file il_opcodes.c.

                                                                                                                                                  {
    rz_return_val_if_fail(fill_bit && x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_3(BitVector, RZ_IL_OP_SHIFTR, RzILOpArgsShiftRight, shiftr, fill_bit, x, y);
    return ret;
}

References NULL, rz_il_op_new_3, RZ_IL_OP_SHIFTR, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_shiftr_arith().

rz_il_op_new_shiftr_arith()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_shiftr_arith	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

alias for shiftr (msb x) x d, right-shift filling up with the left operand's msb

Definition at line 539 of file il_opcodes.c.

                                                                                                                       {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_shiftr(rz_il_op_new_msb(rz_il_op_pure_dup(x)), x, y);
}

References NULL, rz_il_op_new_msb(), rz_il_op_new_shiftr(), rz_il_op_pure_dup(), rz_return_val_if_fail, and x.

rz_il_op_new_signed()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_signed	(	ut32	length,
		RZ_NONNULL RzILOpBitVector *	val
	)

Extend val to length bits, filling up with val's most significant bit.

For length > val->len, this fits the general notion of sign extension.

Definition at line 363 of file il_opcodes.c.

                                                                                                 {
    rz_return_val_if_fail(length && val, NULL);
    return rz_il_op_new_cast(length, rz_il_op_new_msb(rz_il_op_pure_dup(val)), val);
}

References length, NULL, rz_il_op_new_cast(), rz_il_op_new_msb(), rz_il_op_pure_dup(), rz_return_val_if_fail, and val.

Referenced by qadd16(), qadd8(), sadd16(), and sadd8().

rz_il_op_new_sle()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_sle	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for sle/ule ('a bitv -> 'a bitv -> bool)

[SLE] sle x y binary predicate for signed less than or equal

Definition at line 275 of file il_opcodes.c.

                                                                                                         {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_SLE, RzILOpArgsSle, sle, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_SLE, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_sge(), rz_il_op_new_sgt(), and rz_il_op_new_slt().

rz_il_op_new_slt()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_slt	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

signed strict less than

Definition at line 295 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_and(
        rz_il_op_new_sle(x, y),
        rz_il_op_new_bool_inv(rz_il_op_new_eq(rz_il_op_pure_dup(x), rz_il_op_pure_dup(y))));
}

References NULL, rz_il_op_new_bool_and(), rz_il_op_new_bool_inv(), rz_il_op_new_eq(), rz_il_op_new_sle(), rz_il_op_pure_dup(), rz_return_val_if_fail, and x.

rz_il_op_new_smod()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_smod	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[SMOD] smodulo x y is the signed remainder of div x y modulo 2^'s.

Definition at line 457 of file il_opcodes.c.

                                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_MOD, RzILOpArgsSmod, smod, x, y);
    return ret;
}

References NULL, RZ_IL_OP_MOD, rz_il_op_new_2, rz_return_val_if_fail, and x.

rz_il_op_new_store()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_store	(	RzILMemIndex	mem,
		RZ_NONNULL RzILOpBitVector *	key,
		RZ_NONNULL RzILOpBitVector *	value
	)

Helper to create RzILOpArgsStoreW.

Definition at line 728 of file il_opcodes.c.

                                                                                                                                     {
    rz_return_val_if_fail(key && value, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_3(Effect, RZ_IL_OP_STORE, RzILOpArgsStore, store, mem, key, value);
    return ret;
}

References key, mem, NULL, rz_il_op_new_3, RZ_IL_OP_STORE, rz_return_val_if_fail, and value.

Referenced by bf_dec(), and bf_inc().

rz_il_op_new_storew()

RZ_API RZ_OWN RzILOpEffect* rz_il_op_new_storew	(	RzILMemIndex	mem,
		RZ_NONNULL RzILOpBitVector *	key,
		RZ_NONNULL RzILOpBitVector *	value
	)

Helper to create RzILOpArgsStoreW.

Definition at line 748 of file il_opcodes.c.

                                                                                                                                      {
    rz_return_val_if_fail(key && value, NULL);
    RzILOpEffect *ret;
    rz_il_op_new_3(Effect, RZ_IL_OP_STOREW, RzILOpArgsStoreW, storew, mem, key, value);
    return ret;
}

References key, mem, NULL, rz_il_op_new_3, RZ_IL_OP_STOREW, rz_return_val_if_fail, and value.

rz_il_op_new_sub()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_sub	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for two-operand algorithm and logical operations ('s bitv -> 's bitv -> 's bitv)

[SUB] sub x y subtraction modulo 2^'s

Definition at line 409 of file il_opcodes.c.

                                                                                                              {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBitVector *ret;
    rz_il_op_new_2(BitVector, RZ_IL_OP_SUB, RzILOpArgsSub, sub, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_SUB, rz_return_val_if_fail, and x.

Referenced by bf_dec(), and bf_left_arrow().

rz_il_op_new_uge()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_uge	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

unsigned greater or equal

Definition at line 305 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_or(
        rz_il_op_new_bool_inv(rz_il_op_new_ule(x, y)),
        rz_il_op_new_eq(rz_il_op_pure_dup(x), rz_il_op_pure_dup(y)));
}

References NULL, rz_il_op_new_bool_inv(), rz_il_op_new_bool_or(), rz_il_op_new_eq(), rz_il_op_new_ule(), rz_il_op_pure_dup(), rz_return_val_if_fail, and x.

rz_il_op_new_ugt()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_ugt	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

unsigned strictly greater than

Definition at line 325 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_inv(rz_il_op_new_ule(x, y));
}

References NULL, rz_il_op_new_bool_inv(), rz_il_op_new_ule(), rz_return_val_if_fail, and x.

rz_il_op_new_ule()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_ule	(	RZ_NONNULL RzILOpBitVector *	x,
		RZ_NONNULL RzILOpBitVector *	y
	)

op structure for sle/ule ('a bitv -> 'a bitv -> bool)

[ULE] ule x y binary predicate for unsigned less than or equal

Definition at line 263 of file il_opcodes.c.

                                                                                                         {
    rz_return_val_if_fail(x && y, NULL);
    RzILOpBool *ret;
    rz_il_op_new_2(Bool, RZ_IL_OP_ULE, RzILOpArgsUle, ule, x, y);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_ULE, rz_return_val_if_fail, and x.

Referenced by rz_il_op_new_uge(), rz_il_op_new_ugt(), and rz_il_op_new_ult().

rz_il_op_new_ult()

RZ_API RZ_OWN RzILOpBool* rz_il_op_new_ult	(	RZ_NONNULL RzILOpPure *	x,
		RZ_NONNULL RzILOpPure *	y
	)

unsigned strict less than

Definition at line 285 of file il_opcodes.c.

                                                                                               {
    rz_return_val_if_fail(x && y, NULL);
    return rz_il_op_new_bool_and(
        rz_il_op_new_ule(x, y),
        rz_il_op_new_bool_inv(rz_il_op_new_eq(rz_il_op_pure_dup(x), rz_il_op_pure_dup(y))));
}

References NULL, rz_il_op_new_bool_and(), rz_il_op_new_bool_inv(), rz_il_op_new_eq(), rz_il_op_new_ule(), rz_il_op_pure_dup(), rz_return_val_if_fail, and x.

rz_il_op_new_unsigned()

RZ_API RZ_OWN RzILOpBitVector* rz_il_op_new_unsigned	(	ut32	length,
		RZ_NONNULL RzILOpBitVector *	val
	)

Extend val to length bits, filling up with zeroes.

For length > val->len, this fits the general notion of zero extension.

Definition at line 353 of file il_opcodes.c.

                                                                                                   {
    rz_return_val_if_fail(length && val, NULL);
    return rz_il_op_new_cast(length, rz_il_op_new_b0(), val);
}

References length, NULL, rz_il_op_new_b0(), rz_il_op_new_cast(), rz_return_val_if_fail, and val.

Referenced by qadd16(), qadd8(), sadd16(), and sadd8().

rz_il_op_new_var()

RZ_API RZ_OWN RzILOpPure* rz_il_op_new_var	(	RZ_NONNULL const char *	v,
		RzILVarKind	kind
	)

op structure for var ('a var -> 'a pure)

var v is the value of the variable v.

Definition at line 65 of file il_opcodes.c.

                                                                                       {
    rz_return_val_if_fail(v, NULL);
    RzILOpPure *ret;
    rz_il_op_new_2(Pure, RZ_IL_OP_VAR, RzILOpArgsVar, var, v, kind);
    return ret;
}

References NULL, rz_il_op_new_2, RZ_IL_OP_VAR, rz_return_val_if_fail, and v.

Referenced by bf_llimit(), and bf_rlimit().

rz_il_op_pure_dup()

RZ_API RzILOpPure* rz_il_op_pure_dup

(

RZ_NONNULL RzILOpPure *

op

)

Duplicate the given op recursively, for example to reuse it multiple times in another op.

Definition at line 763 of file il_opcodes.c.

                                                                {
    rz_return_val_if_fail(op, NULL);
    RzILOpPure *r = RZ_NEW0(RzILOpPure);
    if (!r) {
        return NULL;
    }
#define DUP_OP1(arg, m0) \
    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        if (!r->op.arg.m0) { \
            return NULL; \
        } \
    } while (0);
#define DUP_OP2(arg, m0, m1) \
    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        r->op.arg.m1 = rz_il_op_pure_dup(op->op.arg.m1); \
        if (!r->op.arg.m0 || !r->op.arg.m1) { \
            rz_il_op_pure_free(r->op.arg.m0); \
            rz_il_op_pure_free(r->op.arg.m1); \
            return NULL; \
        } \
    } while (0);
#define DUP_OP3(arg, m0, m1, m2) \
    do { \
        r->op.arg.m0 = rz_il_op_pure_dup(op->op.arg.m0); \
        r->op.arg.m1 = rz_il_op_pure_dup(op->op.arg.m1); \
        r->op.arg.m2 = rz_il_op_pure_dup(op->op.arg.m2); \
        if (!r->op.arg.m0 || !r->op.arg.m1 || !r->op.arg.m2) { \
            rz_il_op_pure_free(r->op.arg.m0); \
            rz_il_op_pure_free(r->op.arg.m1); \
            rz_il_op_pure_free(r->op.arg.m2); \
            return NULL; \
        } \
    } while (0);
    r->code = op->code;
    switch (op->code) {
    case RZ_IL_OP_VAR:
        r->op.var.v = op->op.var.v;
        r->op.var.kind = op->op.var.kind;
        break;
    case RZ_IL_OP_ITE:
        DUP_OP3(ite, condition, x, y);
        break;
    case RZ_IL_OP_LET:
        r->op.let.name = op->op.let.name;
        DUP_OP2(let, exp, body);
        break;
    case RZ_IL_OP_B0:
        break;
    case RZ_IL_OP_B1:
        break;
    case RZ_IL_OP_INV:
        DUP_OP1(boolinv, x);
        break;
    case RZ_IL_OP_AND:
        DUP_OP2(booland, x, y);
        break;
    case RZ_IL_OP_OR:
        DUP_OP2(boolor, x, y);
        break;
    case RZ_IL_OP_XOR:
        DUP_OP2(boolxor, x, y);
        break;
    case RZ_IL_OP_BITV:
        r->op.bitv.value = rz_bv_dup(op->op.bitv.value);
        break;
    case RZ_IL_OP_MSB:
        DUP_OP1(msb, bv);
        break;
    case RZ_IL_OP_LSB:
        DUP_OP1(lsb, bv);
        break;
    case RZ_IL_OP_IS_ZERO:
        DUP_OP1(is_zero, bv);
        break;
    case RZ_IL_OP_NEG:
        DUP_OP1(neg, bv);
        break;
    case RZ_IL_OP_LOGNOT:
        DUP_OP1(lognot, bv);
        break;
    case RZ_IL_OP_ADD:
        DUP_OP2(add, x, y);
        break;
    case RZ_IL_OP_SUB:
        DUP_OP2(sub, x, y);
        break;
    case RZ_IL_OP_MUL:
        DUP_OP2(mul, x, y);
        break;
    case RZ_IL_OP_DIV:
        DUP_OP2(div, x, y);
        break;
    case RZ_IL_OP_SDIV:
        DUP_OP2(sdiv, x, y);
        break;
    case RZ_IL_OP_MOD:
        DUP_OP2(mod, x, y);
        break;
    case RZ_IL_OP_SMOD:
        DUP_OP2(smod, x, y);
        break;
    case RZ_IL_OP_LOGAND:
        DUP_OP2(logand, x, y);
        break;
    case RZ_IL_OP_LOGOR:
        DUP_OP2(logor, x, y);
        break;
    case RZ_IL_OP_LOGXOR:
        DUP_OP2(logxor, x, y);
        break;
    case RZ_IL_OP_SHIFTR:
        DUP_OP3(shiftr, x, y, fill_bit);
        break;
    case RZ_IL_OP_SHIFTL:
        DUP_OP3(shiftl, x, y, fill_bit);
        break;
    case RZ_IL_OP_EQ:
        DUP_OP2(eq, x, y);
        break;
    case RZ_IL_OP_SLE:
        DUP_OP2(sle, x, y);
        break;
    case RZ_IL_OP_ULE:
        DUP_OP2(ule, x, y);
        break;
    case RZ_IL_OP_CAST:
        r->op.cast.length = op->op.cast.length;
        DUP_OP2(cast, fill, val);
        break;
    case RZ_IL_OP_APPEND:
        DUP_OP2(append, high, low);
        break;
    case RZ_IL_OP_LOAD:
        r->op.load.mem = op->op.load.mem;
        DUP_OP1(load, key);
        break;
    case RZ_IL_OP_LOADW:
        r->op.loadw.mem = op->op.loadw.mem;
        r->op.loadw.n_bits = op->op.loadw.n_bits;
        DUP_OP1(loadw, key);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
#undef DUP_OP
#undef DUP_OP2
#undef DUP_OP3
    return r;
}

References add(), append, cast, op::code, DUP_OP1, DUP_OP2, DUP_OP3, eq, key, load(), mod(), mul(), neg(), NULL, r, rz_bv_dup(), RZ_IL_OP_ADD, RZ_IL_OP_AND, RZ_IL_OP_APPEND, RZ_IL_OP_B0, RZ_IL_OP_B1, RZ_IL_OP_BITV, RZ_IL_OP_CAST, RZ_IL_OP_DIV, RZ_IL_OP_EQ, RZ_IL_OP_INV, RZ_IL_OP_IS_ZERO, RZ_IL_OP_ITE, RZ_IL_OP_LET, RZ_IL_OP_LOAD, RZ_IL_OP_LOADW, RZ_IL_OP_LOGAND, RZ_IL_OP_LOGNOT, RZ_IL_OP_LOGOR, RZ_IL_OP_LOGXOR, RZ_IL_OP_LSB, RZ_IL_OP_MOD, RZ_IL_OP_MSB, RZ_IL_OP_MUL, RZ_IL_OP_NEG, RZ_IL_OP_OR, RZ_IL_OP_SDIV, RZ_IL_OP_SHIFTL, RZ_IL_OP_SHIFTR, RZ_IL_OP_SLE, RZ_IL_OP_SMOD, RZ_IL_OP_SUB, RZ_IL_OP_ULE, RZ_IL_OP_VAR, RZ_IL_OP_XOR, RZ_NEW0, rz_return_val_if_fail, rz_warn_if_reached, sdiv(), val, and x.

Referenced by rz_il_op_new_sge(), rz_il_op_new_shiftr_arith(), rz_il_op_new_signed(), rz_il_op_new_slt(), rz_il_op_new_uge(), and rz_il_op_new_ult().

rz_il_op_pure_free()

RZ_API void rz_il_op_pure_free

(

RZ_NULLABLE RzILOpPure *

op

)

Definition at line 928 of file il_opcodes.c.

                                                           {
    if (!op) {
        return;
    }
    switch (op->code) {
    case RZ_IL_OP_VAR:
        break;
    case RZ_IL_OP_ITE:
        rz_il_op_free_3(pure, ite, condition, x, y);
        break;
    case RZ_IL_OP_LET:
        rz_il_op_free_2(pure, let, exp, body);
        break;
    case RZ_IL_OP_B0:
    case RZ_IL_OP_B1:
        break;
    case RZ_IL_OP_INV:
        rz_il_op_free_1(pure, boolinv, x);
        break;
    case RZ_IL_OP_AND:
    case RZ_IL_OP_OR:
    case RZ_IL_OP_XOR:
        // BoolXor, BoolOr and BoolAnd shares the same struct
        rz_il_op_free_2(pure, boolxor, x, y);
        break;
    case RZ_IL_OP_BITV:
        rz_bv_free(op->op.bitv.value);
        break;
    case RZ_IL_OP_MSB:
        rz_il_op_free_1(pure, msb, bv);
        break;
    case RZ_IL_OP_LSB:
        rz_il_op_free_1(pure, lsb, bv);
        break;
    case RZ_IL_OP_IS_ZERO:
        rz_il_op_free_1(pure, is_zero, bv);
        break;
    case RZ_IL_OP_NEG:
        rz_il_op_free_1(pure, neg, bv);
        break;
    case RZ_IL_OP_LOGNOT:
        rz_il_op_free_1(pure, lognot, bv);
        break;
    case RZ_IL_OP_ADD:
        rz_il_op_free_2(pure, add, x, y);
        break;
    case RZ_IL_OP_SUB:
        rz_il_op_free_2(pure, sub, x, y);
        break;
    case RZ_IL_OP_MUL:
        rz_il_op_free_2(pure, mul, x, y);
        break;
    case RZ_IL_OP_DIV:
        rz_il_op_free_2(pure, div, x, y);
        break;
    case RZ_IL_OP_SDIV:
        rz_il_op_free_2(pure, sdiv, x, y);
        break;
    case RZ_IL_OP_MOD:
        rz_il_op_free_2(pure, mod, x, y);
        break;
    case RZ_IL_OP_SMOD:
        rz_il_op_free_2(pure, smod, x, y);
        break;
    case RZ_IL_OP_LOGAND:
        rz_il_op_free_2(pure, logand, x, y);
        break;
    case RZ_IL_OP_LOGOR:
        rz_il_op_free_2(pure, logor, x, y);
        break;
    case RZ_IL_OP_LOGXOR:
        rz_il_op_free_2(pure, logxor, x, y);
        break;
    case RZ_IL_OP_SHIFTR:
        rz_il_op_free_3(pure, shiftr, fill_bit, x, y);
        break;
    case RZ_IL_OP_SHIFTL:
        rz_il_op_free_3(pure, shiftl, fill_bit, x, y);
        break;
    case RZ_IL_OP_EQ:
        rz_il_op_free_2(pure, eq, x, y);
        break;
    case RZ_IL_OP_SLE:
        rz_il_op_free_2(pure, sle, x, y);
        break;
    case RZ_IL_OP_ULE:
        rz_il_op_free_2(pure, ule, x, y);
        break;
    case RZ_IL_OP_CAST:
        rz_il_op_free_2(pure, cast, fill, val);
        break;
    case RZ_IL_OP_APPEND:
        rz_il_op_free_2(pure, append, high, low);
        break;
    case RZ_IL_OP_LOAD:
        rz_il_op_free_1(pure, load, key);
        break;
    case RZ_IL_OP_LOADW:
        rz_il_op_free_1(pure, loadw, key);
        break;
    default:
        rz_warn_if_reached();
        RZ_LOG_ERROR("RzIL: unknown opcode %u\n", op->code);
        break;
    }
    free(op);
}

References add(), append, cast, op::code, eq, free(), key, load(), mod(), mul(), neg(), rz_bv_free(), RZ_IL_OP_ADD, RZ_IL_OP_AND, RZ_IL_OP_APPEND, RZ_IL_OP_B0, RZ_IL_OP_B1, RZ_IL_OP_BITV, RZ_IL_OP_CAST, RZ_IL_OP_DIV, RZ_IL_OP_EQ, rz_il_op_free_1, rz_il_op_free_2, rz_il_op_free_3, RZ_IL_OP_INV, RZ_IL_OP_IS_ZERO, RZ_IL_OP_ITE, RZ_IL_OP_LET, RZ_IL_OP_LOAD, RZ_IL_OP_LOADW, RZ_IL_OP_LOGAND, RZ_IL_OP_LOGNOT, RZ_IL_OP_LOGOR, RZ_IL_OP_LOGXOR, RZ_IL_OP_LSB, RZ_IL_OP_MOD, RZ_IL_OP_MSB, RZ_IL_OP_MUL, RZ_IL_OP_NEG, RZ_IL_OP_OR, RZ_IL_OP_SDIV, RZ_IL_OP_SHIFTL, RZ_IL_OP_SHIFTR, RZ_IL_OP_SLE, RZ_IL_OP_SMOD, RZ_IL_OP_SUB, RZ_IL_OP_ULE, RZ_IL_OP_VAR, RZ_IL_OP_XOR, RZ_LOG_ERROR, rz_warn_if_reached, sdiv(), val, and x.

Referenced by add_sub(), bfi(), bic(), bitwise(), cbz(), cmp(), csinc(), extr(), ldm(), mla(), mov(), mul(), pkhbt(), qadd(), qadd16(), qadd8(), rfe(), rz_il_op_effect_free(), sadd16(), sadd8(), sdiv(), sel(), shift(), smaddl(), smlabb(), smlal(), smlaw(), smmla(), smmul(), smuad(), smulbb(), smulh(), smull(), ssat(), ssat16(), stm(), str(), strex(), tbz(), tst(), udiv(), umaal(), umull(), usad8(), uxt(), uxt16(), and write_reg().