From dcf03ce77a4baeeda8e72b5d5b44e6643cf11501 Mon Sep 17 00:00:00 2001
From: ajax <devnull@localhost>
Date: Thu, 12 Jun 2014 17:34:49 +0200
Subject: Simplifications: Add regression tests for simplifications_cond

---
 test/expression/simplifications.py | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

(limited to 'test/expression/simplifications.py')

diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index 19f43d6e..7d76b6e2 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -3,7 +3,8 @@
 #
 from pdb import pm
 from miasm2.expression.expression import *
-from miasm2.expression.simplifications import expr_simp
+from miasm2.expression.simplifications import expr_simp, ExpressionSimplifier
+from miasm2.expression.simplifications_cond import TOK_INF_SIGNED, TOK_INF_UNSIGNED
 
 # Define example objects
 a = ExprId('a')
@@ -173,6 +174,34 @@ for e, e_check in to_test[:]:
         raise ValueError(
             'bug in expr_simp simp(%s) is %s and should be %s' % (e, e_new, e_check))
 
+# Test conds
+
+to_test = [
+    (((a - b) ^ ((a ^ b) & ((a - b) ^ a)))[31:32],
+     ExprOp(TOK_INF_SIGNED, a, b)),
+    ((((a - b) ^ ((a ^ b) & ((a - b) ^ a))) ^ a ^ b)[31:32],
+     ExprOp(TOK_INF_UNSIGNED, a, b)),
+    (ExprOp(TOK_INF_UNSIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
+    (ExprOp(TOK_INF_SIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
+]
+
+expr_simp_cond = ExpressionSimplifier()
+expr_simp.enable_passes(ExpressionSimplifier.PASS_COND)
+
+
+for e, e_check in to_test[:]:
+    #
+    print "#" * 80
+    e_check = expr_simp(e_check)
+    # print str(e), str(e_check)
+    e_new = expr_simp(e)
+    print "original: ", str(e), "new: ", str(e_new)
+    rez = e_new == e_check
+    if not rez:
+        raise ValueError(
+            'bug in expr_simp simp(%s) is %s and should be %s' % (e, e_new, e_check))
+
+
 
 x = ExprId('x')
 y = ExprId('y')
-- 
cgit 1.4.1


From 8462e1b5b65b61e837e673229e1bae4dc78c7840 Mon Sep 17 00:00:00 2001
From: ajax <devnull@localhost>
Date: Thu, 12 Jun 2014 17:41:05 +0200
Subject: Test: Simplifications: Use ".msb()" instead of hard coded [31:32]

---
 test/expression/simplifications.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'test/expression/simplifications.py')

diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index 7d76b6e2..9a4fbe8c 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -177,9 +177,9 @@ for e, e_check in to_test[:]:
 # Test conds
 
 to_test = [
-    (((a - b) ^ ((a ^ b) & ((a - b) ^ a)))[31:32],
+    (((a - b) ^ ((a ^ b) & ((a - b) ^ a))).msb(),
      ExprOp(TOK_INF_SIGNED, a, b)),
-    ((((a - b) ^ ((a ^ b) & ((a - b) ^ a))) ^ a ^ b)[31:32],
+    ((((a - b) ^ ((a ^ b) & ((a - b) ^ a))) ^ a ^ b).msb(),
      ExprOp(TOK_INF_UNSIGNED, a, b)),
     (ExprOp(TOK_INF_UNSIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
     (ExprOp(TOK_INF_SIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
-- 
cgit 1.4.1


From 0698cd3820a70182c362ba113849fe8ca5e0e032 Mon Sep 17 00:00:00 2001
From: ajax <devnull@localhost>
Date: Thu, 12 Jun 2014 18:40:55 +0200
Subject: Simplifications_cond: Fix size issue, add constructor

I could have use a child class of ExprOp specific for conditions, but
I prefer to keep a better modularity by just using "<s", "<u" as a new op

I don't add the size issue in expression/expression.py (such as 'parity')
because we don't want dependencies from this file to
expression/simplifications_cond (for TOK_*)
---
 miasm2/expression/simplifications_cond.py | 23 +++++++++++++++++++++--
 test/expression/simplifications.py        | 10 +++++-----
 2 files changed, 26 insertions(+), 7 deletions(-)

(limited to 'test/expression/simplifications.py')

diff --git a/miasm2/expression/simplifications_cond.py b/miasm2/expression/simplifications_cond.py
index 93f28162..8f41975b 100644
--- a/miasm2/expression/simplifications_cond.py
+++ b/miasm2/expression/simplifications_cond.py
@@ -34,6 +34,25 @@ jok1 = m2_expr.ExprId("jok1")
 jok2 = m2_expr.ExprId("jok2")
 jok3 = m2_expr.ExprId("jok3")
 
+# Constructors
+
+def __ExprOp_cond(op, arg1, arg2):
+    "Return an ExprOp standing for arg1 op arg2 with size to 1"
+    ec = m2_expr.ExprOp(op, arg1, arg2)
+    ec._size = 1
+    return ec
+
+
+def ExprOp_inf_signed(arg1, arg2):
+    "Return an ExprOp standing for arg1 <s arg2"
+    return __ExprOp_cond(TOK_INF_SIGNED, arg1, arg2)
+
+
+def ExprOp_inf_unsigned(arg1, arg2):
+    "Return an ExprOp standing for arg1 <s arg2"
+    return __ExprOp_cond(TOK_INF_UNSIGNED, arg1, arg2)
+
+
 # Catching conditions forms
 
 def __check_msb(e):
@@ -83,7 +102,7 @@ def expr_simp_inf_signed(expr_simp, e):
     sub = expr_simp(r[jok1] - r[jok2])
 
     if new_j3 == sub:
-        return m2_expr.ExprOp(TOK_INF_SIGNED, r[jok1], r[jok2])
+        return ExprOp_inf_signed(r[jok1], r[jok2])
     else:
         return e
 
@@ -107,7 +126,7 @@ def expr_simp_inf_unsigned_inversed(expr_simp, e):
     sub = expr_simp(r[jok1] - r[jok2])
 
     if new_j3 == sub:
-        return m2_expr.ExprOp(TOK_INF_UNSIGNED, r[jok1], r[jok2])
+        return ExprOp_inf_unsigned(r[jok1], r[jok2])
     else:
         return e
 
diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index 9a4fbe8c..057ff1c7 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -4,7 +4,7 @@
 from pdb import pm
 from miasm2.expression.expression import *
 from miasm2.expression.simplifications import expr_simp, ExpressionSimplifier
-from miasm2.expression.simplifications_cond import TOK_INF_SIGNED, TOK_INF_UNSIGNED
+from miasm2.expression.simplifications_cond import ExprOp_inf_signed, ExprOp_inf_unsigned
 
 # Define example objects
 a = ExprId('a')
@@ -178,11 +178,11 @@ for e, e_check in to_test[:]:
 
 to_test = [
     (((a - b) ^ ((a ^ b) & ((a - b) ^ a))).msb(),
-     ExprOp(TOK_INF_SIGNED, a, b)),
+     ExprOp_inf_signed(a, b)),
     ((((a - b) ^ ((a ^ b) & ((a - b) ^ a))) ^ a ^ b).msb(),
-     ExprOp(TOK_INF_UNSIGNED, a, b)),
-    (ExprOp(TOK_INF_UNSIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
-    (ExprOp(TOK_INF_SIGNED, ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
+     ExprOp_inf_unsigned(a, b)),
+    (ExprOp_inf_unsigned(ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
+    (ExprOp_inf_signed(ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
 ]
 
 expr_simp_cond = ExpressionSimplifier()
-- 
cgit 1.4.1


From a635b0185b9fe26453ceedb5d56aa9d59503b695 Mon Sep 17 00:00:00 2001
From: ajax <devnull@localhost>
Date: Thu, 12 Jun 2014 18:51:59 +0200
Subject: Simplifications: Add symetric cond catching + corresponding tests

---
 miasm2/expression/simplifications_cond.py | 40 +++++++++++++++++++++++++++++--
 test/expression/simplifications.py        |  2 ++
 2 files changed, 40 insertions(+), 2 deletions(-)

(limited to 'test/expression/simplifications.py')

diff --git a/miasm2/expression/simplifications_cond.py b/miasm2/expression/simplifications_cond.py
index 8f41975b..ee23f6db 100644
--- a/miasm2/expression/simplifications_cond.py
+++ b/miasm2/expression/simplifications_cond.py
@@ -33,6 +33,8 @@ TOK_POS_STRICT = "Spos"
 jok1 = m2_expr.ExprId("jok1")
 jok2 = m2_expr.ExprId("jok2")
 jok3 = m2_expr.ExprId("jok3")
+jok_small = m2_expr.ExprId("jok_small", 1)
+
 
 # Constructors
 
@@ -134,10 +136,44 @@ def expr_simp_inverse(expr_simp, e):
     """(x <u y) ^ ((x ^ y) [31:32]) == x <s y,
     (x <s y) ^ ((x ^ y) [31:32]) == x <u y"""
 
-    if e.op != '^' or len(e.args) != 2:
+    to_match = (ExprOp_inf_unsigned(jok1, jok2) ^ jok_small)
+    r = __MatchExprWrap(e,
+                        to_match,
+                        [jok1, jok2, jok_small])
+
+    # Check for 2 symetric cases
+    if r is False:
+            to_match = (ExprOp_inf_signed(jok1, jok2) ^ jok_small)
+            r = __MatchExprWrap(e,
+                                to_match,
+                                [jok1, jok2, jok_small])
+
+            if r is False:
+                return e
+            cur_sig = TOK_INF_SIGNED
+    else:
+        cur_sig = TOK_INF_UNSIGNED
+
+
+    arg = __check_msb(r[jok_small])
+    if arg is False:
+        return e
+
+    if not isinstance(arg, m2_expr.ExprOp) or arg.op != "^":
+        return e
+
+    op_args = arg.args
+    if len(op_args) != 2:
+        return e
+
+    if r[jok1] not in op_args or r[jok2] not in op_args:
         return e
 
-    return e # TODO: Not Implemented
+    if cur_sig == TOK_INF_UNSIGNED:
+        return ExprOp_inf_signed(r[jok1], r[jok2])
+    else:
+        return ExprOp_inf_unsigned(r[jok1], r[jok2])
+
 
 # Compute conditions
 
diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py
index 057ff1c7..ac6b796d 100644
--- a/test/expression/simplifications.py
+++ b/test/expression/simplifications.py
@@ -183,6 +183,8 @@ to_test = [
      ExprOp_inf_unsigned(a, b)),
     (ExprOp_inf_unsigned(ExprInt32(-1), ExprInt32(3)), ExprInt1(0)),
     (ExprOp_inf_signed(ExprInt32(-1), ExprInt32(3)), ExprInt1(1)),
+    (ExprOp_inf_unsigned(a, b) ^ (a ^ b).msb(), ExprOp_inf_signed(a, b)),
+    (ExprOp_inf_signed(a, b) ^ (a ^ b).msb(), ExprOp_inf_unsigned(a, b)),
 ]
 
 expr_simp_cond = ExpressionSimplifier()
-- 
cgit 1.4.1