avr_il.c File Reference

#include "avr_il.h"
#include <rz_il/rz_il_opbuilder_begin.h>
#include <rz_il/rz_il_opbuilder_end.h>

Go to the source code of this file.

Macros
#define	AVR_REG_SIZE   8
#define	AVR_SREG_SIZE   8
#define	AVR_MMIO_SIZE   8
#define	AVR_SP_SIZE   16
#define	AVR_IND_SIZE   16
#define	AVR_ADDR_SIZE   32
#define	AVR_SREG   "sreg"
#define	AVR_SP   "sp"
#define	AVR_SPH   "spl"
#define	AVR_SPL   "sph"
#define	AVR_RAMPX   "rampx"
#define	AVR_RAMPY   "rampy"
#define	AVR_RAMPZ   "rampz"
#define	AVR_RAMPD   "rampd"
#define	AVR_EIND   "eind"
#define	AVR_SPMCSR   "spmcsr"
#define	AVR_LET_RES   "RES"
#define	AVR_LET_IND   "IND"
#define	AVR_SREG_I_BIT   ((ut8)(1u << 7))
#define	AVR_SREG_I   "if"
#define	AVR_SREG_T_BIT   ((ut8)(1u << 6))
#define	AVR_SREG_T   "tf"
#define	AVR_SREG_H_BIT   ((ut8)(1u << 5))
#define	AVR_SREG_H   "hf"
#define	AVR_SREG_S_BIT   ((ut8)(1u << 4))
#define	AVR_SREG_S   "sf"
#define	AVR_SREG_V_BIT   ((ut8)(1u << 3))
#define	AVR_SREG_V   "vf"
#define	AVR_SREG_N_BIT   ((ut8)(1u << 2))
#define	AVR_SREG_N   "nf"
#define	AVR_SREG_Z_BIT   ((ut8)(1u << 1))
#define	AVR_SREG_Z   "zf"
#define	AVR_SREG_C_BIT   ((ut8)(1u << 0))
#define	AVR_SREG_C   "cf"
#define	AVR_ADDR(x)   UNSIGNED(AVR_ADDR_SIZE, x)
#define	AVR_PC(x)   UN(AVR_ADDR_SIZE, x)
#define	AVR_SH(sh)   U32((sh))
#define	AVR_IMM(imm)   UN(AVR_REG_SIZE, (imm))
#define	AVR_IMM16(imm)   U16((imm))
#define	AVR_REG(reg)   VARG(avr_registers[reg])
#define	AVR_REG_SET(reg, x)   SETG(avr_registers[reg], x)
#define	AVR_ONE()   UN(AVR_REG_SIZE, 1)
#define	AVR_ZERO()   UN(AVR_REG_SIZE, 0)
#define	AVR_X()   avr_il_get_indirect_address_reg(27, 26)
#define	AVR_Y()   avr_il_get_indirect_address_reg(29, 28)
#define	AVR_Z()   avr_il_get_indirect_address_reg(31, 30)
#define	AVR_SET_X(l, n, add)   avr_il_update_indirect_address_reg(l, 27, 26, n, add)
#define	AVR_SET_Y(l, n, add)   avr_il_update_indirect_address_reg(l, 29, 28, n, add)
#define	AVR_SET_Z(l, n, add)   avr_il_update_indirect_address_reg(l, 31, 30, n, add)
#define	AVR_SREG_I_SET(x)   avr_il_assign_bool(AVR_SREG_I, x)
#define	AVR_SREG_T_SET(x)   avr_il_assign_bool(AVR_SREG_T, x)
#define	AVR_SREG_H_SET(x)   avr_il_assign_bool(AVR_SREG_H, x)
#define	AVR_SREG_S_SET(x)   avr_il_assign_bool(AVR_SREG_S, x)
#define	AVR_SREG_V_SET(x)   avr_il_assign_bool(AVR_SREG_V, x)
#define	AVR_SREG_N_SET(x)   avr_il_assign_bool(AVR_SREG_N, x)
#define	AVR_SREG_Z_SET(x)   avr_il_assign_bool(AVR_SREG_Z, x)
#define	AVR_SREG_C_SET(x)   avr_il_assign_bool(AVR_SREG_C, x)
#define	avr_return_val_if_invalid_gpr(x, v)
#define	avr_return_val_if_invalid_indirect_address(x, v)

Typedefs
typedef RzILOpEffect *(*	avr_il_op) (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)

Functions
static RzILOpBitVector *	avr_il_get_indirect_address_reg (ut16 reg_high, ut16 reg_low)
static RzILOpEffect *	avr_il_update_indirect_address_reg (const char *local, ut16 reg_high, ut16 reg_low, ut64 n, bool add)
static RzILOpEffect *	avr_il_jump_relative (AVROp *aop, RzAnalysis *analysis, ut64 where)
static RzILOpEffect *	avr_il_branch_when (AVROp *aop, RzAnalysis *analysis, ut64 where, RzILOpBool *when, bool cond)
static RzILOpEffect *	avr_il_assign_imm (const char *reg, ut16 imm)
static RzILOpEffect *	avr_il_assign_bool (const char *reg, ut16 value)
static RzILOpEffect *	avr_il_assign_reg (const char *dst, const char *src)
static RzILOpEffect *	avr_il_store_pure (ut64 addr, RzILOpPure *var)
static RzILOpEffect *	avr_il_store_reg (ut64 addr, const char *reg)
static RzILOpEffect *	avr_il_load_reg (ut64 addr, const char *reg, ut16 size)
static RzILOpEffect *	avr_il_set16_from_reg (const char *dst, const char *src, ut16 mask, ut16 sh)
static RzILOpEffect *	avr_il_set_sreg_bit_from_reg (const char *src, ut8 bit_val, const char *bit_reg)
static RzILOpBitVector *	avr_il_sreg_bit_as_imm (const char *sreg_bit, ut8 bit)
static const char *	resolve_mmio (RzAnalysis *analysis, ut16 address)
static RzILOpEffect *	avr_il_check_zero_flag_local (const char *local, bool and_zero)
static RzILOpEffect *	avr_il_check_zero_flag_reg (ut16 reg)
static RzILOpEffect *	avr_il_check_half_carry_flag_addition (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_half_carry_flag_subtraction (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_two_complement_overflow_flag_addition (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_two_complement_overflow_flag_addition_wide (const char *local, ut16 reg)
static RzILOpEffect *	avr_il_check_two_complement_overflow_flag_subtraction (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_two_complement_overflow_flag_subtraction_wide (const char *local, ut16 reg)
static RzILOpEffect *	avr_il_check_negative_flag_local (const char *local)
static RzILOpEffect *	avr_il_check_negative_flag_reg (ut16 reg)
static RzILOpEffect *	avr_il_check_carry_flag_addition (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_carry_flag_addition_wide (const char *local, ut16 reg)
static RzILOpEffect *	avr_il_check_carry_flag_subtraction (const char *local, RzILOpPure *x, RzILOpPure *y)
static RzILOpEffect *	avr_il_check_carry_flag_subtraction_wide (const char *local, ut16 reg)
static RzILOpEffect *	avr_il_check_signess_flag ()
static RzILOpEffect *	avr_il_check_nc_overflow_flag ()
static RzILOpPure *	avr_subtract_if (ut32 bitsize, ut64 limit, RzILOpPure *minuend, ut64 subtrahend, bool invert)
static RzILOpEffect *	avr_il_unk (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_nop (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_adc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_add (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_adiw (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_and (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_andi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_asr (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_bld (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brcc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brcs (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_breq (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brge (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brhc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brhs (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brid (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brie (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brlt (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brmi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brne (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brpl (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brtc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brts (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brvc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_brvs (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_bst (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_call (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cbi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clh (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cli (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cln (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clr (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cls (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clt (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clv (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_clz (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_com (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cp (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cpi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cpc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_cpse (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_dec (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_eicall (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_eijmp (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_elpm (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_eor (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_fmul (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_fmuls (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_fmulsu (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_icall (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ijmp (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_in (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_inc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_jmp (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lac (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_las (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lat (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ld (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ldi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lds (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lpm (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lsl (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_lsr (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_mov (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_movw (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_mul (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_muls (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_mulsu (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_neg (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_or (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ori (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_out (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_pop (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_push (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_rcall (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ret (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_rjmp (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_rol (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ror (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbci (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbic (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbis (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbiw (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbrc (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sbrs (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sec (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_seh (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sei (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sen (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ser (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_ses (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_set (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sev (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sez (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_st (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sts (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_sub (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_subi (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_swap (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
static RzILOpEffect *	avr_il_xch (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)
RZ_IPI bool	rz_avr_il_opcode (RzAnalysis *analysis, RzAnalysisOp *op, ut64 pc, AVROp *aop, AVROp *next_op)
RZ_IPI RzAnalysisILConfig *	rz_avr_il_config (RZ_NONNULL RzAnalysis *analysis)

Variables
const char *	avr_registers [32]
static const char *	avr_global_registers []
static avr_il_op	avr_ops [AVR_OP_SIZE]

Detailed Description

Converts AVR instructions into RzIL statements references:

• https://www.da.isy.liu.se/vanheden/pdf/avr_instr_set.pdf (no errors but old and missing some instructions)
• https://ww1.microchip.com/downloads/en/devicedoc/atmel-0856-avr-instruction-set-manual.pdf (contains many errors but complete)

Definition in file avr_il.c.

Macro Definition Documentation

AVR_ADDR

#define AVR_ADDR

(

x

)

UNSIGNED(AVR_ADDR_SIZE, x)

Definition at line 55 of file avr_il.c.

AVR_ADDR_SIZE

#define AVR_ADDR_SIZE   32

Definition at line 20 of file avr_il.c.

AVR_EIND

#define AVR_EIND   "eind"

Definition at line 30 of file avr_il.c.

AVR_IMM

#define AVR_IMM

(

imm

)

UN(AVR_REG_SIZE, (imm))

Definition at line 58 of file avr_il.c.

AVR_IMM16

#define AVR_IMM16

(

imm

)

U16((imm))

Definition at line 59 of file avr_il.c.

AVR_IND_SIZE

#define AVR_IND_SIZE   16

Definition at line 19 of file avr_il.c.

AVR_LET_IND

#define AVR_LET_IND   "IND"

Definition at line 33 of file avr_il.c.

AVR_LET_RES

#define AVR_LET_RES   "RES"

Definition at line 32 of file avr_il.c.

AVR_MMIO_SIZE

#define AVR_MMIO_SIZE   8

Definition at line 17 of file avr_il.c.

AVR_ONE

#define AVR_ONE

(

)

UN(AVR_REG_SIZE, 1)

Definition at line 62 of file avr_il.c.

AVR_PC

#define AVR_PC

(

x

)

UN(AVR_ADDR_SIZE, x)

Definition at line 56 of file avr_il.c.

AVR_RAMPD

#define AVR_RAMPD   "rampd"

Definition at line 29 of file avr_il.c.

AVR_RAMPX

#define AVR_RAMPX   "rampx"

Definition at line 26 of file avr_il.c.

AVR_RAMPY

#define AVR_RAMPY   "rampy"

Definition at line 27 of file avr_il.c.

AVR_RAMPZ

#define AVR_RAMPZ   "rampz"

Definition at line 28 of file avr_il.c.

AVR_REG

#define AVR_REG

(

reg

)

VARG(avr_registers[reg])

Definition at line 60 of file avr_il.c.

AVR_REG_SET

#define AVR_REG_SET	(		reg,
			x
	)		SETG(avr_registers[reg], x)

Definition at line 61 of file avr_il.c.

AVR_REG_SIZE

#define AVR_REG_SIZE   8

Definition at line 15 of file avr_il.c.

avr_return_val_if_invalid_gpr

#define avr_return_val_if_invalid_gpr	(		x,
			v
	)

Value:

    if (x >= 32) { \
        RZ_LOG_ERROR("RzIL: AVR: invalid register R%u\n", x); \
        return v; \
    }

Definition at line 80 of file avr_il.c.

avr_return_val_if_invalid_indirect_address

#define avr_return_val_if_invalid_indirect_address	(		x,
			v
	)

Value:

    if (x != 'X' && x != 'Y' && x != 'Z') { \
        RZ_LOG_ERROR("RzIL: AVR: invalid indirect address register %c\n", x); \
        return v; \
    }

Definition at line 86 of file avr_il.c.

AVR_SET_X

#define AVR_SET_X	(		l,
			n,
			add
	)		avr_il_update_indirect_address_reg(l, 27, 26, n, add)

Definition at line 67 of file avr_il.c.

AVR_SET_Y

#define AVR_SET_Y	(		l,
			n,
			add
	)		avr_il_update_indirect_address_reg(l, 29, 28, n, add)

Definition at line 68 of file avr_il.c.

AVR_SET_Z

#define AVR_SET_Z	(		l,
			n,
			add
	)		avr_il_update_indirect_address_reg(l, 31, 30, n, add)

Definition at line 69 of file avr_il.c.

AVR_SH

#define AVR_SH

(

sh

)

U32((sh))

Definition at line 57 of file avr_il.c.

AVR_SP

#define AVR_SP   "sp"

Definition at line 23 of file avr_il.c.

AVR_SP_SIZE

#define AVR_SP_SIZE   16

Definition at line 18 of file avr_il.c.

AVR_SPH

#define AVR_SPH   "spl"

Definition at line 24 of file avr_il.c.

AVR_SPL

#define AVR_SPL   "sph"

Definition at line 25 of file avr_il.c.

AVR_SPMCSR

#define AVR_SPMCSR   "spmcsr"

Definition at line 31 of file avr_il.c.

AVR_SREG

#define AVR_SREG   "sreg"

Definition at line 22 of file avr_il.c.

AVR_SREG_C

#define AVR_SREG_C   "cf"

Definition at line 53 of file avr_il.c.

AVR_SREG_C_BIT

#define AVR_SREG_C_BIT   ((ut8)(1u << 0))

Definition at line 52 of file avr_il.c.

AVR_SREG_C_SET

#define AVR_SREG_C_SET

(

x

)

avr_il_assign_bool(AVR_SREG_C, x)

Definition at line 78 of file avr_il.c.

AVR_SREG_H

#define AVR_SREG_H   "hf"

Definition at line 43 of file avr_il.c.

AVR_SREG_H_BIT

#define AVR_SREG_H_BIT   ((ut8)(1u << 5))

Definition at line 42 of file avr_il.c.

AVR_SREG_H_SET

#define AVR_SREG_H_SET

(

x

)

avr_il_assign_bool(AVR_SREG_H, x)

Definition at line 73 of file avr_il.c.

AVR_SREG_I

#define AVR_SREG_I   "if"

Definition at line 39 of file avr_il.c.

AVR_SREG_I_BIT

#define AVR_SREG_I_BIT   ((ut8)(1u << 7))

Definition at line 38 of file avr_il.c.

AVR_SREG_I_SET

#define AVR_SREG_I_SET

(

x

)

avr_il_assign_bool(AVR_SREG_I, x)

Definition at line 71 of file avr_il.c.

AVR_SREG_N

#define AVR_SREG_N   "nf"

Definition at line 49 of file avr_il.c.

AVR_SREG_N_BIT

#define AVR_SREG_N_BIT   ((ut8)(1u << 2))

Definition at line 48 of file avr_il.c.

AVR_SREG_N_SET

#define AVR_SREG_N_SET

(

x

)

avr_il_assign_bool(AVR_SREG_N, x)

Definition at line 76 of file avr_il.c.

AVR_SREG_S

#define AVR_SREG_S   "sf"

Definition at line 45 of file avr_il.c.

AVR_SREG_S_BIT

#define AVR_SREG_S_BIT   ((ut8)(1u << 4))

Definition at line 44 of file avr_il.c.

AVR_SREG_S_SET

#define AVR_SREG_S_SET

(

x

)

avr_il_assign_bool(AVR_SREG_S, x)

Definition at line 74 of file avr_il.c.

AVR_SREG_SIZE

#define AVR_SREG_SIZE   8

Definition at line 16 of file avr_il.c.

AVR_SREG_T

#define AVR_SREG_T   "tf"

Definition at line 41 of file avr_il.c.

AVR_SREG_T_BIT

#define AVR_SREG_T_BIT   ((ut8)(1u << 6))

Definition at line 40 of file avr_il.c.

AVR_SREG_T_SET

#define AVR_SREG_T_SET

(

x

)

avr_il_assign_bool(AVR_SREG_T, x)

Definition at line 72 of file avr_il.c.

AVR_SREG_V

#define AVR_SREG_V   "vf"

Definition at line 47 of file avr_il.c.

AVR_SREG_V_BIT

#define AVR_SREG_V_BIT   ((ut8)(1u << 3))

Definition at line 46 of file avr_il.c.

AVR_SREG_V_SET

#define AVR_SREG_V_SET

(

x

)

avr_il_assign_bool(AVR_SREG_V, x)

Definition at line 75 of file avr_il.c.

AVR_SREG_Z

#define AVR_SREG_Z   "zf"

Definition at line 51 of file avr_il.c.

AVR_SREG_Z_BIT

#define AVR_SREG_Z_BIT   ((ut8)(1u << 1))

Definition at line 50 of file avr_il.c.

AVR_SREG_Z_SET

#define AVR_SREG_Z_SET

(

x

)

avr_il_assign_bool(AVR_SREG_Z, x)

Definition at line 77 of file avr_il.c.

AVR_X

#define AVR_X

(

)

avr_il_get_indirect_address_reg(27, 26)

Definition at line 64 of file avr_il.c.

AVR_Y

#define AVR_Y

(

)

avr_il_get_indirect_address_reg(29, 28)

Definition at line 65 of file avr_il.c.

AVR_Z

#define AVR_Z

(

)

avr_il_get_indirect_address_reg(31, 30)

Definition at line 66 of file avr_il.c.

AVR_ZERO

#define AVR_ZERO

(

)

UN(AVR_REG_SIZE, 0)

Definition at line 63 of file avr_il.c.

Typedef Documentation

avr_il_op

typedef RzILOpEffect*(* avr_il_op) (AVROp *aop, AVROp *next_op, ut64 pc, RzAnalysis *analysis)

Definition at line 3024 of file avr_il.c.

Function Documentation

avr_il_adc()

static RzILOpEffect* avr_il_adc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 575 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *adc, *let, *H, *S, *V, *N, *Z, *C;
    // Rd = Rd + Rr + C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // TMP = Rd + Rr + C
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = ADD(x, y);
    y = avr_il_sreg_bit_as_imm(AVR_SREG_C, 1);
    x = ADD(x, y);
    let = SETL(AVR_LET_RES, x);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    adc = AVR_REG_SET(Rd, x);
 
    // V: (Rd7 & Rr7 & !Res7) | (!Rd7 & !Rr7 & Res7)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_addition(AVR_LET_RES, x, y);
 
    // H: (Rd3 & Rr3) | (Rr3 & !R3) | (!R3 & Rd3)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_addition(AVR_LET_RES, x, y);
 
    // N: Res7
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // Z: !Res
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // C: (Rd7 & Rr7) | (Rr7 & !R7) | (!R7 & Rd7)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_addition(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, H, V, N, Z, C, S, adc);
}

References ADD, avr_il_check_carry_flag_addition(), avr_il_check_half_carry_flag_addition(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_addition(), avr_il_check_zero_flag_local(), avr_il_sreg_bit_as_imm(), AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, V, VARL, x, and Z.

avr_il_add()

static RzILOpEffect* avr_il_add ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 623 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *adc, *let, *H, *S, *V, *N, *Z, *C;
    // Rd = Rd + Rr
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // TMP = Rd + Rr
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = ADD(x, y);
    let = SETL(AVR_LET_RES, x);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    adc = AVR_REG_SET(Rd, x);
 
    // V: (Rd7 & Rr7 & !Res7) | (!Rd7 & !Rr7 & Res7)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_addition(AVR_LET_RES, x, y);
 
    // H: (Rd3 & Rr3) | (Rr3 & !R3) | (!R3 & Rd3)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_addition(AVR_LET_RES, x, y);
 
    // N: Res7
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // Z: !Res
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // C: (Rd7 & Rr7) | (Rr7 & !R7) | (!R7 & Rd7)
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_addition(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, H, V, N, Z, C, S, adc);
}

References ADD, avr_il_check_carry_flag_addition(), avr_il_check_half_carry_flag_addition(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_addition(), avr_il_check_zero_flag_local(), AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, V, VARL, x, and Z.

avr_il_adiw()

static RzILOpEffect* avr_il_adiw ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 669 of file avr_il.c.

                                                                                            {
    RzILOpPure *x, *imm;
    RzILOpEffect *let, *adiw, *Z, *S, *V, *N, *C;
    // Rd+1:Rd = Rd+1:Rd + K
    // Rd can be only 24,26,28,30
    ut16 Rdh = aop->param[0];
    ut16 Rdl = aop->param[1];
    ut16 K = aop->param[2];
    avr_return_val_if_invalid_gpr(Rdh, NULL);
    avr_return_val_if_invalid_gpr(Rdl, NULL);
 
    // IND = Rd+1:Rd + K
    imm = UN(AVR_IND_SIZE, K);
    x = avr_il_get_indirect_address_reg(Rdh, Rdl);
    x = ADD(x, imm);
    let = SETL(AVR_LET_IND, x);
 
    // Rd+1:Rd = IND
    adiw = avr_il_update_indirect_address_reg(AVR_LET_IND, Rdh, Rdl, 0, false);
 
    // set Z to 1 if !IND
    Z = avr_il_check_zero_flag_local(AVR_LET_IND, false);
 
    // Res = IND
    // V: !Rdh7 & Res15
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    V = avr_il_check_two_complement_overflow_flag_addition_wide(AVR_LET_IND, Rdh);
 
    // Res = IND
    // N: Res15
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_IND);
 
    // Res = IND
    // C: !Res15 & Rdh7
    C = avr_il_check_carry_flag_addition_wide(AVR_LET_IND, Rdh);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ7(let, adiw, Z, V, N, C, S);
}

References ADD, avr_il_check_carry_flag_addition_wide(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_addition_wide(), avr_il_check_zero_flag_local(), avr_il_get_indirect_address_reg(), avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_IND, avr_return_val_if_invalid_gpr, C, imm, N, NULL, avr_opcode_t::param, S, SEQ7, SETL, UN, V, x, and Z.

avr_il_and()

static RzILOpEffect* avr_il_and ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 712 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *and0, *S, *V, *N, *Z;
    // Rd = Rd & Rr
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // Rd = Rd & Rr
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = LOGAND(x, y);
    and0 = AVR_REG_SET(Rd, x);
 
    // V: 0 (Cleared)
    V = AVR_SREG_V_SET(false);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    Z = avr_il_check_zero_flag_reg(Rd);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ5(and0, V, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), avr_il_check_zero_flag_reg(), AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V_SET, LOGAND, N, NULL, avr_opcode_t::param, S, SEQ5, V, x, and Z.

avr_il_andi()

static RzILOpEffect* avr_il_andi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 742 of file avr_il.c.

                                                                                            {
    RzILOpPure *x, *y;
    RzILOpEffect *andi, *S, *V, *N, *Z;
    // Rd = Rd & K
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // Rd = Rd & K
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    x = LOGAND(x, y);
    andi = AVR_REG_SET(Rd, x);
 
    // V: 0 (Cleared)
    V = AVR_SREG_V_SET(false);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    Z = avr_il_check_zero_flag_reg(Rd);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ5(andi, V, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), avr_il_check_zero_flag_reg(), AVR_IMM, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V_SET, LOGAND, N, NULL, avr_opcode_t::param, S, SEQ5, V, x, and Z.

avr_il_asr()

static RzILOpEffect* avr_il_asr ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 771 of file avr_il.c.

                                                                                           {
    // Arithmetic Signed Shift Right
    RzILOpPure *x, *y, *z;
    RzILOpEffect *asr, *S, *V, *N, *Z, *C;
    // Rd >>= 1
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // simplified by adding itself
    x = AVR_REG(Rd);
    z = MSB(x);
    x = AVR_REG(Rd);
    y = AVR_SH(1);
    x = SHIFTR(z, x, y);
    asr = AVR_REG_SET(Rd, x);
 
    // C: Rd0
    x = AVR_REG(Rd);
    x = LSB(x);
    C = SETG(AVR_SREG_C, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    Z = avr_il_check_zero_flag_reg(Rd);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    // V: N ^ C, For N and C after the shift
    V = avr_il_check_nc_overflow_flag();
 
    return SEQ6(C, asr, N, Z, S, V);
}

References asr, avr_il_check_nc_overflow_flag(), avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), avr_il_check_zero_flag_reg(), AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, C, LSB, MSB, N, NULL, avr_opcode_t::param, S, SEQ6, SETG, SHIFTR, V, x, and Z.

avr_il_assign_bool()

static RzILOpEffect* avr_il_assign_bool ( const char *  reg, ut16  value  )

inlinestatic

Definition at line 173 of file avr_il.c.

                                                                            {
    return SETG(reg, value ? IL_TRUE : IL_FALSE);
}

References IL_FALSE, IL_TRUE, reg, SETG, and value.

avr_il_assign_imm()

static RzILOpEffect* avr_il_assign_imm ( const char *  reg, ut16  imm  )

inlinestatic

Definition at line 168 of file avr_il.c.

                                                                         {
    RzILOpBitVector *_bv = UN(AVR_REG_SIZE, imm);
    return SETG(reg, _bv);
}

References AVR_REG_SIZE, imm, reg, SETG, and UN.

Referenced by avr_il_clr(), avr_il_ldi(), and avr_il_ser().

avr_il_assign_reg()

static RzILOpEffect* avr_il_assign_reg ( const char *  dst, const char *  src  )

inlinestatic

Definition at line 177 of file avr_il.c.

                                                                                {
    RzILOpPure *_var = VARG(src);
    return SETG(dst, _var);
}

References dst, SETG, src, and VARG.

Referenced by avr_il_in(), avr_il_mov(), and avr_il_out().

avr_il_bld()

static RzILOpEffect* avr_il_bld ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 807 of file avr_il.c.

                                                                                           {
    // Copies the T Flag in the SREG (Status Register) to bit b in register Rd
    // all the other bits are unchanged
    ut16 Rd = aop->param[0];
    ut16 b = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpPure *reg, *add_bit, *remove_bit, *bit, *res;
 
    reg = AVR_REG(Rd);
    bit = AVR_IMM(1u << b);
    add_bit = LOGOR(reg, bit);
 
    bit = AVR_IMM(~(1u << b));
    reg = AVR_REG(Rd);
    remove_bit = LOGAND(reg, bit);
 
    res = ITE(VARG(AVR_SREG_T), add_bit, remove_bit);
    return AVR_REG_SET(Rd, res);
}

References AVR_IMM, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_T, b, bit, ITE, LOGAND, LOGOR, NULL, avr_opcode_t::param, reg, and VARG.

avr_il_branch_when()

static RzILOpEffect* avr_il_branch_when ( AVROp *  aop, RzAnalysis *  analysis, ut64  where, RzILOpBool *  when, bool  cond  )

inlinestatic

Definition at line 160 of file avr_il.c.

                                                                                                                          {
    RzILOpEffect *_jmp = avr_il_jump_relative(aop, analysis, where);
    if (cond) {
        return BRANCH(when, _jmp, NULL);
    }
    return BRANCH(when, NULL, _jmp);
}

References avr_il_jump_relative(), BRANCH, cond, and NULL.

Referenced by avr_il_brcc(), avr_il_brcs(), avr_il_breq(), avr_il_brge(), avr_il_brhc(), avr_il_brhs(), avr_il_brid(), avr_il_brie(), avr_il_brlt(), avr_il_brmi(), avr_il_brne(), avr_il_brpl(), avr_il_brtc(), avr_il_brts(), avr_il_brvc(), avr_il_brvs(), avr_il_cpse(), avr_il_sbic(), avr_il_sbis(), avr_il_sbrc(), and avr_il_sbrs().

avr_il_brcc()

static RzILOpEffect* avr_il_brcc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 828 of file avr_il.c.

                                                                                            {
    // branch if C = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_C);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_C, k, avr_opcode_t::param, and VARG.

avr_il_brcs()

static RzILOpEffect* avr_il_brcs ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 836 of file avr_il.c.

                                                                                            {
    // branch if C = 1
    ut16 k = aop->param[0];
 
    RzILOpPure *when = VARG(AVR_SREG_C);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_C, k, avr_opcode_t::param, and VARG.

avr_il_breq()

static RzILOpEffect* avr_il_breq ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 844 of file avr_il.c.

                                                                                            {
    // branch if Z = 1
    ut16 k = aop->param[0];
 
    RzILOpPure *when = VARG(AVR_SREG_Z);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_Z, k, avr_opcode_t::param, and VARG.

avr_il_brge()

static RzILOpEffect* avr_il_brge ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 852 of file avr_il.c.

                                                                                            {
    // branch if N ^ V = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *N = VARG(AVR_SREG_N);
    RzILOpBool *V = VARG(AVR_SREG_V);
    RzILOpPure *when = XOR(N, V);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_N, AVR_SREG_V, k, N, avr_opcode_t::param, V, VARG, and XOR.

avr_il_brhc()

static RzILOpEffect* avr_il_brhc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 862 of file avr_il.c.

                                                                                            {
    // branch if H = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_H);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_H, k, avr_opcode_t::param, and VARG.

avr_il_brhs()

static RzILOpEffect* avr_il_brhs ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 870 of file avr_il.c.

                                                                                            {
    // branch if H = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_H);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_H, k, avr_opcode_t::param, and VARG.

avr_il_brid()

static RzILOpEffect* avr_il_brid ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 878 of file avr_il.c.

                                                                                            {
    // branch if I = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_I);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_I, k, avr_opcode_t::param, and VARG.

avr_il_brie()

static RzILOpEffect* avr_il_brie ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 886 of file avr_il.c.

                                                                                            {
    // branch if I = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_I);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_I, k, avr_opcode_t::param, and VARG.

avr_il_brlt()

static RzILOpEffect* avr_il_brlt ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 894 of file avr_il.c.

                                                                                            {
    // branch if N ^ V = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *N = VARG(AVR_SREG_N);
    RzILOpBool *V = VARG(AVR_SREG_V);
    RzILOpPure *when = XOR(N, V);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_N, AVR_SREG_V, k, N, avr_opcode_t::param, V, VARG, and XOR.

avr_il_brmi()

static RzILOpEffect* avr_il_brmi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 904 of file avr_il.c.

                                                                                            {
    // branch if N = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_N);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_N, k, avr_opcode_t::param, and VARG.

avr_il_brne()

static RzILOpEffect* avr_il_brne ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 912 of file avr_il.c.

                                                                                            {
    // branch if Z = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_Z);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_Z, k, avr_opcode_t::param, and VARG.

avr_il_brpl()

static RzILOpEffect* avr_il_brpl ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 920 of file avr_il.c.

                                                                                            {
    // branch if N = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_N);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_N, k, avr_opcode_t::param, and VARG.

avr_il_brtc()

static RzILOpEffect* avr_il_brtc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 928 of file avr_il.c.

                                                                                            {
    // branch if T = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_T);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_T, k, avr_opcode_t::param, and VARG.

avr_il_brts()

static RzILOpEffect* avr_il_brts ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 936 of file avr_il.c.

                                                                                            {
    // branch if T = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_T);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_T, k, avr_opcode_t::param, and VARG.

avr_il_brvc()

static RzILOpEffect* avr_il_brvc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 944 of file avr_il.c.

                                                                                            {
    // branch if V = 0
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_V);
    return avr_il_branch_when(aop, analysis, k, when, false);
}

References avr_il_branch_when(), AVR_SREG_V, k, avr_opcode_t::param, and VARG.

avr_il_brvs()

static RzILOpEffect* avr_il_brvs ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 952 of file avr_il.c.

                                                                                            {
    // branch if V = 1
    ut16 k = aop->param[0];
 
    RzILOpBool *when = VARG(AVR_SREG_V);
    return avr_il_branch_when(aop, analysis, k, when, true);
}

References avr_il_branch_when(), AVR_SREG_V, k, avr_opcode_t::param, and VARG.

avr_il_bst()

static RzILOpEffect* avr_il_bst ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 960 of file avr_il.c.

                                                                                           {
    // Stores bit b from Rd to the T Flag in SREG (Status Register)
    ut16 Rd = aop->param[0];
    ut16 b = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpPure *reg, *bit;
 
    reg = AVR_REG(Rd);
    bit = AVR_IMM(1u << b);
    bit = LOGAND(reg, bit);
    bit = NON_ZERO(bit);
    return SETG(AVR_SREG_T, bit);
}

References AVR_IMM, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_T, b, bit, LOGAND, NON_ZERO, NULL, avr_opcode_t::param, reg, and SETG.

avr_il_call()

static RzILOpEffect* avr_il_call ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 975 of file avr_il.c.

                                                                                            {
    // PC = k
    ut32 k = aop->param[0];
    k <<= 16;
    k |= aop->param[1];
 
    RzILOpPure *val, *num;
    RzILOpEffect *jmp, *push, *sub;
 
    jmp = avr_il_jump_relative(aop, analysis, k);
 
    val = VARG(AVR_SP);
    val = AVR_ADDR(val);
    num = AVR_PC((AVR_ADDR_SIZE / 8) - 1);
    val = SUB(val, num);
    num = AVR_PC(pc + aop->size);
    push = STOREW(val, num);
 
    num = AVR_IMM16(AVR_ADDR_SIZE / 8);
    val = VARG(AVR_SP);
    val = SUB(val, num);
    sub = SETG(AVR_SP, val);
 
    return SEQ3(push, sub, jmp);
}

References AVR_ADDR, AVR_ADDR_SIZE, avr_il_jump_relative(), AVR_IMM16, AVR_PC, AVR_SP, jmp, k, num, avr_opcode_t::param, pc, SEQ3, SETG, avr_opcode_t::size, STOREW, SUB, val, and VARG.

avr_il_cbi()

static RzILOpEffect* avr_il_cbi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1001 of file avr_il.c.

                                                                                           {
    // Clears a specified bit in an I/O Register.
    ut16 A = aop->param[0];
    ut16 b = aop->param[1];
 
    RzILOpPure *clearb, *target, *result;
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        reg = avr_registers[A];
    }
 
    clearb = AVR_IMM(~(1u << b));
    target = VARG(reg);
    result = LOGAND(clearb, target);
    return SETG(reg, result);
}

References A, AVR_IMM, avr_registers, b, LOGAND, avr_opcode_t::param, reg, resolve_mmio(), SETG, and VARG.

avr_il_check_carry_flag_addition()

static RzILOpEffect* avr_il_check_carry_flag_addition ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 426 of file avr_il.c.

                                                                                                       {
    RzILOpBitVector *Rd, *Rr, *not0, *Res, *and0, *and1, *and2, *or0;
    // Rd = X, Rr = Y, Res = Rd + Rr or Res = Rd + Rr + C
    // H: (Rd7 & Rr7) | (Rr7 & !Res7) | (!Res7 & Rd7)
    // Set if there was a carry from bit 7; cleared otherwise
 
    // and0 = (Rd7 & Rr7)
    Rd = DUP(x);
    Rr = DUP(y);
    and0 = LOGAND(Rd, Rr);
 
    // and1 = (Rr7 & !Res7)
    Res = VARL(local);
    not0 = LOGNOT(Res);
    and1 = LOGAND(y, not0);
 
    // and2 = (!Res7 & Rd7)
    Res = VARL(local);
    not0 = LOGNOT(Res);
    and2 = LOGAND(not0, x);
 
    // or = (and0 | and1)
    or0 = LOGOR(and0, and1);
 
    // or |= and2
    or0 = LOGOR(or0, and2);
 
    return SETG(AVR_SREG_C, MSB(or0));
}

References AVR_SREG_C, DUP, local, LOGAND, LOGNOT, LOGOR, MSB, SETG, VARL, and x.

Referenced by avr_il_adc(), and avr_il_add().

avr_il_check_carry_flag_addition_wide()

static RzILOpEffect* avr_il_check_carry_flag_addition_wide ( const char *  local, ut16  reg  )

static

Definition at line 456 of file avr_il.c.

                                                                                        {
    RzILOpBitVector *carry, *Rdh, *Res;
    // Res = Rd+1:Rd
    // !Res15 & Rdh7
    // Set if the absolute value of K is larger than the absolute value of Rd; cleared otherwise
 
    // extract bit 7 from Rdh
    Rdh = AVR_REG(reg); // Rdh
    Rdh = MSB(Rdh); // Rdh7
 
    // extract bit 15 from Res
    Res = VARL(local);
    Res = MSB(Res); // Res15
    Res = INV(Res); // !Res15
 
    carry = AND(Res, Rdh); // !Res15 & Rdh7
    return SETG(AVR_SREG_C, carry);
}

References AND, AVR_REG, AVR_SREG_C, INV, local, MSB, reg, SETG, and VARL.

Referenced by avr_il_adiw().

avr_il_check_carry_flag_subtraction()

static RzILOpEffect* avr_il_check_carry_flag_subtraction ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 475 of file avr_il.c.

                                                                                                          {
    RzILOpBitVector *Rd, *Rr, *bit, *not0, *Res, *and0, *and1, *and2, *or0;
    // Rd = X, Rr = Y, Res = Rd - Rr or Res = Rd - Rr - C
    // H: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if there was a carry from bit 7; cleared otherwise
 
    Rr = DUP(y);
    // and0 = (!Rd7 & Rr7)
    Rd = DUP(x);
    not0 = LOGNOT(Rd); // !Rd
    and0 = LOGAND(not0, Rr);
 
    // and1 = (Rr7 & Res7)
    Res = VARL(local);
    and1 = LOGAND(y, Res);
 
    // and2 = (Res7 & !Rd7)
    Res = VARL(local);
    not0 = LOGNOT(x);
    and2 = LOGAND(Res, not0);
 
    // or = (and0 | and1)
    or0 = LOGOR(and0, and1);
 
    // or |= and2
    or0 = LOGOR(or0, and2);
 
    // extract bit 7 from or
    bit = AVR_IMM(1u << 7);
    and0 = LOGAND(or0, bit);
    and0 = NON_ZERO(and0); // cast to bool
    return SETG(AVR_SREG_C, and0);
}

References AVR_IMM, AVR_SREG_C, bit, DUP, local, LOGAND, LOGNOT, LOGOR, NON_ZERO, SETG, VARL, and x.

Referenced by avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_sbc(), avr_il_sbci(), avr_il_sub(), and avr_il_subi().

avr_il_check_carry_flag_subtraction_wide()

static RzILOpEffect* avr_il_check_carry_flag_subtraction_wide ( const char *  local, ut16  reg  )

static

Definition at line 509 of file avr_il.c.

                                                                                           {
    RzILOpBitVector *carry, *Rdh, *Res;
    // Res = Rd+1:Rd
    // Res15 & !Rdh7
    // Set if the absolute value of K is larger than the absolute value of Rd; cleared otherwise
 
    // extract bit 7 from Rdh
    Rdh = AVR_REG(reg); // Rdh
    Rdh = MSB(Rdh); // Rdh7
    Rdh = INV(Rdh); // !Rdh7
 
    // extract bit 15 from Res
    Res = VARL(local);
    Res = MSB(Res); // Res15
 
    carry = AND(Res, Rdh); // Res15 & !Rdh7
    return SETG(AVR_SREG_C, carry);
}

References AND, AVR_REG, AVR_SREG_C, INV, local, MSB, reg, SETG, and VARL.

Referenced by avr_il_sbiw().

avr_il_check_half_carry_flag_addition()

static RzILOpEffect* avr_il_check_half_carry_flag_addition ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 251 of file avr_il.c.

                                                                                                            {
    RzILOpBitVector *Rd, *Rr, *bit, *not0, *Res, *and0, *and1, *and2, *or0;
    // Rd = X, Rr = Y, Res = Rd + Rr or Res = Rd + Rr + C
    // H: (Rd3 & Rr3) | (Rr3 & !Res3) | (!Res3 & Rd3)
    // Set if there was a carry from bit 3; cleared otherwise
 
    // and0 = (Rd3 & Rr3)
    Rd = DUP(x);
    Rr = DUP(y);
    and0 = LOGAND(Rd, Rr);
 
    // and1 = (Rr3 & !Res3)
    Res = VARL(local);
    not0 = LOGNOT(Res);
    and1 = LOGAND(y, not0);
 
    // and2 = (!Res3 & Rd3)
    Res = VARL(local);
    not0 = LOGNOT(Res);
    and2 = LOGAND(not0, x);
 
    // or = (and0 | and1)
    or0 = LOGOR(and0, and1);
 
    // or |= and2
    or0 = LOGOR(or0, and2);
 
    // extract bit 3 from or
    bit = AVR_IMM(1u << 3);
    and0 = LOGAND(or0, bit);
    and0 = NON_ZERO(and0); // cast to bool
    return SETG(AVR_SREG_H, and0);
}

References AVR_IMM, AVR_SREG_H, bit, DUP, local, LOGAND, LOGNOT, LOGOR, NON_ZERO, SETG, VARL, and x.

Referenced by avr_il_adc(), and avr_il_add().

avr_il_check_half_carry_flag_subtraction()

static RzILOpEffect* avr_il_check_half_carry_flag_subtraction ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 285 of file avr_il.c.

                                                                                                               {
    RzILOpBitVector *Rd, *Rr, *bit, *not0, *Res, *and0, *and1, *and2, *or0;
    // Rd = X, Rr = Y, Res = Rd - Rr or Res = Rd - Rr - C
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a carry from bit 3; cleared otherwise
 
    Rr = DUP(y);
    // and0 = (!Rd3 & Rr3)
    Rd = DUP(x);
    not0 = LOGNOT(Rd); // !Rd
    and0 = LOGAND(not0, Rr);
 
    // and1 = (Rr3 & Res3)
    Res = VARL(local);
    and1 = LOGAND(y, Res);
 
    // and2 = (Res3 & !Rd3)
    Res = VARL(local);
    not0 = LOGNOT(x);
    and2 = LOGAND(Res, not0);
 
    // or = (and0 | and1)
    or0 = LOGOR(and0, and1);
 
    // or |= and2
    or0 = LOGOR(or0, and2);
 
    // extract bit 3 from or
    bit = AVR_IMM(1u << 3);
    and0 = LOGAND(or0, bit);
    and0 = NON_ZERO(and0); // cast to bool
    return SETG(AVR_SREG_H, and0);
}

References AVR_IMM, AVR_SREG_H, bit, DUP, local, LOGAND, LOGNOT, LOGOR, NON_ZERO, SETG, VARL, and x.

Referenced by avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_sbc(), avr_il_sbci(), avr_il_sub(), and avr_il_subi().

avr_il_check_nc_overflow_flag()

static RzILOpEffect* avr_il_check_nc_overflow_flag ( )

static

Definition at line 536 of file avr_il.c.

                                                     {
    // V: N ^ C, Overflow with negative xor carry
    RzILOpPure *N = VARG(AVR_SREG_N);
    RzILOpPure *C = VARG(AVR_SREG_C);
    RzILOpBool *_xor = XOR(N, C);
    return SETG(AVR_SREG_V, _xor);
}

References AVR_SREG_C, AVR_SREG_N, AVR_SREG_V, C, N, SETG, VARG, and XOR.

Referenced by avr_il_asr(), avr_il_lsl(), avr_il_lsr(), avr_il_rol(), and avr_il_ror().

avr_il_check_negative_flag_local()

static RzILOpEffect* avr_il_check_negative_flag_local ( const char *  local )

static

Definition at line 410 of file avr_il.c.

                                                                         {
    // N: Res7 is set, AKA MSB
    // extract bit 7 from Res
    RzILOpPure *x = VARL(local);
    x = MSB(x);
    return SETG(AVR_SREG_N, x);
}

References AVR_SREG_N, local, MSB, SETG, VARL, and x.

Referenced by avr_il_adc(), avr_il_add(), avr_il_adiw(), avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_sbc(), avr_il_sbci(), avr_il_sbiw(), avr_il_sub(), and avr_il_subi().

avr_il_check_negative_flag_reg()

static RzILOpEffect* avr_il_check_negative_flag_reg ( ut16  reg )

static

Definition at line 418 of file avr_il.c.

                                                              {
    // N: Res7 is set, AKA MSB
    // extract bit 7 from Res
    RzILOpPure *x = AVR_REG(reg);
    x = MSB(x);
    return SETG(AVR_SREG_N, x);
}

References AVR_REG, AVR_SREG_N, MSB, reg, SETG, and x.

Referenced by avr_il_and(), avr_il_andi(), avr_il_asr(), avr_il_dec(), avr_il_eor(), avr_il_inc(), avr_il_lsl(), avr_il_neg(), avr_il_or(), avr_il_ori(), avr_il_rol(), and avr_il_ror().

avr_il_check_signess_flag()

static RzILOpEffect* avr_il_check_signess_flag ( )

static

Definition at line 528 of file avr_il.c.

                                                 {
    // S: N ^ V, For signed tests.
    RzILOpPure *N = VARG(AVR_SREG_N);
    RzILOpPure *V = VARG(AVR_SREG_V);
    RzILOpBool *_xor = XOR(N, V);
    return SETG(AVR_SREG_S, _xor);
}

References AVR_SREG_N, AVR_SREG_S, AVR_SREG_V, N, SETG, V, VARG, and XOR.

Referenced by avr_il_adc(), avr_il_add(), avr_il_adiw(), avr_il_and(), avr_il_andi(), avr_il_asr(), avr_il_com(), avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_dec(), avr_il_eor(), avr_il_inc(), avr_il_lsl(), avr_il_lsr(), avr_il_neg(), avr_il_or(), avr_il_ori(), avr_il_rol(), avr_il_ror(), avr_il_sbc(), avr_il_sbci(), avr_il_sbiw(), avr_il_sub(), and avr_il_subi().

avr_il_check_two_complement_overflow_flag_addition()

static RzILOpEffect* avr_il_check_two_complement_overflow_flag_addition ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 319 of file avr_il.c.

                                                                                                                         {
    RzILOpBitVector *Rd, *Rr, *not0, *not1, *Res, *and0, *and1, *or0;
    // Rd = X, Rr = Y, Res = Rd - Rr or Res = Rd - Rr - C
    // V: (Rd7 & Rr7 & !Res7) | (!Rd7 & !Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
 
    // and0 = Rd7 & Rr7 & !Res7
    Res = VARL(local);
    Rd = DUP(x);
    Rr = DUP(y);
    not0 = LOGNOT(Res); // !Res
    and0 = LOGAND(Rd, Rr); // Rd & Rr
    and0 = LOGAND(and0, not0); // Rd & Rr & !Res
 
    // and1 = !Rd7 & !Rr7 & Res7
    Res = VARL(local);
    not0 = LOGNOT(x); // !Rd
    not1 = LOGNOT(y); // !Rr
    and1 = LOGAND(not0, not1); // !Rd & !Rr
    and1 = LOGAND(and1, Res); // !Rd & Rr & Res
 
    // or = and0 | and1
    or0 = LOGOR(and0, and1);
 
    // extract bit 7 from or
    return SETG(AVR_SREG_V, MSB(or0));
}

References AVR_SREG_V, DUP, local, LOGAND, LOGNOT, LOGOR, MSB, SETG, VARL, and x.

Referenced by avr_il_adc(), and avr_il_add().

avr_il_check_two_complement_overflow_flag_addition_wide()

static RzILOpEffect* avr_il_check_two_complement_overflow_flag_addition_wide ( const char *  local, ut16  reg  )

static

Definition at line 347 of file avr_il.c.

                                                                                                          {
    RzILOpPure *ovf, *Rdh, *Res;
    // Rdh = X, Res = Rd+1:Rd
    // V: !Rdh7 & Res15
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
 
    Rdh = AVR_REG(reg);
    Rdh = MSB(Rdh); // Rdh7
    Rdh = INV(Rdh); // !Rdh7
 
    Res = VARL(local);
    Res = MSB(Res); // Res15
 
    ovf = AND(Rdh, Res); // !Rdh7 & Res15
    return SETG(AVR_SREG_V, ovf);
}

References AND, AVR_REG, AVR_SREG_V, INV, local, MSB, reg, SETG, and VARL.

Referenced by avr_il_adiw().

avr_il_check_two_complement_overflow_flag_subtraction()

static RzILOpEffect* avr_il_check_two_complement_overflow_flag_subtraction ( const char *  local, RzILOpPure *  x, RzILOpPure *  y  )

static

Definition at line 364 of file avr_il.c.

                                                                                                                            {
    RzILOpBitVector *Rd, *Rr, *not0, *not1, *Res, *and0, *and1, *or0;
    // Rd = X, Rr = Y, Res = Rd - Rr or Res = Rd - Rr - C
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
 
    // and0 = Rd7 & !Rr7 & !Res7
    Res = VARL(local);
    Rr = DUP(y);
    not0 = LOGNOT(Rr); // !Rr
    not1 = LOGNOT(Res); // !Res
    Rd = DUP(x);
    and0 = LOGAND(Rd, not0); // Rd & !Rr
    and0 = LOGAND(and0, not1); // Rd & !Rr & !Res
 
    // and1 = !Rd7 & Rr7 & Res7
    Res = VARL(local);
    not0 = LOGNOT(x); // !Rd
    and1 = LOGAND(not0, y); // !Rd & Rr
    and1 = LOGAND(and1, Res); // !Rd & Rr & Res
 
    // or = and0 | and1
    or0 = LOGOR(and0, and1);
 
    return SETG(AVR_SREG_V, MSB(or0));
}

References AVR_SREG_V, DUP, local, LOGAND, LOGNOT, LOGOR, MSB, SETG, VARL, and x.

Referenced by avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_sbc(), avr_il_sbci(), avr_il_sub(), and avr_il_subi().

avr_il_check_two_complement_overflow_flag_subtraction_wide()

static RzILOpEffect* avr_il_check_two_complement_overflow_flag_subtraction_wide ( const char *  local, ut16  reg  )

static

Definition at line 391 of file avr_il.c.

                                                                                                             {
    RzILOpPure *ovf, *Rdh, *Res;
    // Rdh = X, Res = Rd+1:Rd
    // V: Rdh7 & !Res15
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
 
    // extract bit 7 from Rdh
    Rdh = AVR_REG(reg); // Rdh
    Rdh = MSB(Rdh); // Rdh7
 
    // extract bit 15 from Res
    Res = VARL(local);
    Res = MSB(Res); // Res15
    Res = INV(Res); // !Res15
 
    ovf = AND(Rdh, Res); // Rdh7 & !Res15
    return SETG(AVR_SREG_V, ovf);
}

References AND, AVR_REG, AVR_SREG_V, INV, local, MSB, reg, SETG, and VARL.

Referenced by avr_il_sbiw().

avr_il_check_zero_flag_local()

static RzILOpEffect* avr_il_check_zero_flag_local ( const char *  local, bool  and_zero  )

static

Definition at line 234 of file avr_il.c.

                                                                                    {
    // set Z to 1 if !(x - y) or !(x - y - C)
    RzILOpPure *_alu = VARL(local);
    RzILOpBool *_is_zero = IS_ZERO(_alu);
    if (and_zero) {
        RzILOpBool *Z = VARG(AVR_SREG_Z);
        _is_zero = AND(_is_zero, Z);
    }
    return SETG(AVR_SREG_Z, _is_zero);
}

References AND, AVR_SREG_Z, IS_ZERO, local, SETG, VARG, VARL, and Z.

Referenced by avr_il_adc(), avr_il_add(), avr_il_adiw(), avr_il_cp(), avr_il_cpc(), avr_il_cpi(), avr_il_sbc(), avr_il_sbci(), avr_il_sbiw(), avr_il_sub(), and avr_il_subi().

avr_il_check_zero_flag_reg()

static RzILOpEffect* avr_il_check_zero_flag_reg ( ut16  reg )

static

Definition at line 245 of file avr_il.c.

                                                          {
    RzILOpPure *x = AVR_REG(reg);
    x = IS_ZERO(x);
    return SETG(AVR_SREG_Z, x);
}

References AVR_REG, AVR_SREG_Z, IS_ZERO, reg, SETG, and x.

Referenced by avr_il_and(), avr_il_andi(), and avr_il_asr().

avr_il_clc()

static RzILOpEffect* avr_il_clc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1019 of file avr_il.c.

                                                                                           {
    // C = 0
    return AVR_SREG_C_SET(false);
}

References AVR_SREG_C_SET.

avr_il_clh()

static RzILOpEffect* avr_il_clh ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1024 of file avr_il.c.

                                                                                           {
    // H = 0
    return AVR_SREG_H_SET(false);
}

References AVR_SREG_H_SET.

avr_il_cli()

static RzILOpEffect* avr_il_cli ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1029 of file avr_il.c.

                                                                                           {
    // I = 0
    return AVR_SREG_I_SET(false);
}

References AVR_SREG_I_SET.

avr_il_cln()

static RzILOpEffect* avr_il_cln ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1034 of file avr_il.c.

                                                                                           {
    // N = 0
    return AVR_SREG_N_SET(false);
}

References AVR_SREG_N_SET.

avr_il_clr()

static RzILOpEffect* avr_il_clr ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1039 of file avr_il.c.

                                                                                           {
    // Rd = Rd ^ Rd -> S=0, V=0, N=0, Z=1
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpEffect *clr, *S, *V, *N, *Z;
    clr = avr_il_assign_imm(avr_registers[Rd], 0);
    S = AVR_SREG_S_SET(false);
    V = AVR_SREG_V_SET(false);
    N = AVR_SREG_N_SET(false);
    Z = AVR_SREG_Z_SET(true);
 
    return SEQ5(clr, S, V, N, Z);
}

References avr_il_assign_imm(), avr_registers, avr_return_val_if_invalid_gpr, AVR_SREG_N_SET, AVR_SREG_S_SET, AVR_SREG_V_SET, AVR_SREG_Z_SET, N, NULL, avr_opcode_t::param, S, SEQ5, V, and Z.

avr_il_cls()

static RzILOpEffect* avr_il_cls ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1054 of file avr_il.c.

                                                                                           {
    // S = 0
    return AVR_SREG_S_SET(false);
}

References AVR_SREG_S_SET.

avr_il_clt()

static RzILOpEffect* avr_il_clt ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1059 of file avr_il.c.

                                                                                           {
    // T = 0
    return AVR_SREG_T_SET(false);
}

References AVR_SREG_T_SET.

avr_il_clv()

static RzILOpEffect* avr_il_clv ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1064 of file avr_il.c.

                                                                                           {
    // V = 0
    return AVR_SREG_V_SET(false);
}

References AVR_SREG_V_SET.

avr_il_clz()

static RzILOpEffect* avr_il_clz ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1069 of file avr_il.c.

                                                                                           {
    // Z = 0
    return AVR_SREG_Z_SET(false);
}

References AVR_SREG_Z_SET.

avr_il_com()

static RzILOpEffect* avr_il_com ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1074 of file avr_il.c.

                                                                                           {
    // Rd = 0xFF - Rd
    // changes S|V|N|Z|C with V = 0 and C = 1
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpPure *x, *y, *sub;
    RzILOpEffect *set, *S, *V, *N, *Z, *C;
 
    x = AVR_REG(Rd);
    y = AVR_IMM(0xFF);
    sub = SUB(y, x);
    set = AVR_REG_SET(Rd, sub);
 
    // C = 1
    C = AVR_SREG_C_SET(true);
 
    // V = 0
    V = AVR_SREG_V_SET(false);
 
    // set Z to 1 if !(0xFF - Rd)
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // N = Res7
    x = AVR_REG(Rd);
    y = AVR_IMM(1u << 7);
    x = LOGAND(x, y);
    x = NON_ZERO(x); // cast to bool
    N = SETG(AVR_SREG_N, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ6(set, C, V, Z, N, S);
}

References avr_il_check_signess_flag(), AVR_IMM, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C_SET, AVR_SREG_N, AVR_SREG_V_SET, AVR_SREG_Z, C, IS_ZERO, LOGAND, N, NON_ZERO, NULL, avr_opcode_t::param, S, SEQ6, SETG, SUB, V, x, and Z.

avr_il_cp()

static RzILOpEffect* avr_il_cp ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1112 of file avr_il.c.

                                                                                          {
    // compare Rd with Rr and sets the SREG flags
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // result local variable
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // set Z to 1 if !(x - y)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // Res = Rd - Rr
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // Res = Rd - Rr
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // Res = Rd - Rr
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // Res = Rd - Rr
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ7(let, Z, H, V, N, C, S);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), AVR_LET_RES, AVR_REG, avr_return_val_if_invalid_gpr, C, H, N, NULL, avr_opcode_t::param, S, SEQ7, SETL, SUB, V, x, and Z.

avr_il_cpc()

static RzILOpEffect* avr_il_cpc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1211 of file avr_il.c.

                                                                                           {
    // compare Rd with Rr with Carry and sets the SREG flags
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
    RzILOpPure *x, *y, *carry;
    RzILOpEffect *let, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // result local variable
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    carry = VARG(AVR_SREG_C);
    carry = rz_il_op_new_ite(carry, AVR_ONE(), AVR_ZERO());
    sub = SUB(x, y);
    sub = SUB(sub, carry);
    let = SETL(AVR_LET_RES, sub);
 
    // set Z to 1 if !(x - y - C)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, true);
 
    // Res = Rd - Rr - C
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // Res = Rd - Rr - C
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // Res = Rd - Rr - C
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // Res = Rd - Rr - C
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ7(let, Z, H, V, N, C, S);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), AVR_LET_RES, AVR_ONE, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_ZERO, C, H, N, NULL, avr_opcode_t::param, rz_il_op_new_ite(), S, SEQ7, SETL, SUB, V, VARG, x, and Z.

avr_il_cpi()

static RzILOpEffect* avr_il_cpi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1164 of file avr_il.c.

                                                                                           {
    // compare Rd with Imm and sets the SREG flags
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // result local variable
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // set Z to 1 if !(x - y)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ7(let, Z, H, V, N, C, S);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), AVR_IMM, AVR_LET_RES, AVR_REG, avr_return_val_if_invalid_gpr, C, H, N, NULL, avr_opcode_t::param, S, SEQ7, SETL, SUB, V, x, and Z.

avr_il_cpse()

static RzILOpEffect* avr_il_cpse ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1266 of file avr_il.c.

                                                                                            {
    // branch if If Rd == Rr
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
 
    RzILOpBool *when = EQ(AVR_REG(Rd), AVR_REG(Rr));
    return avr_il_branch_when(aop, analysis, pc + next_op->size, when, true);
}

References avr_il_branch_when(), AVR_REG, EQ, avr_opcode_t::param, pc, and avr_opcode_t::size.

avr_il_dec()

static RzILOpEffect* avr_il_dec ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1275 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *dec, *S, *V, *N, *Z;
    // Rd -= 1
    // changes S|V|N|Z
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // V: Rd == 0x80
    x = AVR_REG(Rd);
    y = AVR_IMM(0x80);
    x = EQ(x, y);
    V = SETG(AVR_SREG_V, x);
 
    // Rd -= 1
    x = AVR_REG(Rd);
    y = AVR_ONE();
    x = SUB(x, y);
    dec = AVR_REG_SET(Rd, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ5(V, dec, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_ONE, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V, AVR_SREG_Z, EQ, IS_ZERO, N, NULL, avr_opcode_t::param, S, SEQ5, SETG, SUB, V, x, and Z.

avr_il_eicall()

static RzILOpEffect* avr_il_eicall ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1309 of file avr_il.c.

                                                                                              {
    // *(SP--) = PC
    // PC = (EIND << 16) | Z
    RzILOpPure *x, *y;
    RzILOpEffect *jmp, *push, *sub;
 
    x = VARG(AVR_EIND);
    y = AVR_Z();
    x = APPEND(x, y);
    // extend to max PC address size
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = AVR_PC(1);
    x = SHIFTL0(x, y);
    jmp = JMP(x);
 
    x = VARG(AVR_SP);
    x = AVR_ADDR(x);
    y = AVR_PC((AVR_ADDR_SIZE / 8) - 1);
    x = SUB(x, y);
    y = AVR_PC(pc + aop->size);
    push = STOREW(x, y);
 
    x = AVR_IMM16(AVR_ADDR_SIZE / 8);
    y = VARG(AVR_SP);
    y = SUB(y, x);
    sub = SETG(AVR_SP, y);
 
    return SEQ3(push, sub, jmp);
}

References APPEND, AVR_ADDR, AVR_ADDR_SIZE, AVR_EIND, AVR_IMM16, AVR_PC, AVR_SP, AVR_Z, jmp, JMP, pc, SEQ3, SETG, SHIFTL0, avr_opcode_t::size, STOREW, SUB, UNSIGNED, VARG, and x.

avr_il_eijmp()

static RzILOpEffect* avr_il_eijmp ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1339 of file avr_il.c.

                                                                                             {
    // PC = (EIND << 16) | Z
    RzILOpPure *x, *y;
 
    x = VARG(AVR_EIND);
    y = AVR_Z();
    x = APPEND(x, y);
    // extend to max PC address size
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = AVR_PC(1);
    x = SHIFTL0(x, y);
    return JMP(x);
}

References APPEND, AVR_ADDR_SIZE, AVR_EIND, AVR_PC, AVR_Z, JMP, SHIFTL0, UNSIGNED, VARG, and x.

avr_il_elpm()

static RzILOpEffect* avr_il_elpm ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1353 of file avr_il.c.

                                                                                            {
    // Rd = *(RAMPZ:Z)   # RAMPZ:Z: Unchanged
    // Rd = *(RAMPZ:Z++) # RAMPZ:Z: Post incremented
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *load, *rampz, *reg30, *reg31, *local;
 
    // RAMPZ:Z
    x = VARG(AVR_RAMPZ);
    y = AVR_Z();
    x = APPEND(x, y);
    // extend to max PC address size
    x = UNSIGNED(AVR_ADDR_SIZE, x);
 
    // Rd = *(RAMPZ:Z)
    y = LOADW(AVR_REG_SIZE, x);
    load = AVR_REG_SET(Rd, y);
 
    if (aop->param[2] != '+') {
        // do not need to post increment
        return load;
    }
 
    // RES = (RAMPZ:Z) + 1
    x = DUP(x);
    y = AVR_PC(1);
    x = ADD(x, y);
    local = SETL(AVR_LET_RES, x);
 
    // RAMPZ = (ut8)(RES >> 16)
    x = VARL(AVR_LET_RES);
    y = AVR_SH(AVR_IND_SIZE);
    x = SHIFTR0(x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    rampz = SETG(AVR_RAMPZ, x);
 
    // R31 = (ut8)(RES >> 8)
    x = VARL(AVR_LET_RES);
    y = AVR_SH(AVR_REG_SIZE);
    x = SHIFTR0(x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    reg31 = AVR_REG_SET(31, x);
 
    // R30 = (ut8)(RES)
    x = VARL(AVR_LET_RES);
    x = UNSIGNED(AVR_REG_SIZE, x);
    reg30 = AVR_REG_SET(30, x);
 
    return SEQ5(load, local, rampz, reg31, reg30);
}

References ADD, APPEND, AVR_ADDR_SIZE, AVR_IND_SIZE, AVR_LET_RES, AVR_PC, AVR_RAMPZ, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_SH, AVR_Z, DUP, load(), LOADW, local, NULL, avr_opcode_t::param, SEQ5, SETG, SETL, SHIFTR0, UNSIGNED, VARG, VARL, and x.

avr_il_eor()

static RzILOpEffect* avr_il_eor ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1405 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *eor, *S, *V, *N, *Z;
    // Rd = Rd ^ Rr
    // changes S|V|N|Z
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // Rd = Rd + Rr
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = LOGXOR(x, y);
    eor = AVR_REG_SET(Rd, x);
 
    // V: cleared (0)
    V = AVR_SREG_V_SET(false);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ5(eor, V, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V_SET, AVR_SREG_Z, IS_ZERO, LOGXOR, N, NULL, avr_opcode_t::param, S, SEQ5, SETG, V, x, and Z.

avr_il_fmul()

static RzILOpEffect* avr_il_fmul ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1438 of file avr_il.c.

                                                                                            {
    RzILOpPure *x, *y;
    RzILOpEffect *ind, *res, *mul, *Z, *C;
    // Rd and Rr are floating points that are in 1.7 format that
    // has values between [0, 2) and results in 1.15 format in R1:R0
    // bits 7      0
    // Rd = xxxxxxxx
    //      |||||||`-- 2^-7 = 0.0078125
    //      ||||||`--- 2^-6 = 0.015625
    //      |||||`---- 2^-5 = 0.03125
    //      ||||`----- 2^-4 = 0.0625
    //      |||`------ 2^-3 = 0.125
    //      ||`------- 2^-2 = 0.25
    //      |`-------- 2^-1 = 0.5
    //      `--------- 2^0  = 1
    //      01001100 = 0.5 + 0.0625 + 0.03125 = 0.59375
    // R1:R0 = ((unsigned)Rd * (unsigned)Rr)
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // IND = Rd * Rr
    x = AVR_REG(Rd);
    x = UNSIGNED(AVR_IND_SIZE, x);
    y = AVR_REG(Rr);
    y = UNSIGNED(AVR_IND_SIZE, y);
    x = MUL(x, y);
    ind = SETL(AVR_LET_IND, x);
 
    // RES = ((IND > 0x7FFF) ? (IND - 0x8000) : IND) << 1
    x = VARL(AVR_LET_IND);
    x = avr_subtract_if(16, 0x7FFF, x, 0x8000, false);
    y = AVR_ONE();
    x = SHIFTL0(x, y);
    res = SETL(AVR_LET_RES, x);
 
    // R1:R0 = RES
    mul = avr_il_update_indirect_address_reg(AVR_LET_RES, 1, 0, 0, false);
 
    // set Z to 1 if !(RES)
    x = VARL(AVR_LET_RES);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16
    x = VARL(AVR_LET_RES);
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ5(ind, res, mul, Z, C);
}

References avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_IND, AVR_LET_RES, AVR_ONE, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_Z, avr_subtract_if(), C, IS_ZERO, MSB, mul(), MUL, NULL, avr_opcode_t::param, SEQ5, SETG, SETL, SHIFTL0, UNSIGNED, VARL, x, and Z.

avr_il_fmuls()

static RzILOpEffect* avr_il_fmuls ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1492 of file avr_il.c.

                                                                                             {
    RzILOpPure *x, *y, *z;
    RzILOpEffect *ind, *res, *high, *low, *Z, *C;
    // Rd and Rr are floating points that are in 1.7 format
    // R1:R0 = ((signed)Rd * (signed)Rr)
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // IND = (Rd > 0x7F ? 0 - Rd : Rd) * (Rr > 0x7F ? 0 - Rr : Rr)
    x = AVR_REG(Rd);
    x = avr_subtract_if(AVR_REG_SIZE, 0x7F, x, 0, true);
    x = UNSIGNED(AVR_IND_SIZE, x);
 
    y = AVR_REG(Rr);
    y = avr_subtract_if(AVR_REG_SIZE, 0x7F, y, 0, true);
    y = UNSIGNED(AVR_IND_SIZE, y);
 
    x = MUL(x, y);
    ind = SETL(AVR_LET_IND, x);
 
    // checking if one of the original values are negative
    x = AVR_REG(Rd);
    x = MSB(x);
    y = AVR_REG(Rr);
    y = MSB(y);
    z = XOR(x, y);
 
    // RES = ((IND > 0x3FFF) ? (IND - 0x4000) : IND) << 1
    x = VARL(AVR_LET_IND);
    x = avr_subtract_if(16, 0x3FFF, x, 0x4000, false);
    y = AVR_ONE();
    x = SHIFTL0(x, y);
    res = SETL(AVR_LET_RES, x);
 
    // R1 = (ut8)((z ? (0 - RES) : RES) >> 8)
    x = AVR_IMM16(0);
    y = VARL(AVR_LET_RES);
    x = SUB(x, y);
    y = VARL(AVR_LET_RES);
    x = ITE(z, x, y);
    y = AVR_SH(AVR_REG_SIZE);
    x = SHIFTR0(x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    high = SETG("r1", x);
 
    // R0 = (ut8)(z ? (0 - RES) : RES)
    x = AVR_IMM16(0);
    y = VARL(AVR_LET_RES);
    x = SUB(x, y);
    y = VARL(AVR_LET_RES);
    z = DUP(z);
    x = ITE(z, x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    low = SETG("r0", x);
 
    // set Z to 1 if !(r0:r1)
    x = VARG("r0");
    x = IS_ZERO(x);
    y = VARG("r1");
    y = IS_ZERO(y);
    x = AND(x, y);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16 = r1
    x = VARG("r1");
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ6(ind, res, high, low, Z, C);
}

References AND, AVR_IMM16, AVR_IND_SIZE, AVR_LET_IND, AVR_LET_RES, AVR_ONE, AVR_REG, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, AVR_SREG_Z, avr_subtract_if(), C, DUP, IS_ZERO, ITE, MSB, MUL, NULL, avr_opcode_t::param, SEQ6, SETG, SETL, SHIFTL0, SHIFTR0, SUB, UNSIGNED, VARG, VARL, x, XOR, and Z.

avr_il_fmulsu()

static RzILOpEffect* avr_il_fmulsu ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1566 of file avr_il.c.

                                                                                              {
    RzILOpPure *x, *y, *z;
    RzILOpEffect *ind, *res, *high, *low, *Z, *C;
    // Rd and Rr are floating points that are in 1.7 format
    // R1:R0 = ((signed)Rd * (unsigned)Rr)
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // IND = (Rd > 0x7F ? Rd - 0x80 : Rd) * Rr
    x = AVR_REG(Rd);
    x = UNSIGNED(AVR_IND_SIZE, x);
    x = avr_subtract_if(AVR_IND_SIZE, 0x7F, x, 0x80, false);
    y = AVR_REG(Rr);
    y = UNSIGNED(AVR_IND_SIZE, y);
    x = MUL(x, y);
    ind = SETL(AVR_LET_IND, x);
 
    // checking if Rd is negative
    x = AVR_REG(Rd);
    z = MSB(x);
 
    // RES = ((IND > 0x3FFF) ? (IND - 0x4000) : IND) << 1
    x = VARL(AVR_LET_IND);
    x = avr_subtract_if(16, 0x3FFF, x, 0x4000, false);
    y = AVR_ONE();
    x = SHIFTL0(x, y);
    res = SETL(AVR_LET_RES, x);
 
    // R1 = (ut8)((z ? (0 - RES) : RES) >> 8)
    x = AVR_IMM16(0);
    y = VARL(AVR_LET_RES);
    x = SUB(x, y);
    y = VARL(AVR_LET_RES);
    x = ITE(z, x, y);
    y = AVR_SH(AVR_REG_SIZE);
    x = SHIFTR0(x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    high = SETG("r1", x);
 
    // R0 = (ut8)(z ? (0 - RES) : RES)
    x = AVR_IMM16(0);
    y = VARL(AVR_LET_RES);
    x = SUB(x, y);
    y = VARL(AVR_LET_RES);
    z = DUP(z);
    x = ITE(z, x, y);
    x = UNSIGNED(AVR_REG_SIZE, x);
    low = SETG("r0", x);
 
    // set Z to 1 if !(r0:r1)
    x = VARG("r0");
    x = IS_ZERO(x);
    y = VARG("r1");
    y = IS_ZERO(y);
    x = AND(x, y);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16 = r1
    x = VARG("r1");
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ6(ind, res, high, low, Z, C);
}

References AND, AVR_IMM16, AVR_IND_SIZE, AVR_LET_IND, AVR_LET_RES, AVR_ONE, AVR_REG, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, AVR_SREG_Z, avr_subtract_if(), C, DUP, IS_ZERO, ITE, MSB, MUL, NULL, avr_opcode_t::param, SEQ6, SETG, SETL, SHIFTL0, SHIFTR0, SUB, UNSIGNED, VARG, VARL, x, and Z.

avr_il_get_indirect_address_reg()

static RzILOpBitVector* avr_il_get_indirect_address_reg ( ut16  reg_high, ut16  reg_low  )

static

Definition at line 115 of file avr_il.c.

                                                                                     {
    RzILOpPure *high = AVR_REG(reg_high); // rH
    RzILOpPure *low = AVR_REG(reg_low); // rL
    return rz_il_op_new_append(high, low); // addr
}

References AVR_REG, and rz_il_op_new_append().

Referenced by avr_il_adiw(), avr_il_movw(), and avr_il_sbiw().

avr_il_icall()

static RzILOpEffect* avr_il_icall ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1634 of file avr_il.c.

                                                                                             {
    // *(SP--) = PC
    // PC = Z << 1
    RzILOpPure *x, *y;
    RzILOpEffect *jmp, *push, *sub;
 
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = AVR_SH(1);
    x = SHIFTL0(x, y);
    jmp = JMP(x);
 
    x = VARG(AVR_SP);
    x = AVR_ADDR(x);
    y = AVR_PC((AVR_ADDR_SIZE / 8) - 1);
    x = SUB(x, y);
    y = AVR_PC(pc + aop->size);
    push = STOREW(x, y);
 
    x = AVR_IMM16(AVR_ADDR_SIZE / 8);
    y = VARG(AVR_SP);
    y = SUB(y, x);
    sub = SETG(AVR_SP, y);
 
    return SEQ3(push, sub, jmp);
}

References AVR_ADDR, AVR_ADDR_SIZE, AVR_IMM16, AVR_PC, AVR_SH, AVR_SP, AVR_Z, jmp, JMP, pc, SEQ3, SETG, SHIFTL0, avr_opcode_t::size, STOREW, SUB, UNSIGNED, VARG, and x.

avr_il_ijmp()

static RzILOpEffect* avr_il_ijmp ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1661 of file avr_il.c.

                                                                                            {
    RzILOpPure *loc, *one;
    // PC = Z << 1
    loc = AVR_Z();
    loc = UNSIGNED(AVR_ADDR_SIZE, loc);
    one = AVR_SH(1);
    loc = SHIFTL0(loc, one);
    return JMP(loc);
}

References AVR_ADDR_SIZE, AVR_SH, AVR_Z, JMP, SHIFTL0, and UNSIGNED.

avr_il_in()

static RzILOpEffect* avr_il_in ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1671 of file avr_il.c.

                                                                                          {
    // Rd = I/O(A)
    ut16 Rd = aop->param[0];
    ut16 A = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        return avr_il_assign_reg(avr_registers[Rd], avr_registers[A]);
    } else if (!reg) {
        // memory read
        return avr_il_load_reg(A, avr_registers[Rd], AVR_REG_SIZE);
    } else if (!rz_str_ncasecmp(reg, AVR_SPL, strlen(AVR_SPL))) {
        // zeros low 8 bits and OR new value
        RzILOpPure *x = VARG(AVR_SP);
        x = UNSIGNED(AVR_REG_SIZE, x);
        return AVR_REG_SET(Rd, x);
    } else if (!rz_str_ncasecmp(reg, AVR_SPH, strlen(AVR_SPH))) {
        // zeros high 8 bits and OR new value
        RzILOpPure *x = VARG(AVR_SP);
        RzILOpPure *y = AVR_SH(AVR_REG_SIZE);
        x = SHIFTR0(x, y);
        x = UNSIGNED(AVR_REG_SIZE, x);
        return AVR_REG_SET(Rd, x);
    } else if (!rz_str_ncasecmp(reg, AVR_SREG, strlen(AVR_SREG))) {
        // this could be optimized to just be Rd = SREG
        RzILOpBitVector *x, *I, *T, *H, *S, *V, *N, *Z, *C;
        I = avr_il_sreg_bit_as_imm(AVR_SREG_I, AVR_SREG_I_BIT);
        T = avr_il_sreg_bit_as_imm(AVR_SREG_T, AVR_SREG_T_BIT);
        H = avr_il_sreg_bit_as_imm(AVR_SREG_H, AVR_SREG_H_BIT);
        S = avr_il_sreg_bit_as_imm(AVR_SREG_S, AVR_SREG_S_BIT);
        V = avr_il_sreg_bit_as_imm(AVR_SREG_V, AVR_SREG_V_BIT);
        N = avr_il_sreg_bit_as_imm(AVR_SREG_N, AVR_SREG_N_BIT);
        Z = avr_il_sreg_bit_as_imm(AVR_SREG_Z, AVR_SREG_Z_BIT);
        C = avr_il_sreg_bit_as_imm(AVR_SREG_C, AVR_SREG_C_BIT);
        x = LOGOR(I, T);
        x = LOGOR(x, H);
        x = LOGOR(x, S);
        x = LOGOR(x, V);
        x = LOGOR(x, N);
        x = LOGOR(x, Z);
        x = LOGOR(x, C);
        return AVR_REG_SET(Rd, x);
    }
    // assign the register value.
    return avr_il_assign_reg(avr_registers[Rd], reg);
}

References A, avr_il_assign_reg(), avr_il_load_reg(), avr_il_sreg_bit_as_imm(), AVR_REG_SET, AVR_REG_SIZE, avr_registers, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SP, AVR_SPH, AVR_SPL, AVR_SREG, AVR_SREG_C, AVR_SREG_C_BIT, AVR_SREG_H, AVR_SREG_H_BIT, AVR_SREG_I, AVR_SREG_I_BIT, AVR_SREG_N, AVR_SREG_N_BIT, AVR_SREG_S, AVR_SREG_S_BIT, AVR_SREG_T, AVR_SREG_T_BIT, AVR_SREG_V, AVR_SREG_V_BIT, AVR_SREG_Z, AVR_SREG_Z_BIT, C, H, I, LOGOR, N, NULL, avr_opcode_t::param, reg, resolve_mmio(), rz_str_ncasecmp(), S, SHIFTR0, T, UNSIGNED, V, VARG, x, and Z.

avr_il_inc()

static RzILOpEffect* avr_il_inc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1720 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *inc, *S, *V, *N, *Z;
    // Rd += 1
    // changes S|V|N|Z
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // V: Rd == 0x7F
    x = AVR_REG(Rd);
    y = AVR_IMM(0x7F);
    x = EQ(x, y);
    V = SETG(AVR_SREG_V, x);
 
    // Rd += 1
    x = AVR_REG(Rd);
    y = AVR_ONE();
    x = ADD(x, y);
    inc = AVR_REG_SET(Rd, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ5(V, inc, N, Z, S);
}

References ADD, avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_ONE, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V, AVR_SREG_Z, EQ, IS_ZERO, N, NULL, avr_opcode_t::param, S, SEQ5, SETG, V, x, and Z.

avr_il_jmp()

static RzILOpEffect* avr_il_jmp ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1754 of file avr_il.c.

                                                                                           {
    // PC = PC + k + 1
    st32 k = aop->param[0];
    k <<= 16;
    k |= aop->param[1];
 
    return avr_il_jump_relative(aop, analysis, k);
}

References avr_il_jump_relative(), k, avr_opcode_t::param, and st32.

avr_il_jump_relative()

static RzILOpEffect* avr_il_jump_relative ( AVROp *  aop, RzAnalysis *  analysis, ut64  where  )

inlinestatic

Definition at line 155 of file avr_il.c.

                                                                                               {
    RzILOpBitVector *_loc = UN(AVR_ADDR_SIZE, where);
    return JMP(_loc);
}

References AVR_ADDR_SIZE, JMP, and UN.

Referenced by avr_il_branch_when(), avr_il_call(), avr_il_jmp(), avr_il_rcall(), and avr_il_rjmp().

avr_il_lac()

static RzILOpEffect* avr_il_lac ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1763 of file avr_il.c.

                                                                                           {
    // it's swap like op but clears the bits
    // *(Z) = 0xFF – Rd and Rd = *(Z)
    st32 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *local, *load, *store;
 
    // RES = 0xFF – Rd
    x = AVR_IMM(0xFF);
    y = AVR_REG(Rd);
    x = SUB(x, y);
    local = SETL(AVR_LET_RES, x);
 
    // Rd = *(Z)
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    x = LOADW(AVR_REG_SIZE, x);
    load = AVR_REG_SET(Rd, x);
 
    // *(Z) = RES
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = VARL(AVR_LET_RES);
    store = STOREW(x, y);
 
    return SEQ3(local, load, store);
}

References AVR_ADDR_SIZE, AVR_IMM, AVR_LET_RES, AVR_REG, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_Z, load(), LOADW, local, NULL, avr_opcode_t::param, SEQ3, SETL, st32, STOREW, SUB, UNSIGNED, VARL, and x.

avr_il_las()

static RzILOpEffect* avr_il_las ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1792 of file avr_il.c.

                                                                                           {
    // it's swap like op
    // *(Z) = Rd and Rd = *(Z)
    st32 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *local, *load, *store;
 
    // RES = 0xFF – Rd
    x = AVR_REG(Rd);
    local = SETL(AVR_LET_RES, x);
 
    // Rd = *(Z)
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    x = LOADW(AVR_REG_SIZE, x);
    load = AVR_REG_SET(Rd, x);
 
    // *(Z) = RES
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = VARL(AVR_LET_RES);
    store = STOREW(x, y);
 
    return SEQ3(local, load, store);
}

References AVR_ADDR_SIZE, AVR_LET_RES, AVR_REG, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_Z, load(), LOADW, local, NULL, avr_opcode_t::param, SEQ3, SETL, st32, STOREW, UNSIGNED, VARL, and x.

avr_il_lat()

static RzILOpEffect* avr_il_lat ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1819 of file avr_il.c.

                                                                                           {
    // it's swap like op but xor the memory value
    // *(Z) ^= Rd and Rd = *(Z)
    st32 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *local, *load, *store;
 
    // RES = *(Z)
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    x = LOADW(AVR_REG_SIZE, x);
    local = SETL(AVR_LET_RES, x);
 
    // *(Z) = RES ^ Rd
    x = VARL(AVR_LET_RES);
    y = AVR_REG(Rd);
    y = LOGXOR(x, y);
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    store = STOREW(x, y);
 
    // Rd = RES
    x = VARL(AVR_LET_RES);
    load = AVR_REG_SET(Rd, x);
 
    return SEQ3(local, store, load);
}

References AVR_ADDR_SIZE, AVR_LET_RES, AVR_REG, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_Z, load(), LOADW, local, LOGXOR, NULL, avr_opcode_t::param, SEQ3, SETL, st32, STOREW, UNSIGNED, VARL, and x.

avr_il_ld()

static RzILOpEffect* avr_il_ld ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1848 of file avr_il.c.

                                                                                          {
    RzILOpPure *src;
    RzILOpEffect *ld, *post_op, *let;
    // Rd = *((ut8*)X) where X = (r27 << 8) | r26;
    // Rd = *((ut8*)Y) where Y = (r29 << 8) | r28;
    // Rd = *((ut8*)Z) where Z = (r31 << 8) | r30;
    // When Z+ , Z is incremented by 1 after the execution (applies also to X and Y).
    // When -X , X is decremented by 1 after the execution (applies also to Z and Y).
    // When Y+q, Y is incremented by q after the execution (applies also to X and Z).
 
    // undefined behaviour per ISA below
    // ld r26, X+
    // ld r27, X+
    // ld r26, -X
    // ld r27, -X
 
    ut16 Rd = aop->param[0];
    char Rr = (char)aop->param[1]; // 'X' or 'Y' or 'Z'
    char Op = (char)aop->param[2]; //  0  or '+' or '-'
    ut16 q = aop->param[3];
 
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_indirect_address(Rr, NULL);
 
    switch (Rr) {
    case 'X':
        src = AVR_X();
        break;
    case 'Y':
        src = AVR_Y();
        break;
    default: // 'Z'
        src = AVR_Z();
        break;
    }
 
    src = AVR_ADDR(src);
    src = LOADW(AVR_REG_SIZE, src);
    ld = AVR_REG_SET(Rd, src);
 
    if (Op != '+' && Op != '-') {
        return ld;
    }
 
    switch (Rr) {
    case 'X':
        src = AVR_X();
        post_op = AVR_SET_X(AVR_LET_IND, q, Op == '+');
        break;
    case 'Y':
        src = AVR_Y();
        post_op = AVR_SET_Y(AVR_LET_IND, q, Op == '+');
        break;
    default: // 'Z'
        src = AVR_Z();
        post_op = AVR_SET_Z(AVR_LET_IND, q, Op == '+');
        break;
    }
 
    let = SETL(AVR_LET_IND, src);
    return SEQ3(ld, let, post_op);
}

References AVR_ADDR, AVR_LET_IND, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, avr_return_val_if_invalid_indirect_address, AVR_SET_X, AVR_SET_Y, AVR_SET_Z, AVR_X, AVR_Y, AVR_Z, LOADW, NULL, avr_opcode_t::param, SEQ3, SETL, and src.

avr_il_ldi()

static RzILOpEffect* avr_il_ldi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1911 of file avr_il.c.

                                                                                           {
    // Rd = K
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    return avr_il_assign_imm(avr_registers[Rd], K);
}

References avr_il_assign_imm(), avr_registers, avr_return_val_if_invalid_gpr, NULL, and avr_opcode_t::param.

avr_il_lds()

static RzILOpEffect* avr_il_lds ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1920 of file avr_il.c.

                                                                                           {
    // Rd = *(k)
    ut16 Rd = aop->param[0];
    ut16 k = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    return avr_il_load_reg(k, avr_registers[Rd], AVR_REG_SIZE);
}

References avr_il_load_reg(), AVR_REG_SIZE, avr_registers, avr_return_val_if_invalid_gpr, k, NULL, and avr_opcode_t::param.

avr_il_load_reg()

static RzILOpEffect* avr_il_load_reg ( ut64  addr, const char *  reg, ut16  size  )

inlinestatic

Definition at line 192 of file avr_il.c.

                                                                                   {
    RzILOpBitVector *_loc = UN(AVR_ADDR_SIZE, addr);
    RzILOpBitVector *_val = LOADW(size, _loc);
    return SETG(reg, _val);
}

References addr, AVR_ADDR_SIZE, LOADW, reg, SETG, and UN.

Referenced by avr_il_in(), and avr_il_lds().

avr_il_lpm()

static RzILOpEffect* avr_il_lpm ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1929 of file avr_il.c.

                                                                                           {
    // R0 = *((ut8*)Z) where Z = (r31 << 8) | r30;
    // when Z+, Z is incremented after the execution.
    // LPM r30, Z+ and LPM r31, Z+ have an undefined behaviour per ISA
    // Z is always implied with lpm so we need to check only for post increment
 
    ut16 Rd = aop->param[0];
    bool post_inc = aop->param[2] == '+';
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpBitVector *z, *load;
    RzILOpEffect *lpm, *let, *zpp;
 
    z = AVR_Z();
    z = AVR_ADDR(z);
    load = rz_il_op_new_loadw(0, z, AVR_REG_SIZE);
    lpm = AVR_REG_SET(Rd, load);
 
    if (!post_inc) {
        return lpm;
    }
    z = AVR_Z();
    let = SETL(AVR_LET_IND, z);
    zpp = AVR_SET_Z(AVR_LET_IND, 1, true); // Z++
    return SEQ3(lpm, let, zpp);
}

References AVR_ADDR, AVR_LET_IND, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_SET_Z, AVR_Z, load(), NULL, avr_opcode_t::param, rz_il_op_new_loadw(), SEQ3, and SETL.

avr_il_lsl()

static RzILOpEffect* avr_il_lsl ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1956 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *lsl, *H, *S, *V, *N, *Z, *C;
    // Rd <<= 1
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // simplified by adding itself
    x = AVR_REG(Rd);
    y = AVR_REG(Rd);
    x = ADD(x, y);
    lsl = AVR_REG_SET(Rd, x);
 
    // H: Rd3
    x = AVR_REG(Rd);
    y = AVR_IMM(1u << 3);
    x = LOGAND(x, y);
    x = NON_ZERO(x); // cast to bool
    H = SETG(AVR_SREG_H, x);
 
    // C: Rd7
    x = AVR_REG(Rd);
    x = MSB(x);
    C = SETG(AVR_SREG_C, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    // V: N ^ C, For N and C after the shift
    V = avr_il_check_nc_overflow_flag();
 
    return SEQ7(H, C, lsl, N, Z, S, V);
}

References ADD, avr_il_check_nc_overflow_flag(), avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_H, AVR_SREG_Z, C, H, IS_ZERO, LOGAND, lsl, MSB, N, NON_ZERO, NULL, avr_opcode_t::param, S, SEQ7, SETG, V, x, and Z.

avr_il_lsr()

static RzILOpEffect* avr_il_lsr ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 1998 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *lsr, *S, *V, *N, *Z, *C;
    // Rd >>= 1
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    x = AVR_REG(Rd);
    y = AVR_SH(1);
    x = SHIFTR0(x, y);
    lsr = AVR_REG_SET(Rd, x);
 
    // C: Rd0
    x = AVR_REG(Rd);
    x = LSB(x);
    C = SETG(AVR_SREG_C, x);
 
    // perform shift since we need the result for the SREG flags.
    // N: 0
    N = AVR_SREG_N_SET(false);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    // V: N ^ C, For N and C after the shift
    V = avr_il_check_nc_overflow_flag();
 
    return SEQ6(C, N, lsr, Z, S, V);
}

References avr_il_check_nc_overflow_flag(), avr_il_check_signess_flag(), AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, AVR_SREG_N_SET, AVR_SREG_Z, C, IS_ZERO, LSB, lsr, N, NULL, avr_opcode_t::param, S, SEQ6, SETG, SHIFTR0, V, x, and Z.

avr_il_mov()

static RzILOpEffect* avr_il_mov ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2033 of file avr_il.c.

                                                                                           {
    // Rd = Rr
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    return avr_il_assign_reg(avr_registers[Rd], avr_registers[Rr]);
}

References avr_il_assign_reg(), avr_registers, avr_return_val_if_invalid_gpr, NULL, and avr_opcode_t::param.

avr_il_movw()

static RzILOpEffect* avr_il_movw ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2043 of file avr_il.c.

                                                                                            {
    RzILOpPure *x;
 
    RzILOpEffect *let, *movw;
    // Rd+1:Rd = Rr+1:Rr
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    x = avr_il_get_indirect_address_reg(Rr + 1, Rr);
    let = SETL(AVR_LET_IND, x);
 
    movw = avr_il_update_indirect_address_reg(AVR_LET_IND, Rd + 1, Rd, 0, false);
    return SEQ2(let, movw);
}

References avr_il_get_indirect_address_reg(), avr_il_update_indirect_address_reg(), AVR_LET_IND, avr_return_val_if_invalid_gpr, NULL, avr_opcode_t::param, SEQ2, SETL, and x.

avr_il_mul()

static RzILOpEffect* avr_il_mul ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2060 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect *let, *mul, *Z, *C;
    // R1:R0 = (signed)Rd * (signed)Rr
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // RES = (signed)Rd * (signed)Rr
    x = AVR_REG(Rd);
    x = UNSIGNED(AVR_IND_SIZE, x); // (unsigned)Rd
    y = AVR_REG(Rr);
    y = UNSIGNED(AVR_IND_SIZE, y); // (unsigned)Rr
    x = MUL(x, y);
    let = SETL(AVR_LET_RES, x);
 
    // R1:R0 = RES
    mul = avr_il_update_indirect_address_reg(AVR_LET_RES, 1, 0, 0, false);
 
    // set Z to 1 if !(RES)
    x = VARL(AVR_LET_RES);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16
    x = VARL(AVR_LET_RES);
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ4(let, mul, Z, C);
}

References avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_RES, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_Z, C, IS_ZERO, MSB, mul(), MUL, NULL, avr_opcode_t::param, SEQ4, SETG, SETL, UNSIGNED, VARL, x, and Z.

avr_il_muls()

static RzILOpEffect* avr_il_muls ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2094 of file avr_il.c.

                                                                                            {
    RzILOpPure *x, *y;
    RzILOpEffect *let, *mul, *Z, *C;
    // R1:R0 = (signed)Rd * (signed)Rr
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // RES = (signed)Rd * (signed)Rr
    x = AVR_REG(Rd);
    x = SIGNED(AVR_IND_SIZE, x); // (signed)Rd
    y = AVR_REG(Rr);
    y = SIGNED(AVR_IND_SIZE, y); // (signed)Rr
    x = MUL(x, y);
    let = SETL(AVR_LET_RES, x);
 
    // R1:R0 = RES
    mul = avr_il_update_indirect_address_reg(AVR_LET_RES, 1, 0, 0, false);
 
    // set Z to 1 if !(RES)
    x = VARL(AVR_LET_RES);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16
    x = VARL(AVR_LET_RES);
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ4(let, mul, Z, C);
}

References avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_RES, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_Z, C, IS_ZERO, MSB, mul(), MUL, NULL, avr_opcode_t::param, SEQ4, SETG, SETL, SIGNED, VARL, x, and Z.

avr_il_mulsu()

static RzILOpEffect* avr_il_mulsu ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2128 of file avr_il.c.

                                                                                             {
    RzILOpPure *x, *y;
    RzILOpEffect *let, *mul, *Z, *C;
    // R1:R0 = (signed)Rd * (unsigned)Rr
    // changes Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // RES = (signed)Rd * (unsigned)Rr
    x = AVR_REG(Rd);
    x = SIGNED(AVR_IND_SIZE, x); // (signed)Rd
    y = AVR_REG(Rr);
    y = UNSIGNED(AVR_IND_SIZE, y); // (unsigned)Rr
    x = MUL(x, y);
    let = SETL(AVR_LET_RES, x);
 
    // R1:R0 = RES
    mul = avr_il_update_indirect_address_reg(AVR_LET_RES, 1, 0, 0, false);
 
    // set Z to 1 if !(RES)
    x = VARL(AVR_LET_RES);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // C = Res16
    x = VARL(AVR_LET_RES);
    x = MSB(x); // most significant bit
    C = SETG(AVR_SREG_C, x);
 
    return SEQ4(let, mul, Z, C);
}

References avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_RES, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_Z, C, IS_ZERO, MSB, mul(), MUL, NULL, avr_opcode_t::param, SEQ4, SETG, SETL, SIGNED, UNSIGNED, VARL, x, and Z.

avr_il_neg()

static RzILOpEffect* avr_il_neg ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2162 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y, *cmp;
    RzILOpEffect *let, *neg, *H, *S, *V, *N, *Z, *C;
    // Rd = 0x00 - Rd (when Rd == 0x80 it stays 0x80)
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // IND = Rd
    let = SETL(AVR_LET_IND, AVR_REG(Rd));
 
    // Rd = (Rd == 0x80) ? Rd : (0x00 - Rd)
    x = AVR_REG(Rd);
    y = AVR_IMM(0x80);
    cmp = EQ(x, y); // Rd == 0x80
 
    x = AVR_ZERO();
    y = AVR_REG(Rd);
    x = SUB(x, y); // 0x00 - Rd
 
    y = AVR_REG(Rd); // Rd
    x = ITE(cmp, y, x); // (Rd == 0x80) ? Rd : (0x00 - Rd)
    neg = AVR_REG_SET(Rd, x); // Rd = (Rd == 0x80) ? Rd : (0x00 - Rd)
 
    // H: Res3 | Rd3
    x = AVR_REG(Rd); // Rd is now Res
    y = VARL(AVR_LET_IND); // IND is the old Rd
    x = LOGOR(x, y); // Rd | IND
    y = AVR_IMM(1u << 3);
    x = LOGAND(x, y); // extract bit 3
    x = NON_ZERO(x); // cast to bool
    H = SETG(AVR_SREG_H, x);
 
    // V: Res == 0x80 (after operation)
    x = AVR_REG(Rd); // Rd is now Res
    y = AVR_IMM(0x80);
    x = EQ(x, y); // Rd == 0x80
    V = SETG(AVR_SREG_V, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // C: Res != 0x00
    x = AVR_REG(Rd); // Rd is now Res
    x = NON_ZERO(x); // Rd != 0x00
    C = SETG(AVR_SREG_C, x);
 
    // Z: Res == 0x00
    x = AVR_REG(Rd); // Rd is now Res
    x = IS_ZERO(x); // Rd == 0x00
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, neg, H, V, N, C, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_LET_IND, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C, AVR_SREG_H, AVR_SREG_V, AVR_SREG_Z, AVR_ZERO, C, cmp(), EQ, H, IS_ZERO, ITE, LOGAND, LOGOR, N, neg(), NON_ZERO, NULL, avr_opcode_t::param, S, SEQ8, SETG, SETL, SUB, V, VARL, x, and Z.

avr_il_nop()

static RzILOpEffect* avr_il_nop ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 571 of file avr_il.c.

                                                                                           {
    return NOP();
}

References NOP.

avr_il_or()

static RzILOpEffect* avr_il_or ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2220 of file avr_il.c.

                                                                                          {
    RzILOpPure *x, *y;
    RzILOpEffect * or, *S, *V, *N, *Z;
    // Rd = Rd | Rr
    // changes S|V|N|Z
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    // Rd |= Rr
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = LOGOR(x, y);
    or = AVR_REG_SET(Rd, x);
 
    // V: 0
    V = AVR_SREG_V_SET(false);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: Res == 0x00
    x = AVR_REG(Rd); // Rd is now Res
    x = IS_ZERO(x); // Rd == 0x00
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V
    S = avr_il_check_signess_flag();
 
    return SEQ5(or, V, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V_SET, AVR_SREG_Z, IS_ZERO, LOGOR, N, NULL, avr_opcode_t::param, S, SEQ5, SETG, V, x, and Z.

avr_il_ori()

static RzILOpEffect* avr_il_ori ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2253 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y;
    RzILOpEffect * or, *S, *V, *N, *Z;
    // Rd = Rd | K
    // changes S|V|N|Z
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // Rd |= K
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    x = LOGOR(x, y);
    or = AVR_REG_SET(Rd, x);
 
    // V: 0
    V = AVR_SREG_V_SET(false);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: Res == 0x00
    x = AVR_REG(Rd); // Rd is now Res
    x = IS_ZERO(x); // Rd == 0x00
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V
    S = avr_il_check_signess_flag();
 
    return SEQ5(or, V, N, Z, S);
}

References avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_V_SET, AVR_SREG_Z, IS_ZERO, LOGOR, N, NULL, avr_opcode_t::param, S, SEQ5, SETG, V, x, and Z.

avr_il_out()

static RzILOpEffect* avr_il_out ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2285 of file avr_il.c.

                                                                                           {
    // I/O(A) = Rr -> None
    ut16 A = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rr, NULL);
 
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        return avr_il_assign_reg(avr_registers[A], avr_registers[Rr]);
    } else if (!reg) {
        // memory write
        return avr_il_store_reg(A, avr_registers[Rr]);
    } else if (!rz_str_ncasecmp(reg, AVR_SPL, strlen(AVR_SPL))) {
        // zeros low 8 bits and OR new value
        return avr_il_set16_from_reg(AVR_SP, avr_registers[Rr], 0xFF00, 0);
    } else if (!rz_str_ncasecmp(reg, AVR_SPH, strlen(AVR_SPH))) {
        // zeros high 8 bits and OR new value
        return avr_il_set16_from_reg(AVR_SP, avr_registers[Rr], 0x00FF, 8);
    } else if (!rz_str_ncasecmp(reg, AVR_SREG, strlen(AVR_SREG))) {
        RzILOpEffect *I = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_I_BIT, AVR_SREG_I);
        RzILOpEffect *T = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_T_BIT, AVR_SREG_T);
        RzILOpEffect *H = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_H_BIT, AVR_SREG_H);
        RzILOpEffect *S = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_S_BIT, AVR_SREG_S);
        RzILOpEffect *V = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_V_BIT, AVR_SREG_V);
        RzILOpEffect *N = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_N_BIT, AVR_SREG_N);
        RzILOpEffect *Z = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_Z_BIT, AVR_SREG_Z);
        RzILOpEffect *C = avr_il_set_sreg_bit_from_reg(avr_registers[Rr], AVR_SREG_C_BIT, AVR_SREG_C);
        RzILOpEffect *SREG = avr_il_assign_reg(reg, avr_registers[Rr]);
        return SEQ9(I, T, H, S, V, N, Z, C, SREG);
    }
    // assign the register value.
    return avr_il_assign_reg(reg, avr_registers[Rr]);
}

References A, avr_il_assign_reg(), avr_il_set16_from_reg(), avr_il_set_sreg_bit_from_reg(), avr_il_store_reg(), avr_registers, avr_return_val_if_invalid_gpr, AVR_SP, AVR_SPH, AVR_SPL, AVR_SREG, AVR_SREG_C, AVR_SREG_C_BIT, AVR_SREG_H, AVR_SREG_H_BIT, AVR_SREG_I, AVR_SREG_I_BIT, AVR_SREG_N, AVR_SREG_N_BIT, AVR_SREG_S, AVR_SREG_S_BIT, AVR_SREG_T, AVR_SREG_T_BIT, AVR_SREG_V, AVR_SREG_V_BIT, AVR_SREG_Z, AVR_SREG_Z_BIT, C, H, I, N, NULL, avr_opcode_t::param, reg, resolve_mmio(), rz_str_ncasecmp(), S, SEQ9, T, V, and Z.

avr_il_pop()

static RzILOpEffect* avr_il_pop ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2320 of file avr_il.c.

                                                                                           {
    // SP++
    // Rd = *(SP)
    st32 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *pop, *inc;
 
    // SP++
    x = VARG(AVR_SP);
    y = AVR_IMM16(1);
    x = ADD(x, y);
    inc = SETG(AVR_SP, x);
 
    // Rd = *(SP)
    y = VARG(AVR_SP);
    y = UNSIGNED(AVR_ADDR_SIZE, y);
    x = LOADW(AVR_REG_SIZE, y);
    pop = AVR_REG_SET(Rd, x);
 
    return SEQ2(inc, pop);
}

References ADD, AVR_ADDR_SIZE, AVR_IMM16, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_SP, LOADW, NULL, avr_opcode_t::param, SEQ2, SETG, st32, UNSIGNED, VARG, and x.

avr_il_push()

static RzILOpEffect* avr_il_push ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2343 of file avr_il.c.

                                                                                            {
    // *(SP) = Rd
    // SP--
    st32 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *push, *dec;
 
    // *(SP) = Rd
    y = VARG(AVR_SP);
    y = UNSIGNED(AVR_ADDR_SIZE, y);
    x = AVR_REG(Rd);
    push = STOREW(y, x);
 
    // SP--
    x = VARG(AVR_SP);
    y = AVR_IMM16(1);
    x = SUB(x, y);
    dec = SETG(AVR_SP, x);
 
    return SEQ2(push, dec);
}

References AVR_ADDR_SIZE, AVR_IMM16, AVR_REG, avr_return_val_if_invalid_gpr, AVR_SP, NULL, avr_opcode_t::param, SEQ2, SETG, st32, STOREW, SUB, UNSIGNED, VARG, and x.

avr_il_rcall()

static RzILOpEffect* avr_il_rcall ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2366 of file avr_il.c.

                                                                                             {
    // PC = PC + k + 1
    st32 k = (st16)aop->param[0];
 
    RzILOpPure *val, *num;
    RzILOpEffect *jmp, *push, *sub;
 
    jmp = avr_il_jump_relative(aop, analysis, k);
 
    val = VARG(AVR_SP);
    val = AVR_ADDR(val);
    num = AVR_PC((AVR_ADDR_SIZE / 8) - 1);
    val = SUB(val, num);
    num = AVR_PC(pc + aop->size);
    push = STOREW(val, num);
 
    num = AVR_IMM16(AVR_ADDR_SIZE / 8);
    val = VARG(AVR_SP);
    val = SUB(val, num);
    sub = SETG(AVR_SP, val);
 
    return SEQ3(push, sub, jmp);
}

References AVR_ADDR, AVR_ADDR_SIZE, avr_il_jump_relative(), AVR_IMM16, AVR_PC, AVR_SP, jmp, k, num, avr_opcode_t::param, pc, SEQ3, SETG, avr_opcode_t::size, st16, st32, STOREW, SUB, val, and VARG.

avr_il_ret()

static RzILOpEffect* avr_il_ret ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2390 of file avr_il.c.

                                                                                           {
    // SP += PC_SIZE
    // PC = *(SP - PC_SIZE + 1)
    RzILOpPure *x, *y;
    RzILOpEffect *jmp, *inc;
 
    // PC = *(SP - PC_SIZE + 1)
    y = VARG(AVR_SP);
    y = UNSIGNED(AVR_ADDR_SIZE, y);
    x = AVR_PC((AVR_ADDR_SIZE / 8) - 1);
    y = SUB(y, x);
    x = LOADW(AVR_ADDR_SIZE, y);
    jmp = JMP(x);
 
    // SP += PC_SIZE
    x = VARG(AVR_SP);
    y = AVR_IMM16(AVR_ADDR_SIZE / 8);
    x = ADD(x, y);
    inc = SETG(AVR_SP, x);
 
    return SEQ2(inc, jmp);
}

References ADD, AVR_ADDR_SIZE, AVR_IMM16, AVR_PC, AVR_SP, jmp, JMP, LOADW, SEQ2, SETG, SUB, UNSIGNED, VARG, and x.

avr_il_rjmp()

static RzILOpEffect* avr_il_rjmp ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2413 of file avr_il.c.

                                                                                            {
    // PC = PC + k + 1
    st32 k = (st16)aop->param[0];
 
    return avr_il_jump_relative(aop, analysis, k);
}

References avr_il_jump_relative(), k, avr_opcode_t::param, st16, and st32.

avr_il_rol()

static RzILOpEffect* avr_il_rol ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2420 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y, *carry;
    RzILOpEffect *let, *rol, *H, *S, *V, *N, *Z, *C;
    // Rd = rot_left(Rd, 1)
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // copy C into RES
    carry = VARG(AVR_SREG_C);
    let = SETL(AVR_LET_RES, carry);
 
    x = AVR_REG(Rd);
    y = AVR_SH(1);
    // Use carry as bit filler
    carry = VARL(AVR_LET_RES);
    x = SHIFTL(carry, x, y);
    rol = AVR_REG_SET(Rd, x);
 
    // H: Rd3
    x = AVR_REG(Rd);
    y = AVR_IMM(1u << 3);
    x = LOGAND(x, y);
    x = NON_ZERO(x); // cast to bool
    H = SETG(AVR_SREG_H, x);
 
    // C: Rd7
    x = AVR_REG(Rd);
    x = MSB(x);
    C = SETG(AVR_SREG_C, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    // V: N ^ C, For N and C after the shift
    V = avr_il_check_nc_overflow_flag();
 
    return SEQ8(let, H, C, rol, N, Z, S, V);
}

References avr_il_check_nc_overflow_flag(), avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_IMM, AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, AVR_SREG_H, AVR_SREG_Z, C, H, IS_ZERO, LOGAND, MSB, N, NON_ZERO, NULL, avr_opcode_t::param, rol, S, SEQ8, SETG, SETL, SHIFTL, V, VARG, VARL, x, and Z.

avr_il_ror()

static RzILOpEffect* avr_il_ror ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2467 of file avr_il.c.

                                                                                           {
    RzILOpPure *x, *y, *carry;
    RzILOpEffect *let, *ror, *S, *V, *N, *Z, *C;
    // Rd = rot_right(Rd, 1)
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    // copy C into RES
    carry = VARG(AVR_SREG_C);
    let = SETL(AVR_LET_RES, carry);
 
    x = AVR_REG(Rd);
    y = AVR_SH(1);
    // Use carry as bit filler
    carry = VARL(AVR_LET_RES);
    x = SHIFTR(carry, x, y);
    ror = AVR_REG_SET(Rd, x);
 
    // C: Rd0
    x = AVR_REG(Rd);
    x = LSB(x);
    C = SETG(AVR_SREG_C, x);
 
    // N: Res7
    N = avr_il_check_negative_flag_reg(Rd);
 
    // Z: !Res
    x = AVR_REG(Rd);
    x = IS_ZERO(x);
    Z = SETG(AVR_SREG_Z, x);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    // V: N ^ C, For N and C after the shift
    V = avr_il_check_nc_overflow_flag();
 
    return SEQ7(let, C, ror, N, Z, S, V);
}

References avr_il_check_nc_overflow_flag(), avr_il_check_negative_flag_reg(), avr_il_check_signess_flag(), AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SH, AVR_SREG_C, AVR_SREG_Z, C, IS_ZERO, LSB, N, NULL, avr_opcode_t::param, ror, S, SEQ7, SETG, SETL, SHIFTR, V, VARG, VARL, x, and Z.

avr_il_sbc()

static RzILOpEffect* avr_il_sbc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2507 of file avr_il.c.

                                                                                           {
    // Rd = Rd - Rr - C
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *subt, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // TMP = Rd - Rr - C
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    x = SUB(x, y);
    y = avr_il_sreg_bit_as_imm(AVR_SREG_C, 1);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    subt = AVR_REG_SET(Rd, x);
 
    // set Z to 1 if !(x - y - C)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, true);
 
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, Z, H, V, N, C, S, subt);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), avr_il_sreg_bit_as_imm(), AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, SUB, V, VARL, x, and Z.

avr_il_sbci()

static RzILOpEffect* avr_il_sbci ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2561 of file avr_il.c.

                                                                                            {
    // Rd = Rd - K - C
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *subt, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // TMP = Rd - K - C
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    x = SUB(x, y);
    y = avr_il_sreg_bit_as_imm(AVR_SREG_C, 1);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    subt = AVR_REG_SET(Rd, x);
 
    // set Z to 1 if !(x - y - C)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, true);
 
    // H: (!Rd3 & K3) | (K3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // V: (Rd7 & !K7 & !Res7) | (!Rd7 & K7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // C: (!Rd7 & K7) | (K7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of K is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, Z, H, V, N, C, S, subt);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), avr_il_sreg_bit_as_imm(), AVR_IMM, AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SREG_C, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, SUB, V, VARL, x, and Z.

avr_il_sbi()

static RzILOpEffect* avr_il_sbi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2614 of file avr_il.c.

                                                                                           {
    // Sets a specified bit in an I/O Register.
    ut16 A = aop->param[0];
    ut16 b = aop->param[1];
 
    RzILOpPure *setb, *target, *result;
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        reg = avr_registers[A];
    }
 
    setb = AVR_IMM(1u << b);
    target = VARG(reg);
    result = LOGOR(setb, target);
    return SETG(reg, result);
}

References A, AVR_IMM, avr_registers, b, LOGOR, avr_opcode_t::param, reg, resolve_mmio(), SETG, and VARG.

avr_il_sbic()

static RzILOpEffect* avr_il_sbic ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2632 of file avr_il.c.

                                                                                            {
    // Skip if Bit in I/O Register is Cleared.
    ut16 A = aop->param[0];
    ut16 b = aop->param[1];
 
    RzILOpPure *clearb, *target, *result;
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        reg = avr_registers[A];
    }
 
    clearb = AVR_IMM(~(1u << b));
    target = VARG(reg);
    result = LOGAND(clearb, target);
    result = IS_ZERO(result);
    return avr_il_branch_when(aop, analysis, pc + next_op->size, result, true);
}

References A, avr_il_branch_when(), AVR_IMM, avr_registers, b, IS_ZERO, LOGAND, avr_opcode_t::param, pc, reg, resolve_mmio(), avr_opcode_t::size, and VARG.

avr_il_sbis()

static RzILOpEffect* avr_il_sbis ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2651 of file avr_il.c.

                                                                                            {
    // Skip if Bit in I/O Register is Set.
    ut16 A = aop->param[0];
    ut16 b = aop->param[1];
 
    RzILOpPure *clearb, *target, *result;
    const char *reg = resolve_mmio(analysis, A);
    if (!reg && A < 32) {
        // profiles that does not map registers between 0 and 31 have MMIO regs at this range
        reg = avr_registers[A];
    }
 
    clearb = AVR_IMM(~(1u << b));
    target = VARG(reg);
    result = LOGAND(clearb, target);
    result = IS_ZERO(result);
    return avr_il_branch_when(aop, analysis, pc + next_op->size, result, false);
}

References A, avr_il_branch_when(), AVR_IMM, avr_registers, b, IS_ZERO, LOGAND, avr_opcode_t::param, pc, reg, resolve_mmio(), avr_opcode_t::size, and VARG.

avr_il_sbiw()

static RzILOpEffect* avr_il_sbiw ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2670 of file avr_il.c.

                                                                                            {
    RzILOpPure *x, *imm;
    RzILOpEffect *let, *sbiw, *Z, *S, *V, *N, *C;
    // Rd+1:Rd = Rd+1:Rd - K
    // Rd can be only 24,26,28,30
    ut16 Rdh = aop->param[0];
    ut16 Rdl = aop->param[1];
    ut16 K = aop->param[2];
    avr_return_val_if_invalid_gpr(Rdh, NULL);
    avr_return_val_if_invalid_gpr(Rdl, NULL);
 
    // IND = Rd+1:Rd - K
    imm = UN(AVR_IND_SIZE, K);
    x = avr_il_get_indirect_address_reg(Rdh, Rdl);
    x = SUB(x, imm);
    let = SETL(AVR_LET_IND, x);
 
    // Rd+1:Rd = IND
    sbiw = avr_il_update_indirect_address_reg(AVR_LET_IND, Rdh, Rdl, 0, false);
 
    // set Z to 1 if !IND
    Z = avr_il_check_zero_flag_local(AVR_LET_IND, false);
 
    // Res = IND
    // V: Rdh7 & !Res15
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    V = avr_il_check_two_complement_overflow_flag_subtraction_wide(AVR_LET_IND, Rdh);
 
    // Res = IND
    // N: Res15
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_IND);
 
    // Res = IND
    // C: !Rdh7 & Res15
    C = avr_il_check_carry_flag_subtraction_wide(AVR_LET_IND, Rdh);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ7(let, sbiw, Z, V, N, C, S);
}

References avr_il_check_carry_flag_subtraction_wide(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction_wide(), avr_il_check_zero_flag_local(), avr_il_get_indirect_address_reg(), avr_il_update_indirect_address_reg(), AVR_IND_SIZE, AVR_LET_IND, avr_return_val_if_invalid_gpr, C, imm, N, NULL, avr_opcode_t::param, S, SEQ7, SETL, SUB, UN, V, x, and Z.

avr_il_sbrc()

static RzILOpEffect* avr_il_sbrc ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2713 of file avr_il.c.

                                                                                            {
    // Skip if Bit in Register is Cleared.
    ut16 Rd = aop->param[0];
    ut16 b = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpPure *clearb, *target, *result;
 
    clearb = AVR_IMM(~(1u << b));
    target = AVR_REG(Rd);
    result = LOGAND(clearb, target);
    result = IS_ZERO(result);
    return avr_il_branch_when(aop, analysis, pc + next_op->size, result, true);
}

References avr_il_branch_when(), AVR_IMM, AVR_REG, avr_return_val_if_invalid_gpr, b, IS_ZERO, LOGAND, NULL, avr_opcode_t::param, pc, and avr_opcode_t::size.

avr_il_sbrs()

static RzILOpEffect* avr_il_sbrs ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2728 of file avr_il.c.

                                                                                            {
    // Skip if Bit in Register is Set.
    ut16 Rd = aop->param[0];
    ut16 b = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    RzILOpPure *clearb, *target, *result;
 
    clearb = AVR_IMM(~(1u << b));
    target = AVR_REG(Rd);
    result = LOGAND(clearb, target);
    result = IS_ZERO(result);
    return avr_il_branch_when(aop, analysis, pc + next_op->size, result, false);
}

References avr_il_branch_when(), AVR_IMM, AVR_REG, avr_return_val_if_invalid_gpr, b, IS_ZERO, LOGAND, NULL, avr_opcode_t::param, pc, and avr_opcode_t::size.

avr_il_sec()

static RzILOpEffect* avr_il_sec ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2743 of file avr_il.c.

                                                                                           {
    // C = 1
    return AVR_SREG_C_SET(true);
}

References AVR_SREG_C_SET.

avr_il_seh()

static RzILOpEffect* avr_il_seh ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2748 of file avr_il.c.

                                                                                           {
    // H = 1
    return AVR_SREG_H_SET(true);
}

References AVR_SREG_H_SET.

avr_il_sei()

static RzILOpEffect* avr_il_sei ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2753 of file avr_il.c.

                                                                                           {
    // I = 1
    return AVR_SREG_I_SET(true);
}

References AVR_SREG_I_SET.

avr_il_sen()

static RzILOpEffect* avr_il_sen ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2758 of file avr_il.c.

                                                                                           {
    // N = 1
    return AVR_SREG_N_SET(true);
}

References AVR_SREG_N_SET.

avr_il_ser()

static RzILOpEffect* avr_il_ser ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2763 of file avr_il.c.

                                                                                           {
    // Rd = $FF
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    return avr_il_assign_imm(avr_registers[Rd], 0xFF);
}

References avr_il_assign_imm(), avr_registers, avr_return_val_if_invalid_gpr, NULL, and avr_opcode_t::param.

avr_il_ses()

static RzILOpEffect* avr_il_ses ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2771 of file avr_il.c.

                                                                                           {
    // S = 1
    return AVR_SREG_S_SET(true);
}

References AVR_SREG_S_SET.

avr_il_set()

static RzILOpEffect* avr_il_set ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2776 of file avr_il.c.

                                                                                           {
    // T = 1
    return AVR_SREG_T_SET(true);
}

References AVR_SREG_T_SET.

avr_il_set16_from_reg()

static RzILOpEffect* avr_il_set16_from_reg ( const char *  dst, const char *  src, ut16  mask, ut16  sh  )

inlinestatic

Definition at line 198 of file avr_il.c.

                                                                                                        {
    RzILOpPure *_dst = VARG(dst);
    RzILOpBitVector *_mask = UN(16, mask);
    RzILOpBitVector *_and = LOGAND(_dst, _mask);
    RzILOpPure *_src = VARG(src);
    RzILOpBitVector *_extz = UNSIGNED(16, _src);
    if (sh) {
        RzILOpBitVector *_sh = AVR_SH(sh);
        _extz = SHIFTL0(_extz, _sh);
    }
    RzILOpBitVector *_or = LOGOR(_extz, _and);
    return SETG(dst, _or);
}

References AVR_SH, dst, LOGAND, LOGOR, mask, SETG, SHIFTL0, src, UN, UNSIGNED, and VARG.

Referenced by avr_il_out().

avr_il_set_sreg_bit_from_reg()

static RzILOpEffect* avr_il_set_sreg_bit_from_reg ( const char *  src, ut8  bit_val, const char *  bit_reg  )

inlinestatic

Definition at line 212 of file avr_il.c.

                                                                                                            {
    RzILOpPure *reg = VARG(src);
    RzILOpBitVector *bit = UN(AVR_REG_SIZE, bit_val);
    RzILOpBitVector *and = LOGAND(reg, bit);
    return SETG(bit_reg, and);
}

References AVR_REG_SIZE, bit, LOGAND, reg, SETG, src, UN, and VARG.

Referenced by avr_il_out().

avr_il_sev()

static RzILOpEffect* avr_il_sev ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2781 of file avr_il.c.

                                                                                           {
    // V = 1
    return AVR_SREG_V_SET(true);
}

References AVR_SREG_V_SET.

avr_il_sez()

static RzILOpEffect* avr_il_sez ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2786 of file avr_il.c.

                                                                                           {
    // Z = 1
    return AVR_SREG_Z_SET(true);
}

References AVR_SREG_Z_SET.

avr_il_sreg_bit_as_imm()

static RzILOpBitVector* avr_il_sreg_bit_as_imm ( const char *  sreg_bit, ut8  bit  )

inlinestatic

Definition at line 219 of file avr_il.c.

                                                                                     {
    RzILOpPure *_bit = VARG(sreg_bit);
    RzILOpPure *_true = AVR_IMM(bit);
    RzILOpPure *_false = AVR_ZERO();
    return rz_il_op_new_ite(_bit, _true, _false);
}

References AVR_IMM, AVR_ZERO, bit, rz_il_op_new_ite(), and VARG.

Referenced by avr_il_adc(), avr_il_in(), avr_il_sbc(), and avr_il_sbci().

avr_il_st()

static RzILOpEffect* avr_il_st ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2791 of file avr_il.c.

                                                                                          {
    RzILOpBitVector *addr;
    RzILOpPure *src;
    RzILOpEffect *st, *post_op, *let;
    // *((ut8*)X) = Rd where X = (r27 << 8) | r26;
    // *((ut8*)Y) = Rd where Y = (r29 << 8) | r28;
    // *((ut8*)Z) = Rd where Z = (r31 << 8) | r30;
    // When Z+ , Z is incremented by 1 after the execution (applies also to X and Y).
    // When -X , X is decremented by 1 after the execution (applies also to Z and Y).
    // When Y+q, Y is incremented by q after the execution (applies also to X and Z).
 
    // undefined behaviour per ISA below
    // st X+, r26 ; st X+, r27 ; st -X, r26 ; st -X, r27
    // st Y+, r28 ; st Y+, r29 ; st -Y, r28 ; st -Y, r29
    // st Z+, r30 ; st Z+, r31 ; st -Z, r30 ; st -Z, r31
 
    ut16 Rd = aop->param[0];
    char Rr = (char)aop->param[1]; // 'X' or 'Y' or 'Z'
    char Op = (char)aop->param[2]; //  0  or '+' or '-'
    ut16 q = aop->param[3];
 
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_indirect_address(Rr, NULL);
 
    switch (Rr) {
    case 'X':
        addr = AVR_X();
        break;
    case 'Y':
        addr = AVR_Y();
        break;
    default: // 'Z'
        addr = AVR_Z();
        break;
    }
 
    addr = AVR_ADDR(addr);
    src = AVR_REG(Rd);
    st = STOREW(addr, src);
 
    if (Op != '+' && Op != '-') {
        return st;
    }
 
    switch (Rr) {
    case 'X':
        addr = AVR_X();
        post_op = AVR_SET_X(AVR_LET_IND, q, Op == '+');
        break;
    case 'Y':
        addr = AVR_Y();
        post_op = AVR_SET_Y(AVR_LET_IND, q, Op == '+');
        break;
    default: // 'Z'
        addr = AVR_Z();
        post_op = AVR_SET_Z(AVR_LET_IND, q, Op == '+');
        break;
    }
 
    let = SETL(AVR_LET_IND, addr);
    return SEQ3(st, let, post_op);
}

References addr, AVR_ADDR, AVR_LET_IND, AVR_REG, avr_return_val_if_invalid_gpr, avr_return_val_if_invalid_indirect_address, AVR_SET_X, AVR_SET_Y, AVR_SET_Z, AVR_X, AVR_Y, AVR_Z, NULL, avr_opcode_t::param, SEQ3, SETL, src, and STOREW.

avr_il_store_pure()

static RzILOpEffect* avr_il_store_pure ( ut64  addr, RzILOpPure *  var  )

inlinestatic

Definition at line 182 of file avr_il.c.

                                                                          {
    RzILOpBitVector *_loc = UN(AVR_ADDR_SIZE, addr);
    return STOREW(_loc, var);
}

References addr, AVR_ADDR_SIZE, STOREW, and UN.

Referenced by avr_il_store_reg().

avr_il_store_reg()

static RzILOpEffect* avr_il_store_reg ( ut64  addr, const char *  reg  )

inlinestatic

Definition at line 187 of file avr_il.c.

                                                                         {
    RzILOpPure *_var = VARG(reg);
    return avr_il_store_pure(addr, _var);
}

References addr, avr_il_store_pure(), reg, and VARG.

Referenced by avr_il_out(), and avr_il_sts().

avr_il_sts()

static RzILOpEffect* avr_il_sts ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2854 of file avr_il.c.

                                                                                           {
    // Rd = *(k)
    ut16 k = aop->param[0];
    ut16 Rd = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
 
    return avr_il_store_reg(k, avr_registers[Rd]);
}

References avr_il_store_reg(), avr_registers, avr_return_val_if_invalid_gpr, k, NULL, and avr_opcode_t::param.

avr_il_sub()

static RzILOpEffect* avr_il_sub ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2863 of file avr_il.c.

                                                                                           {
    // Rd = Rd - Rr
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 Rr = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    avr_return_val_if_invalid_gpr(Rr, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *subt, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // TMP = Rd - Rr
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    subt = AVR_REG_SET(Rd, x);
 
    // set Z to 1 if !(x - y)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_REG(Rr);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, Z, H, V, N, C, S, subt);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, SUB, V, VARL, x, and Z.

avr_il_subi()

static RzILOpEffect* avr_il_subi ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2915 of file avr_il.c.

                                                                                            {
    // Rd = Rd - K
    // changes H|S|V|N|Z|C
    ut16 Rd = aop->param[0];
    ut16 K = aop->param[1];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *subt, *Z, *H, *S, *V, *N, *C;
    RzILOpBitVector *sub;
 
    // TMP = Rd - K
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    sub = SUB(x, y);
    let = SETL(AVR_LET_RES, sub);
 
    // Rd = TMP
    x = VARL(AVR_LET_RES);
    subt = AVR_REG_SET(Rd, x);
 
    // set Z to 1 if !(x - y)
    Z = avr_il_check_zero_flag_local(AVR_LET_RES, false);
 
    // H: (!Rd3 & Rr3) | (Rr3 & Res3) | (Res3 & !Rd3)
    // Set if there was a borrow from bit 3; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    H = avr_il_check_half_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // V: (Rd7 & !Rr7 & !Res7) | (!Rd7 & Rr7 & Res7)
    // Set if two’s complement overflow resulted from the operation; cleared otherwise.
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    V = avr_il_check_two_complement_overflow_flag_subtraction(AVR_LET_RES, x, y);
 
    // N: Res7
    // Set if MSB of the result is set; cleared otherwise.
    N = avr_il_check_negative_flag_local(AVR_LET_RES);
 
    // C: (!Rd7 & Rr7) | (Rr7 & Res7) | (Res7 & !Rd7)
    // Set if the absolute value of Rr is larger than the absolute value of Rd; cleared otherwise
    x = AVR_REG(Rd);
    y = AVR_IMM(K);
    C = avr_il_check_carry_flag_subtraction(AVR_LET_RES, x, y);
 
    // S: N ^ V, For signed tests.
    S = avr_il_check_signess_flag();
 
    return SEQ8(let, Z, H, V, N, C, S, subt);
}

References avr_il_check_carry_flag_subtraction(), avr_il_check_half_carry_flag_subtraction(), avr_il_check_negative_flag_local(), avr_il_check_signess_flag(), avr_il_check_two_complement_overflow_flag_subtraction(), avr_il_check_zero_flag_local(), AVR_IMM, AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, C, H, N, NULL, avr_opcode_t::param, S, SEQ8, SETL, SUB, V, VARL, x, and Z.

avr_il_swap()

static RzILOpEffect* avr_il_swap ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2966 of file avr_il.c.

                                                                                            {
    // Swaps high and low nibbles in a register.
    // R(7:4) = Rd(3:0), R(3:0) = Rd(7:4)
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y, *z;
    RzILOpEffect *let, *swap;
 
    // copy Rd
    x = AVR_REG(Rd);
    let = SETL(AVR_LET_RES, x);
 
    // Rd <<= 4
    x = AVR_REG(Rd);
    y = AVR_SH(4);
    x = SHIFTL0(x, y);
 
    // Rd |= RES >> 4
    z = VARL(AVR_LET_RES);
    y = AVR_SH(4);
    z = SHIFTR0(z, y);
 
    // Rd = (Rd << 4) | (RES >> 4)
    x = LOGOR(x, z);
    swap = AVR_REG_SET(Rd, x);
 
    return SEQ2(let, swap);
}

References AVR_LET_RES, AVR_REG, AVR_REG_SET, avr_return_val_if_invalid_gpr, AVR_SH, LOGOR, NULL, avr_opcode_t::param, SEQ2, SETL, SHIFTL0, SHIFTR0, swap, VARL, and x.

avr_il_unk()

static RzILOpEffect* avr_il_unk ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 567 of file avr_il.c.

                                                                                           {
    return NULL; // rz_il_op_new_nop();
}

References NULL.

avr_il_update_indirect_address_reg()

static RzILOpEffect* avr_il_update_indirect_address_reg ( const char *  local, ut16  reg_high, ut16  reg_low, ut64  n, bool  add  )

static

Definition at line 121 of file avr_il.c.

                                                                                                                          {
    RzILOpBitVector *_iar, *_num;
    RzILOpEffect *_high, *_low;
    const char *Rh = avr_registers[reg_high]; // register high
    const char *Rl = avr_registers[reg_low]; // register low
 
    _iar = VARL(local);
    if (n > 0) {
        _num = UN(AVR_IND_SIZE, n);
        if (add) {
            _iar = ADD(_iar, _num);
        } else {
            _iar = SUB(_iar, _num);
        }
    }
    _num = AVR_SH(8);
    _iar = SHIFTR0(_iar, _num);
    _iar = UNSIGNED(AVR_REG_SIZE, _iar);
    _high = SETG(Rh, _iar);
 
    _iar = VARL(local);
    if (n > 0) {
        _num = UN(AVR_IND_SIZE, n);
        if (add) {
            _iar = ADD(_iar, _num);
        } else {
            _iar = SUB(_iar, _num);
        }
    }
    _iar = UNSIGNED(AVR_REG_SIZE, _iar);
    _low = SETG(Rl, _iar);
    return SEQ2(_high, _low);
}

References ADD, add(), AVR_IND_SIZE, AVR_REG_SIZE, avr_registers, AVR_SH, local, n, SEQ2, SETG, SHIFTR0, SUB, UN, UNSIGNED, and VARL.

Referenced by avr_il_adiw(), avr_il_fmul(), avr_il_movw(), avr_il_mul(), avr_il_muls(), avr_il_mulsu(), and avr_il_sbiw().

avr_il_xch()

static RzILOpEffect* avr_il_xch ( AVROp *  aop, AVROp *  next_op, ut64  pc, RzAnalysis *  analysis  )

static

Definition at line 2995 of file avr_il.c.

                                                                                           {
    // Swaps the register content with the contents pointed by Z.
    // *(Z) = Rd and Rd = *(Z)
    ut16 Rd = aop->param[0];
    avr_return_val_if_invalid_gpr(Rd, NULL);
    RzILOpPure *x, *y;
    RzILOpEffect *let, *set, *store;
 
    // copy Rd
    x = AVR_REG(Rd);
    let = SETL(AVR_LET_RES, x);
 
    // Rd = *(Z)
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    x = LOADW(AVR_REG_SIZE, x);
    set = AVR_REG_SET(Rd, x);
 
    // *(Z) = RES
    x = AVR_Z();
    x = UNSIGNED(AVR_ADDR_SIZE, x);
    y = VARL(AVR_LET_RES);
    store = STOREW(x, y);
 
    return SEQ3(let, set, store);
}

References AVR_ADDR_SIZE, AVR_LET_RES, AVR_REG, AVR_REG_SET, AVR_REG_SIZE, avr_return_val_if_invalid_gpr, AVR_Z, LOADW, NULL, avr_opcode_t::param, SEQ3, SETL, STOREW, UNSIGNED, VARL, and x.

avr_subtract_if()

static RzILOpPure* avr_subtract_if ( ut32  bitsize, ut64  limit, RzILOpPure *  minuend, ut64  subtrahend, bool  invert  )

static

Definition at line 544 of file avr_il.c.

                                                                                                                {
    RzILOpPure *x, *y, *cmp;
 
    // cmp = minuend > limit
    x = UN(bitsize, limit);
    y = DUP(minuend);
    cmp = UGT(y, x);
 
    x = DUP(minuend);
    y = UN(bitsize, subtrahend);
    if (invert) {
        // x = subtrahend - minuend
        x = SUB(y, x);
    } else {
        // x = minuend - subtrahend
        x = SUB(x, y);
    }
 
    return ITE(cmp, x, minuend);
}

References cmp(), DUP, invert(), ITE, limit, SUB, UGT, UN, and x.

Referenced by avr_il_fmul(), avr_il_fmuls(), and avr_il_fmulsu().

resolve_mmio()

static const char* resolve_mmio ( RzAnalysis *  analysis, ut16  address  )

inlinestatic

Definition at line 226 of file avr_il.c.

                                                                           {
    RzPlatformProfile *profile = analysis->arch_target ? analysis->arch_target->profile : NULL;
    if (!profile) {
        return NULL;
    }
    return rz_platform_profile_resolve_mmio(profile, address);
}

References rz_analysis_t::arch_target, NULL, rz_platform_target_t::profile, and rz_platform_profile_resolve_mmio().

Referenced by avr_il_cbi(), avr_il_in(), avr_il_out(), avr_il_sbi(), avr_il_sbic(), and avr_il_sbis().

rz_avr_il_config()

RZ_IPI RzAnalysisILConfig* rz_avr_il_config

(

RZ_NONNULL RzAnalysis *

analysis

)

Definition at line 3156 of file avr_il.c.

                                                                             {
    rz_return_val_if_fail(analysis, NULL);
 
    RzAnalysisILConfig *r = rz_analysis_il_config_new(AVR_ADDR_SIZE, analysis->big_endian, AVR_ADDR_SIZE);
    r->reg_bindings = avr_global_registers;
    return r;
}

References AVR_ADDR_SIZE, avr_global_registers, NULL, r, rz_analysis_il_config_new(), and rz_return_val_if_fail.

rz_avr_il_opcode()

RZ_IPI bool rz_avr_il_opcode	(	RzAnalysis *	analysis,
		RzAnalysisOp *	op,
		ut64	pc,
		AVROp *	aop,
		AVROp *	next_op
	)

Definition at line 3143 of file avr_il.c.

                                                                                                          {
    rz_return_val_if_fail(analysis && op && aop && next_op, false);
    if (aop->mnemonic >= AVR_OP_SIZE) {
        RZ_LOG_ERROR("RzIL: AVR: out of bounds op\n");
        return false;
    }
 
    avr_il_op create_op = avr_ops[aop->mnemonic];
    op->il_op = create_op(aop, next_op, pc, analysis);
 
    return true;
}

References AVR_OP_SIZE, avr_ops, avr_opcode_t::mnemonic, pc, RZ_LOG_ERROR, and rz_return_val_if_fail.

Referenced by avr_op().

Variable Documentation

avr_global_registers

const char* avr_global_registers[]

static

Initial value:

= {
    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
    "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18",
    "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27",
    "r28", "r29", "r30", "r31", AVR_SREG_I, AVR_SREG_T, AVR_SREG_H,
    AVR_SREG_S, AVR_SREG_V, AVR_SREG_N, AVR_SREG_Z, AVR_SREG_C,
    AVR_SP, AVR_RAMPX, AVR_RAMPY, AVR_RAMPZ, AVR_RAMPD,
    AVR_EIND, AVR_SPMCSR, NULL
}

All registers available as global IL variables

Definition at line 105 of file avr_il.c.

Referenced by rz_avr_il_config().

avr_ops

avr_il_op avr_ops[AVR_OP_SIZE]

static

Definition at line 3026 of file avr_il.c.

Referenced by rz_avr_il_opcode().

avr_registers

const char* avr_registers[32]

Initial value:

= {
    "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9",
    "r10", "r11", "r12", "r13", "r14", "r15", "r16", "r17", "r18",
    "r19", "r20", "r21", "r22", "r23", "r24", "r25", "r26", "r27",
    "r28", "r29", "r30", "r31"
}

All registers

Definition at line 95 of file avr_il.c.

Referenced by avr_il_cbi(), avr_il_clr(), avr_il_in(), avr_il_ldi(), avr_il_lds(), avr_il_mov(), avr_il_out(), avr_il_sbi(), avr_il_sbic(), avr_il_sbis(), avr_il_ser(), avr_il_sts(), and avr_il_update_indirect_address_reg().