ExprCompose: update api

6 files changed, 69 insertions, 47 deletions

diff --git a/miasm2/core/sembuilder.py b/miasm2/core/sembuilder.py
index 27401049..6ff390bb 100644
--- a/miasm2/core/sembuilder.py
+++ b/miasm2/core/sembuilder.py
@@ -95,27 +95,16 @@ class MiasmTransformer(ast.NodeTransformer):
         return call
 
     def visit_Set(self, node):
-        "{a, b} -> ExprCompose([(a, 0, a.size)], (b, a.size, a.size + b.size)])"
+        "{a, b} -> ExprCompose(a, b)"
         if len(node.elts) == 0:
             return node
 
         # Recursive visit
         node = self.generic_visit(node)
 
-        new_elts = []
-        index = ast.Num(n=0)
-        for elt in node.elts:
-            new_index = ast.BinOp(op=ast.Add(), left=index,
-                                  right=ast.Attribute(value=elt,
-                                                      attr='size',
-                                                      ctx=ast.Load()))
-            new_elts.append(ast.Tuple(elts=[elt, index, new_index],
-                                     ctx=ast.Load()))
-            index = new_index
         return ast.Call(func=ast.Name(id='ExprCompose',
                                       ctx=ast.Load()),
-                               args=[ast.List(elts=new_elts,
-                                              ctx=ast.Load())],
+                               args=node.elts,
                                keywords=[],
                                starargs=None,
                                kwargs=None)
diff --git a/miasm2/expression/expression.py b/miasm2/expression/expression.py
index d18bc751..cb9f6114 100644
--- a/miasm2/expression/expression.py
+++ b/miasm2/expression/expression.py
@@ -289,7 +289,10 @@ class Expr(object):
                 else:
                     new_e = e
             elif isinstance(e, ExprCompose):
-                new_e = ExprCompose(canonize_expr_list_compose(e.args))
+                starts = [start for (_, start, _) in e.args]
+                assert sorted(starts) == starts
+                assert len(set(starts)) == len(starts)
+                new_e = e
             else:
                 new_e = e
             new_e.is_canon = True
@@ -311,8 +314,7 @@ class Expr(object):
             return self
         ad_size = size - self.size
         n = ExprInt(0, ad_size)
-        return ExprCompose([(self, 0, self.size),
-                            (n, self.size, size)])
+        return ExprCompose(self, n)
 
     def signExtend(self, size):
         """Sign extend to size
@@ -542,7 +544,8 @@ class ExprAff(Expr):
                     for r in dst.slice_rest()]
             all_a = [(src, dst.start, dst.stop)] + rest
             all_a.sort(key=lambda x: x[1])
-            self.__src = ExprCompose(all_a)
+            args = [expr for (expr, _, _) in all_a]
+            self.__src = ExprCompose(*args)
 
         else:
             self.__dst, self.__src = dst, src
@@ -1078,6 +1081,8 @@ class ExprCompose(Expr):
                 index += arg.size
             args = new_args
         else:
+            warnings.warn('DEPRECATION WARNING: use "ExprCompose(a, b) instead of'+
+                          'ExprCemul_ir_block(self, addr, step=False)" instead of emul_ir_bloc')
             assert len(args) == 1
             args = args[0]
 
@@ -1153,12 +1158,13 @@ class ExprCompose(Expr):
         args = [(arg[0].visit(cb, tv), arg[1], arg[2]) for arg in self.__args]
         modified = any([arg[0] != arg[1] for arg in zip(self.__args, args)])
         if modified:
-            return ExprCompose(args)
+            args = [expr for (expr, _, _) in args]
+            return ExprCompose(*args)
         return self
 
     def copy(self):
-        args = [(arg[0].copy(), arg[1], arg[2]) for arg in self.__args]
-        return ExprCompose(args)
+        args = [arg[0].copy() for arg in self.__args]
+        return ExprCompose(*args)
 
     def depth(self):
         depth = [arg[0].depth() for arg in self.__args]
diff --git a/miasm2/expression/expression_helper.py b/miasm2/expression/expression_helper.py
index 178ee25f..e9176658 100644
--- a/miasm2/expression/expression_helper.py
+++ b/miasm2/expression/expression_helper.py
@@ -449,21 +449,19 @@ class ExprRandom(object):
         """
         # First layer
         upper_bound = random.randint(1, size)
-        args = [(cls._gen(size=upper_bound, depth=depth - 1), 0, upper_bound)]
+        args = [cls._gen(size=upper_bound, depth=depth - 1)]
 
         # Next layers
         while (upper_bound < size):
             if len(args) == (cls.compose_max_layer - 1):
                 # We reach the maximum size
-                upper_bound = size
+                new_upper_bound = size
             else:
-                upper_bound = random.randint(args[-1][-1] + 1, size)
+                new_upper_bound = random.randint(upper_bound + 1, size)
 
-            args.append((cls._gen(size=upper_bound - args[-1][-1]),
-                         args[-1][-1],
-                         upper_bound))
-
-        return m2_expr.ExprCompose(args)
+            args.append(cls._gen(size=new_upper_bound - upper_bound))
+            upper_bound = new_upper_bound
+        return m2_expr.ExprCompose(*args)
 
     @classmethod
     def memory(cls, size=32, depth=1):
@@ -656,14 +654,10 @@ def possible_values(expr):
             args_constraint = itertools.chain(*[consval[0].constraints
                                                 for consval in consvals_possibility])
             # Gen the corresponding constraints / ExprCompose
+            args = [consval[0].value for consval in consvals_possibility]
             consvals.add(
                 ConstrainedValue(frozenset(args_constraint),
-                                 m2_expr.ExprCompose(
-                                     [(consval[0].value,
-                                       consval[1],
-                                       consval[2])
-                                      for consval in consvals_possibility]
-                )))
+                                 m2_expr.ExprCompose(*args)))
     else:
         raise RuntimeError("Unsupported type for expr: %s" % type(expr))
 
diff --git a/miasm2/expression/simplifications_common.py b/miasm2/expression/simplifications_common.py
index 49dfbcc0..4b88f8c2 100644
--- a/miasm2/expression/simplifications_common.py
+++ b/miasm2/expression/simplifications_common.py
@@ -286,7 +286,11 @@ def simp_cst_propagation(e_s, e):
         # create entry 0
         expr = ExprInt(0, min_index)
         filter_args = [(expr, 0, min_index)] + filter_args
-        return ExprCompose(filter_args)
+        filter_args.sort(key=lambda x:x[1])
+        starts = [start for (_, start, _) in filter_args]
+        assert len(set(starts)) == len(starts)
+        args = [expr for (expr, _, _) in filter_args]
+        return ExprCompose(*args)
 
     # A >> int with A ExprCompose => move index
     if op == ">>" and isinstance(args[0], ExprCompose) and isinstance(args[1], ExprInt):
@@ -310,7 +314,11 @@ def simp_cst_propagation(e_s, e):
         # create entry 0
         expr = ExprInt(0, final_size - max_index)
         filter_args += [(expr, max_index, final_size)]
-        return ExprCompose(filter_args)
+        filter_args.sort(key=lambda x:x[1])
+        starts = [start for (_, start, _) in filter_args]
+        assert len(set(starts)) == len(starts)
+        args = [expr for (expr, _, _) in filter_args]
+        return ExprCompose(*args)
 
 
     # Compose(a) OP Compose(b) with a/b same bounds => Compose(a OP b)
@@ -327,7 +335,13 @@ def simp_cst_propagation(e_s, e):
                     new_args[i].append(expr)
             for i, arg in enumerate(new_args):
                 new_args[i] = ExprOp(op, *arg), bound[i][0], bound[i][1]
-            return ExprCompose(new_args)
+
+            new_args.sort(key=lambda x:x[1])
+            starts = [start for (_, start, _) in new_args]
+            assert len(set(starts)) == len(starts)
+            args = [expr for (expr, _, _) in new_args]
+
+            return ExprCompose(*args)
 
     # <<<c_rez, >>>c_rez
     if op in [">>>c_rez", "<<<c_rez"]:
@@ -481,7 +495,13 @@ def simp_slice(e_s, e):
                 slice_stop = arg.size
                 a_stop = s_stop - e.start
             out.append((arg[slice_start:slice_stop], a_start, a_stop))
-        return ExprCompose(out)
+
+        out.sort(key=lambda x:x[1])
+        starts = [start for (_, start, _) in out]
+        assert len(set(starts)) == len(starts)
+        args = [expr for (expr, _, _) in out]
+
+        return ExprCompose(*args)
 
     # ExprMem(x, size)[:A] => ExprMem(x, a)
     # XXXX todo hum, is it safe?
@@ -590,11 +610,15 @@ def simp_compose(e_s, e):
             else:
                 src1.append(a)
                 src2.append(a)
-        src1 = e_s.apply_simp(ExprCompose(src1))
-        src2 = e_s.apply_simp(ExprCompose(src2))
+        src1 = [expr for (expr, _, _) in src1]
+        src2 = [expr for (expr, _, _) in src2]
+        src1 = e_s.apply_simp(ExprCompose(*src1))
+        src2 = e_s.apply_simp(ExprCompose(*src2))
         if isinstance(src1, ExprInt) and isinstance(src2, ExprInt):
             return ExprCond(cond.cond, src1, src2)
-    return ExprCompose(args)
+    args.sort(key=lambda x:x[1])
+    args = [expr for (expr, _, _) in args]
+    return ExprCompose(*args)
 
 
 def simp_cond(e_s, e):
diff --git a/miasm2/ir/ir.py b/miasm2/ir/ir.py
index 3a841fa5..2c6300a9 100644
--- a/miasm2/ir/ir.py
+++ b/miasm2/ir/ir.py
@@ -59,7 +59,8 @@ class AssignBlock(dict):
                     for r in dst.slice_rest()]
             all_a = [(src, dst.start, dst.stop)] + rest
             all_a.sort(key=lambda x: x[1])
-            new_src = m2_expr.ExprCompose(all_a)
+            args = [expr for (expr, _, _) in all_a]
+            new_src = m2_expr.ExprCompose(*args)
         else:
             new_dst, new_src = dst, src
 
@@ -95,7 +96,12 @@ class AssignBlock(dict):
                          for interval in missing_i)
 
             # Build the merging expression
-            new_src = m2_expr.ExprCompose(e_colision.union(remaining))
+            args = list(e_colision.union(remaining))
+            args.sort(key=lambda x:x[1])
+            starts = [start for (_, start, _) in args]
+            assert len(set(starts)) == len(starts)
+            args = [expr for (expr, _, _) in args]
+            new_src = m2_expr.ExprCompose(*args)
 
         super(AssignBlock, self).__setitem__(new_dst, new_src)
 
diff --git a/miasm2/ir/symbexec.py b/miasm2/ir/symbexec.py
index 2a0b19ca..65515c64 100644
--- a/miasm2/ir/symbexec.py
+++ b/miasm2/ir/symbexec.py
@@ -148,7 +148,8 @@ class symbexec(object):
                     mem = m2_expr.ExprMem(ptr, slice_stop - slice_start)
                     out.append((mem, slice_start, slice_stop))
                 out.sort(key=lambda x: x[1])
-                tmp = m2_expr.ExprSlice(m2_expr.ExprCompose(out), 0, size)
+                args = [expr for (expr, _, _) in out]
+                tmp = m2_expr.ExprSlice(m2_expr.ExprCompose(*args), 0, size)
                 tmp = self.expr_simp(tmp)
                 return tmp
 
@@ -179,7 +180,9 @@ class symbexec(object):
                 ptr_index += diff_size
                 rest -= diff_size
                 ptr = self.expr_simp(ptr + m2_expr.ExprInt(mem.size / 8, ptr.size))
-            ret = self.expr_simp(m2_expr.ExprCompose(out))
+            out.sort(key=lambda x: x[1])
+            args = [expr for (expr, _, _) in out]
+            ret = self.expr_simp(m2_expr.ExprCompose(*args))
             return ret
         # part lookup
         ret = self.expr_simp(self.symbols[ret][:size])
@@ -228,8 +231,8 @@ class symbexec(object):
             args = []
             for (arg, start, stop) in expr.args:
                 arg = self.apply_expr_on_state_visit_cache(arg, state, cache, level+1)
-                args.append((arg, start, stop))
-            ret = m2_expr.ExprCompose(args)
+                args.append(arg)
+            ret = m2_expr.ExprCompose(*args)
         else:
             raise TypeError("Unknown expr type")
         #print '\t'*level, "Result", ret