Miasm2
 All Classes Namespaces Files Functions Variables Typedefs Properties Macros
Public Member Functions | Public Attributes | Static Public Attributes | List of all members
miasm2.expression.simplifications.ExpressionSimplifier Class Reference
+ Inheritance diagram for miasm2.expression.simplifications.ExpressionSimplifier:
+ Collaboration diagram for miasm2.expression.simplifications.ExpressionSimplifier:

Public Member Functions

def __init__
 
def enable_passes
 
def apply_simp
 
def expr_simp
 
def expr_simp_wrapper
 
def __call__
 

Public Attributes

 expr_simp_cb
 

Static Public Attributes

dictionary PASS_COMMONS
 
dictionary PASS_HEAVY = {}
 
dictionary PASS_COND
 

Detailed Description

Wrapper on expression simplification passes.

Instance handle passes lists.

Available passes lists are:
 - commons: common passes such as constant folding
 - heavy  : rare passes (for instance, in case of obfuscation)

Definition at line 14 of file simplifications.py.

Constructor & Destructor Documentation

def miasm2.expression.simplifications.ExpressionSimplifier.__init__ (   self)

Definition at line 49 of file simplifications.py.

49 
50  def __init__(self):
51  self.expr_simp_cb = {}

Member Function Documentation

def miasm2.expression.simplifications.ExpressionSimplifier.__call__ (   self,
  expression,
  callback = None 
)

Definition at line 115 of file simplifications.py.

115 
116  def __call__(self, expression, callback=None):
117  "Wrapper on expr_simp_wrapper"
118  return self.expr_simp_wrapper(expression, callback)
119 
120 
# Public ExprSimplificationPass instance with commons passes

+ Here is the call graph for this function:

def miasm2.expression.simplifications.ExpressionSimplifier.apply_simp (   self,
  expression 
) 
Apply enabled simplifications on expression
@expression: Expr instance
Return an Expr instance

Definition at line 62 of file simplifications.py.

62 
63  def apply_simp(self, expression):
64  """Apply enabled simplifications on expression
65  @expression: Expr instance
66  Return an Expr instance"""
67 
68  cls = expression.__class__
69  for simp_func in self.expr_simp_cb.get(cls, []):
70  # Apply simplifications
71  expression = simp_func(self, expression)
72 
73  # If class changes, stop to prevent wrong simplifications
74  if expression.__class__ is not cls:
75  break
76 
77  return expression

+ Here is the caller graph for this function:

def miasm2.expression.simplifications.ExpressionSimplifier.enable_passes (   self,
  passes 
) 
Add passes from @passes
@passes: dict(Expr class : list(callback))

Callback signature: Expr callback(ExpressionSimplifier, Expr)

Definition at line 52 of file simplifications.py.

52 
53  def enable_passes(self, passes):
54  """Add passes from @passes
55  @passes: dict(Expr class : list(callback))
56 
57  Callback signature: Expr callback(ExpressionSimplifier, Expr)
58  """
59 
60  for k, v in passes.items():
61  self.expr_simp_cb[k] = fast_unify(self.expr_simp_cb.get(k, []) + v)
miasm2.expression.expression_helper.fast_unify
def fast_unify
Definition: expression_helper.py:172

+ Here is the call graph for this function:

def miasm2.expression.simplifications.ExpressionSimplifier.expr_simp (   self,
  expression 
) 
Apply enabled simplifications on expression and find a stable state
@expression: Expr instance
Return an Expr instance

Definition at line 78 of file simplifications.py.

78 
79  def expr_simp(self, expression):
80  """Apply enabled simplifications on expression and find a stable state
81  @expression: Expr instance
82  Return an Expr instance"""
83 
84  if expression.is_simp:
85  return expression
86 
87  # Find a stable state
88  while True:
89  # Canonize and simplify
90  e_new = self.apply_simp(expression.canonize())
91  if e_new == expression:
92  break
93 
94  # Launch recursivity
95  expression = self.expr_simp_wrapper(e_new)
96  expression.is_simp = True
97 
98  # Mark expression as simplified
99  e_new.is_simp = True
100  return e_new

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

def miasm2.expression.simplifications.ExpressionSimplifier.expr_simp_wrapper (   self,
  expression,
  callback = None 
) 
Apply enabled simplifications on expression
@expression: Expr instance
@manual_callback: If set, call this function instead of normal one
Return an Expr instance

Definition at line 101 of file simplifications.py.

101 
102  def expr_simp_wrapper(self, expression, callback=None):
103  """Apply enabled simplifications on expression
104  @expression: Expr instance
105  @manual_callback: If set, call this function instead of normal one
106  Return an Expr instance"""
107 
108  if expression.is_simp:
109  return expression
110 
111  if callback is None:
112  callback = self.expr_simp
113 
114  return expression.visit(callback, lambda e: not(e.is_simp))

+ Here is the call graph for this function:

+ Here is the caller graph for this function:

Member Data Documentation

miasm2.expression.simplifications.ExpressionSimplifier.expr_simp_cb

Definition at line 50 of file simplifications.py.

dictionary miasm2.expression.simplifications.ExpressionSimplifier.PASS_COMMONS
static
Initial value:
1 = {
2  m2_expr.ExprOp: [simplifications_common.simp_cst_propagation,
3  simplifications_common.simp_cond_op_int,
4  simplifications_common.simp_cond_factor],
5  m2_expr.ExprSlice: [simplifications_common.simp_slice],
6  m2_expr.ExprCompose: [simplifications_common.simp_compose],
7  m2_expr.ExprCond: [simplifications_common.simp_cond],
8  }

Definition at line 26 of file simplifications.py.

dictionary miasm2.expression.simplifications.ExpressionSimplifier.PASS_COND
static
Initial value:
1 = {m2_expr.ExprSlice: [simplifications_cond.expr_simp_inf_signed,
2  simplifications_cond.expr_simp_inf_unsigned_inversed],
3  m2_expr.ExprOp: [simplifications_cond.exec_inf_unsigned,
4  simplifications_cond.exec_inf_signed,
5  simplifications_cond.expr_simp_inverse,
6  simplifications_cond.exec_equal],
7  m2_expr.ExprCond: [simplifications_cond.expr_simp_equal]
8  }

Definition at line 39 of file simplifications.py.

dictionary miasm2.expression.simplifications.ExpressionSimplifier.PASS_HEAVY = {}
static

Definition at line 36 of file simplifications.py.

The documentation for this class was generated from the following file:
Generated by   doxygen 1.8.8