miasm2.expression.expression.ExprCompose Class Reference

Inheritance diagram for miasm2.expression.expression.ExprCompose:

Collaboration diagram for miasm2.expression.expression.ExprCompose:

Public Member Functions
def	__init__
def	__str__
def	get_r
def	get_w
def	__contains__
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
	args = property(lambda self: self._args)
	size = property(lambda self: self._size)
	mask = property(lambda self: ExprInt(-1, self.size))

Private Member Functions
def	_exprhash
def	_exprrepr

Private Attributes
	_args
	_size

Detailed Description

Compose is like a hambuger.
It's arguments are tuple of:  (Expression, start, stop)
start and stop are intergers, determining Expression position in the compose.

Burger Example:
ExprCompose([(salad, 0, 3), (cheese, 3, 10), (beacon, 10, 16)])
In the example, salad.size == 3.

Definition at line 938 of file expression.py.

Constructor & Destructor Documentation

def miasm2.expression.expression.ExprCompose.__init__	(		self,
			args
	)

Create an ExprCompose
The ExprCompose is contiguous and starts at 0
@args: tuple(Expr, int, int)

Definition at line 950 of file expression.py.

    def __init__(self, args):
        """Create an ExprCompose
        The ExprCompose is contiguous and starts at 0
        @args: tuple(Expr, int, int)
        """

        last_stop = 0
        args = sorted(args, key=itemgetter(1))
        for e, start, stop in args:
            if e.size != stop - start:
                raise ValueError(
                    "sanitycheck: ExprCompose args must have correct size!" +
                    " %r %r %r" % (e, e.size, stop - start))
            if last_stop != start:
                raise ValueError(
                    "sanitycheck: ExprCompose args must be contiguous!" +
                    " %r" % (args))
            last_stop = stop

        # Transform args to lists
        o = []
        for e, a, b in args:
            assert(a >= 0 and b >= 0)
            o.append(tuple([e, a, b]))
        self._args = tuple(o)

        self._size = self._args[-1][2]