From e5c439d3b4ee7120fae3d15ae7106cce8d0dcbde Mon Sep 17 00:00:00 2001
From: Fabrice Desclaux <fabrice.desclaux@cea.fr>
Date: Tue, 9 Oct 2018 07:40:52 +0200
Subject: Simplifications: simplify by default high level op

Simplifify by default high level operators (<u, ...) with pure cst as arguments
---
 miasm2/expression/simplifications.py        | 28 ++++++++----
 miasm2/expression/simplifications_common.py | 70 +++++++++++++++++++++++++++++
 miasm2/expression/simplifications_cond.py   | 54 ----------------------
 3 files changed, 89 insertions(+), 63 deletions(-)

(limited to 'miasm2/expression')

diff --git a/miasm2/expression/simplifications.py b/miasm2/expression/simplifications.py
index e090d806..2807b4b3 100644
--- a/miasm2/expression/simplifications.py
+++ b/miasm2/expression/simplifications.py
@@ -46,9 +46,15 @@ class ExpressionSimplifier(object):
             simplifications_common.simp_double_signext,
             simplifications_common.simp_zeroext_eq_cst,
 
+            simplifications_common.simp_cmp_int_int,
+            simplifications_common.simp_ext_cst,
+
         ],
 
-        m2_expr.ExprSlice: [simplifications_common.simp_slice],
+        m2_expr.ExprSlice: [
+            simplifications_common.simp_slice,
+            simplifications_common.simp_slice_of_ext,
+        ],
         m2_expr.ExprCompose: [simplifications_common.simp_compose],
         m2_expr.ExprCond: [
             simplifications_common.simp_cond,
@@ -68,14 +74,18 @@ class ExpressionSimplifier(object):
     PASS_HEAVY = {}
 
     # Cond passes
-    PASS_COND = {m2_expr.ExprSlice: [simplifications_cond.expr_simp_inf_signed,
-                                     simplifications_cond.expr_simp_inf_unsigned_inversed],
-                 m2_expr.ExprOp: [simplifications_cond.exec_inf_unsigned,
-                                  simplifications_cond.exec_inf_signed,
-                                  simplifications_cond.expr_simp_inverse,
-                                  simplifications_cond.exec_equal],
-                 m2_expr.ExprCond: [simplifications_cond.expr_simp_equal]
-                 }
+    PASS_COND = {
+        m2_expr.ExprSlice: [
+            simplifications_cond.expr_simp_inf_signed,
+            simplifications_cond.expr_simp_inf_unsigned_inversed
+        ],
+        m2_expr.ExprOp: [
+            simplifications_cond.expr_simp_inverse,
+        ],
+        m2_expr.ExprCond: [
+            simplifications_cond.expr_simp_equal
+        ]
+    }
 
 
     # Available passes lists are:
diff --git a/miasm2/expression/simplifications_common.py b/miasm2/expression/simplifications_common.py
index 2eeabd9b..676501a0 100644
--- a/miasm2/expression/simplifications_common.py
+++ b/miasm2/expression/simplifications_common.py
@@ -1060,3 +1060,73 @@ def simp_cond_eq_zero(expr_s, expr):
         return expr
     new_expr = ExprCond(arg1, expr.src2, expr.src1)
     return new_expr
+
+
+def simp_cmp_int_int(expr_s, expr):
+    # IntA <s IntB => int
+    # IntA <u IntB => int
+    # IntA <=s IntB => int
+    # IntA <=u IntB => int
+    # IntA == IntB => int
+    if expr.op not in [
+            TOK_EQUAL,
+            TOK_INF_SIGNED, TOK_INF_UNSIGNED,
+            TOK_INF_EQUAL_SIGNED, TOK_INF_EQUAL_UNSIGNED,
+    ]:
+        return expr
+    if not all(arg.is_int() for arg in expr.args):
+        return expr
+    int_a, int_b = expr.args
+    if expr.is_op(TOK_EQUAL):
+        if int_a == int_b:
+            return ExprInt(1, 1)
+        else:
+            return ExprInt(0, 1)
+
+    if expr.op in [TOK_INF_SIGNED, TOK_INF_EQUAL_SIGNED]:
+        int_a = int(mod_size2int[int_a.size](int(int_a)))
+        int_b = int(mod_size2int[int_b.size](int(int_b)))
+    else:
+        int_a = int(mod_size2uint[int_a.size](int(int_a)))
+        int_b = int(mod_size2uint[int_b.size](int(int_b)))
+
+    if expr.op in [TOK_INF_SIGNED, TOK_INF_UNSIGNED]:
+        ret = int_a < int_b
+    else:
+        ret = int_a <= int_b
+
+    if ret:
+        ret = 1
+    else:
+        ret = 0
+    return ExprInt(ret, 1)
+
+
+def simp_ext_cst(expr_s, expr):
+    # Int.zeroExt(X) => Int
+    # Int.signExt(X) => Int
+    if not (expr.op.startswith("zeroExt") or expr.op.startswith("signExt")):
+        return expr
+    arg = expr.args[0]
+    if not arg.is_int():
+        return expr
+    if expr.op.startswith("zeroExt"):
+        ret = int(arg)
+    else:
+        ret = int(mod_size2int[arg.size](int(arg)))
+    ret = ExprInt(ret, expr.size)
+    return ret
+
+
+def simp_slice_of_ext(expr_s, expr):
+    # zeroExt(X)[0:size(X)] => X
+    if expr.start != 0:
+        return expr
+    if not expr.arg.is_op():
+        return expr
+    if not expr.arg.op.startswith("zeroExt"):
+        return expr
+    arg = expr.arg.args[0]
+    if arg.size != expr.size:
+        return expr
+    return arg
diff --git a/miasm2/expression/simplifications_cond.py b/miasm2/expression/simplifications_cond.py
index 6bdc810f..f6b1ea8b 100644
--- a/miasm2/expression/simplifications_cond.py
+++ b/miasm2/expression/simplifications_cond.py
@@ -176,57 +176,3 @@ def expr_simp_equal(expr_simp, e):
         return e
 
     return ExprOp_equal(r[jok1], expr_simp(-r[jok2]))
-
-# Compute conditions
-
-def exec_inf_unsigned(expr_simp, e):
-    "Compute x <u y"
-    if e.op != m2_expr.TOK_INF_UNSIGNED:
-        return e
-
-    arg1, arg2 = e.args
-
-    if isinstance(arg1, m2_expr.ExprInt) and isinstance(arg2, m2_expr.ExprInt):
-        return m2_expr.ExprInt(1, 1) if (arg1.arg < arg2.arg) else m2_expr.ExprInt(0, 1)
-    else:
-        return e
-
-
-def __comp_signed(arg1, arg2):
-    """Return ExprInt(1, 1) if arg1 <s arg2 else ExprInt(0, 1)
-    @arg1, @arg2: ExprInt"""
-
-    val1 = int(arg1)
-    if val1 >> (arg1.size - 1) == 1:
-        val1 = - ((int(arg1.mask) ^ val1) + 1)
-
-    val2 = int(arg2)
-    if val2 >> (arg2.size - 1) == 1:
-        val2 = - ((int(arg2.mask) ^ val2) + 1)
-
-    return m2_expr.ExprInt(1, 1) if (val1 < val2) else m2_expr.ExprInt(0, 1)
-
-def exec_inf_signed(expr_simp, e):
-    "Compute x <s y"
-
-    if e.op != m2_expr.TOK_INF_SIGNED:
-        return e
-
-    arg1, arg2 = e.args
-
-    if isinstance(arg1, m2_expr.ExprInt) and isinstance(arg2, m2_expr.ExprInt):
-        return __comp_signed(arg1, arg2)
-    else:
-        return e
-
-def exec_equal(expr_simp, e):
-    "Compute x == y"
-
-    if e.op != m2_expr.TOK_EQUAL:
-        return e
-
-    arg1, arg2 = e.args
-    if isinstance(arg1, m2_expr.ExprInt) and isinstance(arg2, m2_expr.ExprInt):
-        return m2_expr.ExprInt(1, 1) if (arg1.arg == arg2.arg) else m2_expr.ExprInt(0, 1)
-    else:
-        return e
-- 
cgit 1.4.1