From a11964b49954c7bba71264b5b27e31cec01e8481 Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Mon, 8 Oct 2018 23:30:01 +0200 Subject: Simplifications: fix bad simplifications --- miasm2/expression/simplifications_common.py | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) (limited to 'miasm2/expression/simplifications_common.py') diff --git a/miasm2/expression/simplifications_common.py b/miasm2/expression/simplifications_common.py index e7dacc91..2eeabd9b 100644 --- a/miasm2/expression/simplifications_common.py +++ b/miasm2/expression/simplifications_common.py @@ -885,6 +885,8 @@ def simp_cond_flag(expr_simp, expr): def simp_cond_int(expr_simp, expr): + # ({X, 0} == int) => X == int[:] + # X + int1 == int2 => X == int2-int1 if (expr.cond.is_op(TOK_EQUAL) and expr.cond.args[1].is_int() and expr.cond.args[0].is_compose() and @@ -903,15 +905,15 @@ def simp_cond_int(expr_simp, expr): elif (expr.cond.is_op() and expr.cond.op in [ TOK_EQUAL, - TOK_INF_SIGNED, - TOK_INF_EQUAL_SIGNED, - TOK_INF_UNSIGNED, - TOK_INF_EQUAL_UNSIGNED ] and expr.cond.args[1].is_int() and expr.cond.args[0].is_op("+") and expr.cond.args[0].args[-1].is_int()): # X + int1 == int2 => X == int2-int1 + # WARNING: + # X - 0x10 <=u 0x20 gives X in [0x10 0x30] + # which is not equivalet to A <=u 0x10 + left, right = expr.cond.args left, int_diff = left.args[:-1], left.args[-1] if len(left) == 1: -- cgit 1.4.1 From e5c439d3b4ee7120fae3d15ae7106cce8d0dcbde Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Tue, 9 Oct 2018 07:40:52 +0200 Subject: Simplifications: simplify by default high level op Simplifify by default high level operators ( int + # IntA 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 > (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 Date: Tue, 9 Oct 2018 08:16:02 +0200 Subject: Simplifications: fix hl cond reduction Match code to comment --- miasm2/expression/simplifications.py | 2 +- miasm2/expression/simplifications_common.py | 38 ++++++++++++----------------- 2 files changed, 17 insertions(+), 23 deletions(-) (limited to 'miasm2/expression/simplifications_common.py') diff --git a/miasm2/expression/simplifications.py b/miasm2/expression/simplifications.py index 2807b4b3..b30ee1d0 100644 --- a/miasm2/expression/simplifications.py +++ b/miasm2/expression/simplifications.py @@ -46,6 +46,7 @@ class ExpressionSimplifier(object): simplifications_common.simp_double_signext, simplifications_common.simp_zeroext_eq_cst, + simplifications_common.simp_cmp_int, simplifications_common.simp_cmp_int_int, simplifications_common.simp_ext_cst, @@ -60,7 +61,6 @@ class ExpressionSimplifier(object): simplifications_common.simp_cond, # CC op simplifications_common.simp_cond_flag, - simplifications_common.simp_cond_int, simplifications_common.simp_cmp_int_arg, simplifications_common.simp_cond_eq_zero, diff --git a/miasm2/expression/simplifications_common.py b/miasm2/expression/simplifications_common.py index 676501a0..9c002fa5 100644 --- a/miasm2/expression/simplifications_common.py +++ b/miasm2/expression/simplifications_common.py @@ -884,37 +884,34 @@ def simp_cond_flag(expr_simp, expr): return expr -def simp_cond_int(expr_simp, expr): +def simp_cmp_int(expr_simp, expr): # ({X, 0} == int) => X == int[:] # X + int1 == int2 => X == int2-int1 - if (expr.cond.is_op(TOK_EQUAL) and - expr.cond.args[1].is_int() and - expr.cond.args[0].is_compose() and - len(expr.cond.args[0].args) == 2 and - expr.cond.args[0].args[1].is_int(0)): + if (expr.is_op(TOK_EQUAL) and + expr.args[1].is_int() and + expr.args[0].is_compose() and + len(expr.args[0].args) == 2 and + expr.args[0].args[1].is_int(0)): # ({X, 0} == int) => X == int[:] - src = expr.cond.args[0].args[0] - int_val = int(expr.cond.args[1]) + src = expr.args[0].args[0] + int_val = int(expr.args[1]) new_int = ExprInt(int_val, src.size) expr = expr_simp( - ExprCond( - ExprOp(TOK_EQUAL, src, new_int), - expr.src1, - expr.src2) + ExprOp(TOK_EQUAL, src, new_int) ) - elif (expr.cond.is_op() and - expr.cond.op in [ + elif (expr.is_op() and + expr.op in [ TOK_EQUAL, ] and - expr.cond.args[1].is_int() and - expr.cond.args[0].is_op("+") and - expr.cond.args[0].args[-1].is_int()): + expr.args[1].is_int() and + expr.args[0].is_op("+") and + expr.args[0].args[-1].is_int()): # X + int1 == int2 => X == int2-int1 # WARNING: # X - 0x10 <=u 0x20 gives X in [0x10 0x30] # which is not equivalet to A <=u 0x10 - left, right = expr.cond.args + left, right = expr.args left, int_diff = left.args[:-1], left.args[-1] if len(left) == 1: left = left[0] @@ -922,10 +919,7 @@ def simp_cond_int(expr_simp, expr): left = ExprOp('+', *left) new_int = expr_simp(right - int_diff) expr = expr_simp( - ExprCond( - ExprOp(expr.cond.op, left, new_int), - expr.src1, - expr.src2) + ExprOp(expr.op, left, new_int), ) return expr -- cgit 1.4.1 From 3877d4db136e124973c59d66b106ebe80ce4f732 Mon Sep 17 00:00:00 2001 From: Fabrice Desclaux Date: Tue, 9 Oct 2018 18:40:07 +0200 Subject: Simplification: add high evel simp --- miasm2/expression/simplifications.py | 1 + miasm2/expression/simplifications_common.py | 14 ++++++++++++++ test/expression/simplifications.py | 3 +++ 3 files changed, 18 insertions(+) (limited to 'miasm2/expression/simplifications_common.py') diff --git a/miasm2/expression/simplifications.py b/miasm2/expression/simplifications.py index b30ee1d0..a5978fbb 100644 --- a/miasm2/expression/simplifications.py +++ b/miasm2/expression/simplifications.py @@ -45,6 +45,7 @@ class ExpressionSimplifier(object): simplifications_common.simp_double_zeroext, simplifications_common.simp_double_signext, simplifications_common.simp_zeroext_eq_cst, + simplifications_common.simp_ext_eq_ext, simplifications_common.simp_cmp_int, simplifications_common.simp_cmp_int_int, diff --git a/miasm2/expression/simplifications_common.py b/miasm2/expression/simplifications_common.py index 9c002fa5..1ebd4878 100644 --- a/miasm2/expression/simplifications_common.py +++ b/miasm2/expression/simplifications_common.py @@ -1043,6 +1043,20 @@ def simp_zeroext_eq_cst(expr_s, expr): return ExprInt(0, 1) return ExprOp(TOK_EQUAL, src, ExprInt(int(arg2), src.size)) +def simp_ext_eq_ext(expr_s, expr): + # A.zeroExt(X) == B.zeroExt(X) => A == B + # A.signExt(X) == B.signExt(X) => A == B + if not expr.is_op(TOK_EQUAL): + return expr + arg1, arg2 = expr.args + if (not ((arg1.is_op() and arg1.op.startswith("zeroExt") and + arg2.is_op() and arg2.op.startswith("zeroExt")) or + (arg1.is_op() and arg1.op.startswith("signExt") and + arg2.is_op() and arg2.op.startswith("signExt")))): + return expr + if arg1.args[0].size != arg2.args[0].size: + return expr + return ExprOp(TOK_EQUAL, arg1.args[0], arg2.args[0]) def simp_cond_eq_zero(expr_s, expr): # (X == 0)?(A:B) => X?(B:A) diff --git a/test/expression/simplifications.py b/test/expression/simplifications.py index 8f9656d4..741d6adb 100644 --- a/test/expression/simplifications.py +++ b/test/expression/simplifications.py @@ -495,6 +495,9 @@ to_test = [ (ExprOp(TOK_INF_EQUAL_SIGNED, i1, im1), ExprInt(0, 1)), (ExprOp(TOK_INF_EQUAL_UNSIGNED, i1, im1), ExprInt(1, 1)), + (ExprOp(TOK_EQUAL, a8.zeroExtend(32), b8.zeroExtend(32)), ExprOp(TOK_EQUAL, a8, b8)), + (ExprOp(TOK_EQUAL, a8.signExtend(32), b8.signExtend(32)), ExprOp(TOK_EQUAL, a8, b8)), + ] for e_input, e_check in to_test: -- cgit 1.4.1