about summary refs log tree commit diff stats
path: root/example/expression
diff options
context:
space:
mode:
Diffstat (limited to 'example/expression')
-rw-r--r--example/expression/access_c.py27
-rw-r--r--example/expression/asm_to_ir.py21
-rw-r--r--example/expression/basic_op.py15
-rw-r--r--example/expression/basic_simplification.py11
-rw-r--r--example/expression/constant_propagation.py2
-rw-r--r--example/expression/export_llvm.py16
-rw-r--r--example/expression/expr_c.py7
-rw-r--r--example/expression/expr_grapher.py14
-rw-r--r--example/expression/expr_random.py26
-rw-r--r--example/expression/expr_translate.py27
-rw-r--r--example/expression/get_read_write.py22
-rw-r--r--example/expression/graph_dataflow.py45
-rw-r--r--example/expression/simplification_add.py13
-rw-r--r--example/expression/simplification_tools.py35
-rw-r--r--example/expression/solve_condition_stp.py39
15 files changed, 174 insertions, 146 deletions
diff --git a/example/expression/access_c.py b/example/expression/access_c.py
index b23ba81b..c6f26a10 100644
--- a/example/expression/access_c.py
+++ b/example/expression/access_c.py
@@ -39,10 +39,12 @@ Then, in the C generator:
 ExprCompose(var1, 0) => var1
 
 """
-
+from __future__ import print_function
 
 import sys
 
+from future.utils import viewitems, viewvalues
+
 from miasm2.analysis.machine import Machine
 from miasm2.analysis.binary import Container
 from miasm2.expression.expression import ExprOp, ExprCompose, ExprId, ExprInt
@@ -57,21 +59,21 @@ from miasm2.core.ctypesmngr import CAstTypes, CTypePtr, CTypeStruct
 def find_call(ircfg):
     """Returns (irb, index) which call"""
 
-    for irb in ircfg.blocks.values():
+    for irb in viewvalues(ircfg.blocks):
         out = set()
         if len(irb) < 2:
             continue
         assignblk = irb[-2]
-        for src in assignblk.itervalues():
+        for src in viewvalues(assignblk):
             if not isinstance(src, ExprOp):
                 continue
             if not src.op.startswith('call_func'):
                 continue
-            out.add((irb, len(irb) - 2))
+            out.add((irb.loc_key, len(irb) - 2))
         if len(out) != 1:
             continue
-        irb, index = out.pop()
-        yield irb, index
+        loc_key, index = out.pop()
+        yield loc_key, index
 
 
 class MyExprToAccessC(ExprToAccessC):
@@ -96,9 +98,10 @@ def get_funcs_arg0(ctx, ira, ircfg, lbl_head):
     g_dep = DependencyGraph(ircfg, follow_call=False)
     element = ira.arch.regs.RSI
 
-    for irb, index in find_call(ircfg):
+    for loc_key, index in find_call(ircfg):
+        irb = ircfg.get_block(loc_key)
         instr = irb[index].instr
-        print 'Analysing references from:', hex(instr.offset), instr
+        print('Analysing references from:', hex(instr.offset), instr)
         g_list = g_dep.get(irb.loc_key, set([element]), index, set([lbl_head]))
         for dep in g_list:
             emul_result = dep.emul(ira, ctx)
@@ -113,7 +116,7 @@ class MyCHandler(CHandler):
 
 
 
-data = open(sys.argv[1]).read()
+data = open(sys.argv[1], 'rb').read()
 # Digest C information
 text = """
 struct human {
@@ -160,7 +163,7 @@ expr_types = {arg0: (ptr_llhuman,),
 mychandler = MyCHandler(types_mngr, expr_types)
 
 for expr in get_funcs_arg0(ctx, ir_arch_a, ircfg, lbl_head):
-    print "Access:", expr
+    print("Access:", expr)
     for c_str, ctype in mychandler.expr_to_c_and_types(expr):
-        print '\taccess:', c_str
-        print '\tc type:', ctype
+        print('\taccess:', c_str)
+        print('\tc type:', ctype)
diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py
index 7036d960..16f766e1 100644
--- a/example/expression/asm_to_ir.py
+++ b/example/expression/asm_to_ir.py
@@ -1,5 +1,8 @@
+from __future__ import print_function
 from pdb import pm
 
+from future.utils import viewitems
+
 from miasm2.arch.x86.arch import mn_x86
 from miasm2.core import parse_asm
 from miasm2.expression.expression import *
@@ -27,11 +30,11 @@ loop:
 
 loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0)
 for block in asmcfg.blocks:
-    print block
+    print(block)
 
 
-print "symbols:"
-print loc_db
+print("symbols:")
+print(loc_db)
 patches = asmblock.asm_resolve_final(mn_x86, asmcfg, loc_db)
 
 # Translate to IR
@@ -39,16 +42,16 @@ ir_arch = ir_a_x86_32(loc_db)
 ircfg = ir_arch.new_ircfg_from_asmcfg(asmcfg)
 
 # Display IR
-for lbl, irblock in ircfg.blocks.items():
-    print irblock
+for lbl, irblock in viewitems(ircfg.blocks):
+    print(irblock)
 
 # Dead propagation
 open('graph.dot', 'w').write(ircfg.dot())
-print '*' * 80
+print('*' * 80)
 dead_simp(ir_arch, ircfg)
 open('graph2.dot', 'w').write(ircfg.dot())
 
 # Display new IR
-print 'new ir blocks'
-for lbl, irblock in ircfg.blocks.items():
-    print irblock
+print('new ir blocks')
+for lbl, irblock in viewitems(ircfg.blocks):
+    print(irblock)
diff --git a/example/expression/basic_op.py b/example/expression/basic_op.py
index 6032f483..8b5d7e2b 100644
--- a/example/expression/basic_op.py
+++ b/example/expression/basic_op.py
@@ -1,31 +1,32 @@
+from __future__ import print_function
 from miasm2.expression.expression import *
 
-print """
+print("""
 Simple expression manipulation demo
-"""
+""")
 
 # define 2 ID
 a = ExprId('eax', 32)
 b = ExprId('ebx', 32)
-print a, b
+print(a, b)
 # eax ebx
 
 # add those ID
 c = ExprOp('+', a, b)
-print c
+print(c)
 # (eax + ebx)
 
 # + automatically generates ExprOp('+', a, b)
 c = a + b
-print c
+print(c)
 # (eax + ebx)
 
 # ax is a slice of eax
 ax = a[:16]
-print ax
+print(ax)
 # eax[0:16]
 
 # memory deref
 d = ExprMem(c, 32)
-print d
+print(d)
 # @32[(eax + ebx)]
diff --git a/example/expression/basic_simplification.py b/example/expression/basic_simplification.py
index eefdc765..5ecf21db 100644
--- a/example/expression/basic_simplification.py
+++ b/example/expression/basic_simplification.py
@@ -1,9 +1,10 @@
+from __future__ import print_function
 from miasm2.expression.expression import *
 from miasm2.expression.simplifications import expr_simp
 
-print """
+print("""
 Simple expression simplification demo
-"""
+""")
 
 
 a = ExprId('eax', 32)
@@ -14,6 +15,6 @@ exprs = [a + b - a,
          ExprCompose(a[:8], a[8:16])]
 
 for e in exprs:
-    print '*' * 40
-    print 'original expression:', e
-    print "simplified:", expr_simp(e)
+    print('*' * 40)
+    print('original expression:', e)
+    print("simplified:", expr_simp(e))
diff --git a/example/expression/constant_propagation.py b/example/expression/constant_propagation.py
index e70f8163..1259758b 100644
--- a/example/expression/constant_propagation.py
+++ b/example/expression/constant_propagation.py
@@ -25,7 +25,7 @@ args = parser.parse_args()
 
 machine = Machine("x86_32")
 
-cont = Container.from_stream(open(args.filename))
+cont = Container.from_stream(open(args.filename, 'rb'))
 mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db)
 ir_arch = machine.ira(mdis.loc_db)
 addr = int(args.address, 0)
diff --git a/example/expression/export_llvm.py b/example/expression/export_llvm.py
index a0af66b7..c8ee14a5 100644
--- a/example/expression/export_llvm.py
+++ b/example/expression/export_llvm.py
@@ -1,3 +1,5 @@
+from future.utils import viewitems, viewvalues
+
 from argparse import ArgumentParser
 from miasm2.analysis.binary import Container
 from miasm2.analysis.machine import Machine
@@ -12,7 +14,7 @@ parser.add_argument("--architecture", "-a", help="Force architecture")
 args = parser.parse_args()
 
 # This part focus on obtaining an IRCFG to transform #
-cont = Container.from_stream(open(args.target))
+cont = Container.from_stream(open(args.target, 'rb'))
 machine = Machine(args.architecture if args.architecture else cont.arch)
 ir = machine.ir(cont.loc_db)
 dis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db)
@@ -47,12 +49,14 @@ func.init_fc()
 #     ...
 
 all_regs = set()
-for block in ircfg.blocks.itervalues():
+for block in viewvalues(ircfg.blocks):
     for irs in block.assignblks:
-        for dst, src in irs.get_rw(mem_read=True).iteritems():
+        for dst, src in viewitems(irs.get_rw(mem_read=True)):
             elem = src.union(set([dst]))
-            all_regs.update(x for x in elem
-                            if x.is_id())
+            all_regs.update(
+                x for x in elem
+                if x.is_id()
+            )
 
 reg2glob = {}
 for var in all_regs:
@@ -70,7 +74,7 @@ for var in all_regs:
 func.from_ircfg(ircfg, append_ret=False)
 
 # Finish the saving of registers (temporary version to global)
-for reg, glob in reg2glob.iteritems():
+for reg, glob in viewitems(reg2glob):
     value = func.builder.load(func.local_vars_pointers[reg.name])
     func.builder.store(value, glob)
 
diff --git a/example/expression/expr_c.py b/example/expression/expr_c.py
index 37c9f510..83cc727b 100644
--- a/example/expression/expr_c.py
+++ b/example/expression/expr_c.py
@@ -3,6 +3,7 @@ Parse C expression to access variables and retrieve information:
 * Miasm expression to access this variable
 * variable type
 """
+from __future__ import print_function
 
 from miasm2.core.ctypesmngr import CTypeStruct, CAstTypes, CTypePtr
 from miasm2.arch.x86.ctype import CTypeAMD64_unk
@@ -56,6 +57,6 @@ c_acceses = ["ptr->width",
 for c_str in c_acceses:
     expr = mychandler.c_to_expr(c_str)
     c_type = mychandler.c_to_type(c_str)
-    print 'C access:', c_str
-    print '\tExpr:', expr
-    print '\tType:', c_type
+    print('C access:', c_str)
+    print('\tExpr:', expr)
+    print('\tType:', c_type)
diff --git a/example/expression/expr_grapher.py b/example/expression/expr_grapher.py
index e0562852..e1643b03 100644
--- a/example/expression/expr_grapher.py
+++ b/example/expression/expr_grapher.py
@@ -1,6 +1,8 @@
+from __future__ import print_function
+
 from miasm2.expression.expression import *
 
-print "Simple Expression grapher demo"
+print("Simple Expression grapher demo")
 
 a = ExprId("A", 32)
 b = ExprId("B", 32)
@@ -8,13 +10,13 @@ c = ExprId("C", 32)
 d = ExprId("D", 32)
 m = ExprMem(a + b + c + a, 32)
 
-e1 = ExprCompose(a + b - (c * a) / m | b, a + m)
+e1 = ExprCompose(a + b - ((c * a) // m) | b, a + m)
 e2 = ExprInt(15, 64)
 e = ExprCond(d, e1, e2)[0:32]
 
-print "[+] Expression:"
-print e
+print("[+] Expression:")
+print(e)
 
 g = e.graph()
-print "[+] Graph:"
-print g.dot()
+print("[+] Graph:")
+print(g.dot())
diff --git a/example/expression/expr_random.py b/example/expression/expr_random.py
index 66c09f2e..5ac3be06 100644
--- a/example/expression/expr_random.py
+++ b/example/expression/expr_random.py
@@ -1,22 +1,24 @@
+from __future__ import print_function
+from builtins import range
 import string
 import random
 
 from miasm2.expression.expression_helper import ExprRandom
 
-print "Simple expression generator\n"
+print("Simple expression generator\n")
 
 depth = 8
 seed = 0
 random.seed(seed)
 
-print "- An ID:"
-print ExprRandom.identifier()
-print "- A number:"
-print ExprRandom.number()
+print("- An ID:")
+print(ExprRandom.identifier())
+print("- A number:")
+print(ExprRandom.number())
 
-print "- 3 expressions (without cleaning expression cache):"
-for i in xrange(3):
-    print "\t%s\n" % ExprRandom.get(depth=depth, clean=False)
+print("- 3 expressions (without cleaning expression cache):")
+for i in range(3):
+    print("\t%s\n" % ExprRandom.get(depth=depth, clean=False))
 
 class ExprRandom_NoPerfect_NoReuse_UppercaseIdent(ExprRandom):
     """ExprRandom extension with:
@@ -27,8 +29,8 @@ class ExprRandom_NoPerfect_NoReuse_UppercaseIdent(ExprRandom):
 
     perfect_tree = False
     reuse_element = False
-    identifier_charset = string.uppercase
+    identifier_charset = string.ascii_uppercase
 
-print "- 3 expressions with a custom generator:"
-for i in xrange(3):
-    print "\t%s\n" % ExprRandom_NoPerfect_NoReuse_UppercaseIdent.get(depth=depth)
+print("- 3 expressions with a custom generator:")
+for i in range(3):
+    print("\t%s\n" % ExprRandom_NoPerfect_NoReuse_UppercaseIdent.get(depth=depth))
diff --git a/example/expression/expr_translate.py b/example/expression/expr_translate.py
index e1505dae..1a36a64c 100644
--- a/example/expression/expr_translate.py
+++ b/example/expression/expr_translate.py
@@ -1,5 +1,8 @@
+from __future__ import print_function
 import random
 
+from future.utils import viewitems
+
 from miasm2.expression.expression import *
 from miasm2.expression.expression_helper import ExprRandom
 from miasm2.ir.translators import Translator
@@ -13,32 +16,32 @@ class ExprRandom_OpSubRange(ExprRandom):
                                  }
 
 
-print "[+] Compute a random expression:"
+print("[+] Compute a random expression:")
 expr = ExprRandom_OpSubRange.get(depth=8)
-print "-> %s" % expr
-print
+print("-> %s" % expr)
+print()
 
 target_exprs = {lang:Translator.to_language(lang).from_expr(expr)
                 for lang in Translator.available_languages()}
-for target_lang, target_expr in target_exprs.iteritems():
-    print "[+] Translate in %s:" % target_lang
-    print target_expr
-    print
+for target_lang, target_expr in viewitems(target_exprs):
+    print("[+] Translate in %s:" % target_lang)
+    print(target_expr)
+    print()
 
-print "[+] Eval in Python:"
+print("[+] Eval in Python:")
 def memory(addr, size):
     ret = random.randint(0, (1 << size) - 1)
-    print "Memory access: @0x%x -> 0x%x" % (addr, ret)
+    print("Memory access: @0x%x -> 0x%x" % (addr, ret))
     return ret
 
 for expr_id in expr.get_r(mem_read=True):
     if isinstance(expr_id, ExprId):
         value = random.randint(0, (1 << expr_id.size) - 1)
-        print "Declare var: %s = 0x%x" % (expr_id.name, value)
+        print("Declare var: %s = 0x%x" % (expr_id.name, value))
         globals()[expr_id.name] = value
 
-print "-> 0x%x" % eval(target_exprs["Python"])
+print("-> 0x%x" % eval(target_exprs["Python"]))
 
-print "[+] Validate the Miasm syntax rebuilding"
+print("[+] Validate the Miasm syntax rebuilding")
 exprRebuild = eval(target_exprs["Miasm"])
 assert(expr == exprRebuild)
diff --git a/example/expression/get_read_write.py b/example/expression/get_read_write.py
index 34d0f94a..0c8bb3dd 100644
--- a/example/expression/get_read_write.py
+++ b/example/expression/get_read_write.py
@@ -1,3 +1,7 @@
+from __future__ import print_function
+
+from future.utils import viewitems
+
 from miasm2.arch.x86.arch import mn_x86
 from miasm2.expression.expression import get_rw
 from miasm2.arch.x86.ira import ir_a_x86_32
@@ -6,10 +10,10 @@ from miasm2.core.locationdb import LocationDB
 loc_db = LocationDB()
 
 
-print """
+print("""
 Simple expression manipulation demo.
 Get read/written registers for a given instruction
-"""
+""")
 
 arch = mn_x86
 ir_arch = ir_a_x86_32(loc_db)
@@ -18,14 +22,14 @@ instr = arch.fromstring('LODSB', loc_db, 32)
 instr.offset, instr.l = 0, 15
 ir_arch.add_instr_to_ircfg(instr, ircfg)
 
-print '*' * 80
-for lbl, irblock in ircfg.blocks.iteritems():
-    print irblock
+print('*' * 80)
+for lbl, irblock in viewitems(ircfg.blocks):
+    print(irblock)
     for assignblk in irblock:
         rw = assignblk.get_rw()
-        for dst, reads in rw.iteritems():
-            print 'read:   ', [str(x) for x in reads]
-            print 'written:', dst
-            print
+        for dst, reads in viewitems(rw):
+            print('read:   ', [str(x) for x in reads])
+            print('written:', dst)
+            print()
 
 open('graph_instr.dot', 'w').write(ircfg.dot())
diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py
index 92bcf249..55159598 100644
--- a/example/expression/graph_dataflow.py
+++ b/example/expression/graph_dataflow.py
@@ -1,5 +1,8 @@
+from __future__ import print_function
 from argparse import ArgumentParser
 
+from future.utils import viewitems, viewvalues
+
 from miasm2.analysis.binary import Container
 from miasm2.analysis.machine import Machine
 from miasm2.expression.expression import get_expr_mem
@@ -17,10 +20,6 @@ parser.add_argument("-s", "--symb", help="Symbolic execution mode",
 args = parser.parse_args()
 
 
-def node_x_2_id(n, x):
-    return hash(str(n) + str(x)) & 0xffffffffffffffff
-
-
 def get_node_name(label, i, n):
     n_name = (label, i, n)
     return n_name
@@ -30,8 +29,8 @@ def intra_block_flow_symb(ir_arch, _, flow_graph, irblock, in_nodes, out_nodes):
     symbols_init = ir_arch.arch.regs.regs_init.copy()
     sb = SymbolicExecutionEngine(ir_arch, symbols_init)
     sb.eval_updt_irblock(irblock)
-    print '*' * 40
-    print irblock
+    print('*' * 40)
+    print(irblock)
 
 
     out = sb.modified(mems=False)
@@ -86,14 +85,14 @@ def node2str(node):
 
 
 def gen_block_data_flow_graph(ir_arch, ircfg, ad, block_flow_cb):
-    for irblock in ircfg.blocks.values():
-        print irblock
+    for irblock in viewvalues(ircfg.blocks):
+        print(irblock)
 
     dead_simp(ir_arch, ircfg)
 
 
     irblock_0 = None
-    for irblock in ircfg.blocks.values():
+    for irblock in viewvalues(ircfg.blocks):
         loc_key = irblock.loc_key
         offset = ircfg.loc_db.get_location_offset(loc_key)
         if offset == ad:
@@ -110,15 +109,15 @@ def gen_block_data_flow_graph(ir_arch, ircfg, ad, block_flow_cb):
         irb_in_nodes[label] = {}
         irb_out_nodes[label] = {}
 
-    for label, irblock in ircfg.blocks.iteritems():
+    for label, irblock in viewitems(ircfg.blocks):
         block_flow_cb(ir_arch, ircfg, flow_graph, irblock, irb_in_nodes[label], irb_out_nodes[label])
 
     for label in ircfg.blocks:
-        print label
-        print 'IN', [str(x) for x in irb_in_nodes[label]]
-        print 'OUT', [str(x) for x in irb_out_nodes[label]]
+        print(label)
+        print('IN', [str(x) for x in irb_in_nodes[label]])
+        print('OUT', [str(x) for x in irb_out_nodes[label]])
 
-    print '*' * 20, 'interblock', '*' * 20
+    print('*' * 20, 'interblock', '*' * 20)
     inter_block_flow(ir_arch, ircfg, flow_graph, irblock_0.loc_key, irb_in_nodes, irb_out_nodes)
 
     # from graph_qt import graph_qt
@@ -128,22 +127,22 @@ def gen_block_data_flow_graph(ir_arch, ircfg, ad, block_flow_cb):
 
 ad = int(args.addr, 16)
 
-print 'disasm...'
-cont = Container.from_stream(open(args.filename))
+print('disasm...')
+cont = Container.from_stream(open(args.filename, 'rb'))
 machine = Machine("x86_32")
 
 mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db)
 mdis.follow_call = True
 asmcfg = mdis.dis_multiblock(ad)
-print 'ok'
+print('ok')
 
 
-print 'generating dataflow graph for:'
+print('generating dataflow graph for:')
 ir_arch_analysis = machine.ira(mdis.loc_db)
 ircfg = ir_arch_analysis.new_ircfg_from_asmcfg(asmcfg)
 
-for irblock in ircfg.blocks.values():
-    print irblock
+for irblock in viewvalues(ircfg.blocks):
+    print(irblock)
 
 
 if args.symb:
@@ -153,11 +152,11 @@ else:
 
 gen_block_data_flow_graph(ir_arch_analysis, ircfg, ad, block_flow_cb)
 
-print '*' * 40
-print """
+print('*' * 40)
+print("""
  View with:
 dotty dataflow.dot
  or
  Generate ps with pdf:
 dot -Tps dataflow_xx.dot -o graph.ps
-"""
+""")
diff --git a/example/expression/simplification_add.py b/example/expression/simplification_add.py
index 621d1139..6ac36a17 100644
--- a/example/expression/simplification_add.py
+++ b/example/expression/simplification_add.py
@@ -1,13 +1,14 @@
+from __future__ import print_function
 import miasm2.expression.expression as m2_expr
 from miasm2.expression.simplifications import expr_simp
 from pdb import pm
 
-print """
+print("""
 Expression simplification demo: Adding a simplification:
 a + a + a == a * 3
 
 More detailed examples can be found in miasm2/expression/simplification*.
-"""
+""")
 
 # Define the simplification method
 ## @expr_simp is the current expression simplifier instance
@@ -32,14 +33,14 @@ def simp_add_mul(expr_simp, expr):
 
 a = m2_expr.ExprId('a', 32)
 base_expr = a + a + a
-print "Without adding the simplification:"
-print "\t%s = %s" % (base_expr, expr_simp(base_expr))
+print("Without adding the simplification:")
+print("\t%s = %s" % (base_expr, expr_simp(base_expr)))
 
 # Enable pass
 expr_simp.enable_passes({m2_expr.ExprOp: [simp_add_mul]})
 
-print "After adding the simplification:"
-print "\t%s = %s" % (base_expr, expr_simp(base_expr))
+print("After adding the simplification:")
+print("\t%s = %s" % (base_expr, expr_simp(base_expr)))
 
 # Automatic fail
 assert(expr_simp(base_expr) == m2_expr.ExprOp("*", a,
diff --git a/example/expression/simplification_tools.py b/example/expression/simplification_tools.py
index cb062fb3..a9bcc429 100644
--- a/example/expression/simplification_tools.py
+++ b/example/expression/simplification_tools.py
@@ -1,10 +1,11 @@
+from __future__ import print_function
 from miasm2.expression.expression import *
 from pdb import pm
 
-print """
+print("""
 Expression simplification demo.
 (and regression test)
-"""
+""")
 
 
 a = ExprId('a', 32)
@@ -39,26 +40,26 @@ def replace_expr(e):
     return e
 
 
-print x
+print(x)
 y = x.visit(replace_expr)
-print y
-print x.copy()
-print y.copy()
-print y == y.copy()
-print repr(y), repr(y.copy())
+print(y)
+print(x.copy())
+print(y.copy())
+print(y == y.copy())
+print(repr(y), repr(y.copy()))
 
 
 z = ExprCompose(a[5:5 + 8], b[:16], x[:8])
-print z
-print z.copy()
-print z[:31].copy().visit(replace_expr)
+print(z)
+print(z.copy())
+print(z[:31].copy().visit(replace_expr))
 
-print 'replace'
-print x.replace_expr({c + ExprInt(0x42, 32): d,
-                      a + b: c, })
-print z.replace_expr({c + ExprInt(0x42, 32): d,
-                      a + b: c, })
+print('replace')
+print(x.replace_expr({c + ExprInt(0x42, 32): d,
+                      a + b: c, }))
+print(z.replace_expr({c + ExprInt(0x42, 32): d,
+                      a + b: c, }))
 
 
 u = z.copy()
-print u
+print(u)
diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py
index c79dd0b8..e0ab09da 100644
--- a/example/expression/solve_condition_stp.py
+++ b/example/expression/solve_condition_stp.py
@@ -1,8 +1,11 @@
+from __future__ import print_function
 import sys
 import subprocess
 from optparse import OptionParser
 from pdb import pm
 
+from future.utils import viewitems
+
 from miasm2.analysis.machine import Machine
 from miasm2.analysis.binary import Container
 from miasm2.expression.expression import ExprInt, ExprCond, ExprId, \
@@ -29,9 +32,9 @@ if not args:
 def emul_symb(ir_arch, ircfg, mdis, states_todo, states_done):
     while states_todo:
         addr, symbols, conds = states_todo.pop()
-        print '*' * 40, "addr", addr, '*' * 40
+        print('*' * 40, "addr", addr, '*' * 40)
         if (addr, symbols, conds) in states_done:
-            print 'Known state, skipping', addr
+            print('Known state, skipping', addr)
             continue
         states_done.add((addr, symbols, conds))
         symbexec = SymbolicExecutionEngine(ir_arch)
@@ -40,10 +43,10 @@ def emul_symb(ir_arch, ircfg, mdis, states_todo, states_done):
             del symbexec.symbols[ir_arch.pc]
         irblock = get_block(ir_arch, ircfg, mdis, addr)
 
-        print 'Run block:'
-        print irblock
+        print('Run block:')
+        print(irblock)
         addr = symbexec.eval_updt_irblock(irblock)
-        print 'Final state:'
+        print('Final state:')
         symbexec.dump(mems=False)
 
         assert addr is not None
@@ -55,16 +58,16 @@ def emul_symb(ir_arch, ircfg, mdis, states_todo, states_done):
             addr_b = expr_simp(symbexec.eval_expr(addr.replace_expr(cond_group_b), {}))
             if not (addr_a.is_int() or addr_a.is_loc() and
                     addr_b.is_int() or addr_b.is_loc()):
-                print str(addr_a), str(addr_b)
+                print(str(addr_a), str(addr_b))
                 raise ValueError("Unsupported condition")
             if isinstance(addr_a, ExprInt):
                 addr_a = int(addr_a.arg)
             if isinstance(addr_b, ExprInt):
                 addr_b = int(addr_b.arg)
-            states_todo.add((addr_a, symbexec.symbols.copy(), tuple(list(conds) + cond_group_a.items())))
-            states_todo.add((addr_b, symbexec.symbols.copy(), tuple(list(conds) + cond_group_b.items())))
+            states_todo.add((addr_a, symbexec.symbols.copy(), tuple(list(conds) + list(viewitems(cond_group_a)))))
+            states_todo.add((addr_b, symbexec.symbols.copy(), tuple(list(conds) + list(viewitems(cond_group_b)))))
         elif addr == ret_addr:
-            print 'Return address reached'
+            print('Return address reached')
             continue
         elif addr.is_int():
             addr = int(addr.arg)
@@ -81,7 +84,7 @@ if __name__ == '__main__':
 
     addr = int(options.address, 16)
 
-    cont = Container.from_stream(open(args[0]))
+    cont = Container.from_stream(open(args[0], 'rb'))
     mdis = machine.dis_engine(cont.bin_stream, loc_db=cont.loc_db)
     ir_arch = machine.ir(mdis.loc_db)
     ircfg = ir_arch.new_ircfg()
@@ -120,7 +123,7 @@ if __name__ == '__main__':
     for instr in block.lines:
         for i, arg in enumerate(instr.args):
             instr.args[i]= arg.replace_expr(fix_args)
-    print block
+    print(block)
 
     # add fake address and len to parsed instructions
     ir_arch.add_asmblock_to_ircfg(block, ircfg)
@@ -139,12 +142,12 @@ if __name__ == '__main__':
 
     all_info = []
 
-    print '*' * 40, 'conditions to match', '*' * 40
-    for addr, symbols, conds in sorted(states_done):
-        print '*' * 40, addr, '*' * 40
+    print('*' * 40, 'conditions to match', '*' * 40)
+    for addr, symbols, conds in sorted(states_done, key=str):
+        print('*' * 40, addr, '*' * 40)
         reqs = []
         for k, v in conds:
-            print k, v
+            print(k, v)
             reqs.append((k, v))
         all_info.append((addr, reqs))
 
@@ -179,14 +182,14 @@ if __name__ == '__main__':
                                              "-p", '--SMTLIB2',
                                              "out.dot"])
         except OSError:
-            print "Cannot find stp binary!"
+            print("Cannot find stp binary!")
             break
         for c in cases.split('\n'):
             if c.startswith('ASSERT'):
                 all_cases.add((addr, c))
 
-    print '*' * 40, 'ALL COND', '*' * 40
+    print('*' * 40, 'ALL COND', '*' * 40)
     all_cases = list(all_cases)
     all_cases.sort(key=lambda x: (x[0], x[1]))
     for addr, val in all_cases:
-        print 'Address:', addr, 'is reachable using argc', val
+        print('Address:', addr, 'is reachable using argc', val)