miasm2.expression.expression.ExprOp Class Reference

Inheritance diagram for miasm2.expression.expression.ExprOp:

Collaboration diagram for miasm2.expression.expression.ExprOp:

Public Member Functions
def	__init__
def	__str__
def	get_r
def	get_w
def	__contains__
def	is_function_call
def	is_associative
def	is_commutative
def	visit
def	copy
def	depth
def	graph_recursive
def	set_size
def	__getitem__
def	get_size
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
	op = property(lambda self: self._op)
	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

An ExprOp stand for an operation between Expr

Use cases:
 - var1 XOR var2
 - var1 + var2 + var3
 - parity bit(var1)

Definition at line 718 of file expression.py.

Constructor & Destructor Documentation

def miasm2.expression.expression.ExprOp.__init__	(		self,
			op,
			args
	)

Create an ExprOp
@op: str, operation
@*args: Expr, operand list

Definition at line 728 of file expression.py.

    def __init__(self, op, *args):
        """Create an ExprOp
        @op: str, operation
        @*args: Expr, operand list
        """

        sizes = set([arg.size for arg in args])

        if len(sizes) != 1:
            # Special cases : operande sizes can differ
            if op not in ["segm"]:
                raise ValueError(
                    "sanitycheck: ExprOp args must have same size! %s" %
                                 ([(str(arg), arg.size) for arg in args]))

        if not isinstance(op, str):
            raise ValueError("ExprOp: 'op' argument must be a string")

        self._op, self._args = op, tuple(args)

        # Set size for special cases
        if self._op in [
                '==', 'parity', 'fcom_c0', 'fcom_c1', 'fcom_c2', 'fcom_c3',
                'fxam_c0', 'fxam_c1', 'fxam_c2', 'fxam_c3',
                "access_segment_ok", "load_segment_limit_ok", "bcdadd_cf",
                "ucomiss_zf", "ucomiss_pf", "ucomiss_cf"]:
            sz = 1
        elif self._op in [TOK_INF, TOK_INF_SIGNED,
                          TOK_INF_UNSIGNED, TOK_INF_EQUAL,
                          TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED,
                          TOK_EQUAL, TOK_POS,
                          TOK_POS_STRICT,
                          ]:
            sz = 1
        elif self._op in ['mem_16_to_double', 'mem_32_to_double',
                          'mem_64_to_double', 'mem_80_to_double',
                          'int_16_to_double', 'int_32_to_double',
                          'int_64_to_double', 'int_80_to_double']:
            sz = 64
        elif self._op in ['double_to_mem_16', 'double_to_int_16',
                          'float_trunc_to_int_16', 'double_trunc_to_int_16']:
            sz = 16
        elif self._op in ['double_to_mem_32', 'double_to_int_32',
                          'float_trunc_to_int_32', 'double_trunc_to_int_32',
                          'double_to_float']:
            sz = 32
        elif self._op in ['double_to_mem_64', 'double_to_int_64',
                          'float_trunc_to_int_64', 'double_trunc_to_int_64',
                          'float_to_double']:
            sz = 64
        elif self._op in ['double_to_mem_80', 'double_to_int_80',
                          'float_trunc_to_int_80',
                          'double_trunc_to_int_80']:
            sz = 80
        elif self._op in ['segm']:
            sz = self._args[1].size
        else:
            if None in sizes:
                sz = None
            else:
                # All arguments have the same size
                sz = list(sizes)[0]

        self._size = sz