miasm2.expression.expression.ExprAff Class Reference

Inheritance diagram for miasm2.expression.expression.ExprAff:

Collaboration diagram for miasm2.expression.expression.ExprAff:

Public Member Functions
def	__init__
def	__str__
def	get_r
def	get_w
def	__contains__
def	get_modified_slice
def	visit
def	copy
def	depth
def	graph_recursive
def	set_size
def	__getitem__
def	get_size
def	is_function_call
def	__repr__
def	__hash__
def	pre_eq
def	__eq__
def	__ne__
def	__add__
def	__sub__
def	__div__
def	__mod__
def	__mul__
def	__lshift__
def	__rshift__
def	__xor__
def	__or__
def	__and__
def	__neg__
def	__invert__
def	replace_expr
def	canonize
def	msb
def	zeroExtend
def	signExtend
def	graph
def	set_mask

Public Attributes
	arg

Static Public Attributes
	is_term = False
	is_simp = False
	is_canon = False
	is_eval = False

Properties
	dst = property(lambda self: self._dst)
	src = property(lambda self: self._src)
	size = property(lambda self: self._size)
	mask = property(lambda self: ExprInt(-1, self.size))

Private Member Functions
def	_exprhash
def	_exprrepr

Private Attributes
	_dst
	_src
	_size

Detailed Description

An ExprAff represent an affection from an Expression to another one.

Some use cases:
 - var1 <- 2

Definition at line 473 of file expression.py.

Constructor & Destructor Documentation

def miasm2.expression.expression.ExprAff.__init__	(		self,
			dst,
			src
	)

Create an ExprAff for dst <- src
@dst: Expr, affectation destination
@src: Expr, affectation source

Definition at line 481 of file expression.py.

    def __init__(self, dst, src):
        """Create an ExprAff for dst <- src
        @dst: Expr, affectation destination
        @src: Expr, affectation source
        """
        if dst.size != src.size:
            raise ValueError(
                "sanitycheck: ExprAff args must have same size! %s" %
                             ([(str(arg), arg.size) for arg in [dst, src]]))

        if isinstance(dst, ExprSlice):
            # Complete the source with missing slice parts
            self._dst = dst.arg
            rest = [(ExprSlice(dst.arg, r[0], r[1]), r[0], r[1])
                    for r in dst.slice_rest()]
            all_a = [(src, dst.start, dst.stop)] + rest
            all_a.sort(key=lambda x: x[1])
            self._src = ExprCompose(all_a)

        else:
            self._dst, self._src = dst, src

        self._size = self.dst.size