def jit_instructions(mn_str):
    """JIT instructions and return the jitter object."""

    # Get the miasm2 Machine
    machine = Machine("mepb")
    mn_mep = machine.mn()

    # Assemble the instructions
    asm = ""
    for instr_str in mn_str.split("\n"):
        instr = mn_mep.fromstring(instr_str, "b")
        instr.mode = "b"
        asm += mn_mep.asm(instr)[0]

    # Init the jitter and add the assembled instructions to memory
    jitter = machine.jitter(jit_type="gcc")
    jitter.vm.add_memory_page(0, PAGE_READ | PAGE_WRITE, asm)

    # Set the breakpoint
    jitter.add_breakpoint(len(asm), lambda x: False)

    # Jit the instructions
    #jitter.init_stack()
    jitter.init_run(0)
    jitter.continue_run()

    return jitter

    def run(self):
        # Architecture
        architecture = False
        if self.args.architecture:
            architecture = self.args.architecture
        else:
            with open(self.args.filename) as fdesc:
                architecture = ArchHeuristic(fdesc).guess()
            if not architecture:
                raise ValueError("Unable to recognize the architecture, please specify it")
            if self.args.verbose:
                print "Guessed architecture: %s" % architecture

        cont = Container.from_stream(open(self.args.filename))
        machine = Machine(architecture)
        addr_size = machine.ira().pc.size / 4
        fh = FuncHeuristic(cont, machine)

        # Enable / disable heuristics
        for name in self.args.enable_heuristic:
            heur = fh.name2heuristic(name)
            if heur not in fh.heuristics:
                fh.heuristics.append(heur)
        for name in self.args.disable_heuristic:
            heur = fh.name2heuristic(name)
            fh.heuristics.remove(heur)

        if self.args.verbose:
            print "Heuristics to run: %s" % ", ".join(fh.heuristic_names)


        # Launch guess
        fmt = "0x{:0%dx}" % addr_size
        for addr in fh.guess():
            print fmt.format(addr)

def main():
    native_code = assemble_text(asm_helloworld, [("L_MAIN", 0)]) 

    mach = Machine("x86_64")
    jitter = mach.jitter(jit_type="tcc")
    run_addr =0x40000000
    jitter.init_stack()
    jitter.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, native_code)
    jitter.push_uint64_t(0xdeadbeef)
    jitter.add_breakpoint(0xdeadbeef, on_exit)
    jitter.jit.log_mn = True

    jitter.init_run(run_addr)
    jitter.continue_run()

    def do_trace(self):
        '''Run miasm and construct the trace'''

        self.trace = Trace()

        # Retrieve miasm tools
        machine = Machine(self.machine)
        jitter = machine.jitter("python")

        # Set the jitter to use our custom emulator
        jitter.jit.symbexec = CustomEmulatedSymbExec(
            jitter.cpu, jitter.vm, jitter.jit.ir_arch, {})
        jitter.jit.symbexec.enable_emulated_simplifications()
        jitter.jit.symbexec.reset_regs()

        elf = vm_load_elf(jitter.vm, open(self.program, "rb").read())

        # Init segment
        jitter.ir_arch.do_stk_segm = True
        jitter.ir_arch.do_ds_segm = True
        jitter.ir_arch.do_str_segm = True
        jitter.ir_arch.do_all_segm = True

        FS_0_ADDR = 0x7ff70000
        jitter.cpu.FS = 0x4
        jitter.cpu.set_segm_base(jitter.cpu.FS, FS_0_ADDR)
        jitter.vm.add_memory_page(
            FS_0_ADDR + 0x28, PAGE_READ, "\x42\x42\x42\x42\x42\x42\x42\x42")

        # Init stack and push main args
        jitter.init_stack()
        jitter.push_uint64_t(1)
        jitter.vm.add_memory_page(0x800000, PAGE_READ, self.program)
        jitter.push_uint64_t(0x800000)
        jitter.push_uint64_t(0xDEADDEAD)

        jitter.add_breakpoint(0xDEADDEAD, self.end_do_trace)
        jitter.add_breakpoint(0x1337beef, self.end_func)
        jitter.add_breakpoint(self.address, self.begin_func)

        # Run the execution
        if self.main_address is None:
            jitter.init_run(elf.Ehdr.entry)
        else:
            jitter.init_run(self.main_address)

        jitter.continue_run()
        assert jitter.run == False
        return self.trace

    def __init__(self, jitter_engine):
        self.machine = Machine(self.arch_name)
        self.myjit = self.machine.jitter(jitter_engine)
        self.myjit.init_stack()

        self.myjit.jit.log_regs = False
        self.myjit.jit.log_mn = False

class ethRE:

    def __init__(self):
        self.machine = Machine("evm")
        self.mn = self.machine.mn

    def get_bytecode(self, account_addr):
        code = evm_env.code(int(account_addr[2:],16))
        code = code[2:] # To remove '0x'..
        if len(code) % 2 == 1:
            code  = "0"+code
        code = binascii.unhexlify(code)
        return code

    def from_bytecode(self, bytecode):

        container = Container.from_string(bytecode)

        mdis = self.machine.dis_engine(container.bin_stream)
        self.blks = mdis.dis_multibloc(0)

    def from_asm(self, asm_text):
        all_bloc, symbol_pool = parse_asm.parse_txt(self.mn,0, asm_text)
        self.blks = all_bloc
        raise Exception("Not correctly implemented")

    def graph(self):
        if not self.blks:
            raise Exception("Need to parse bytecode before")
        return self.blks.dot()

    def __init__(self, jitter_engine):
        self.myjit = Machine(self.arch_name).jitter(jitter_engine)
        self.myjit.stack_base = 0x1000
        self.myjit.stack_size = 0x1000
        self.myjit.init_stack()

        self.myjit.jit.log_regs = False
        self.myjit.jit.log_mn = False

def init_jitter():
    global data, run_addr
    # Create jitter
    myjit = Machine("x86_32").jitter(sys.argv[1])

    myjit.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, data)

    # Init jitter
    myjit.init_stack()
    myjit.set_trace_log()
    myjit.push_uint32_t(0x1337beef)

    myjit.add_breakpoint(0x1337beef, code_sentinelle)
    return myjit

class Asm_Test(object):
    def __init__(self):
        self.myjit = Machine("x86_32").jitter()
        self.myjit.init_stack()

        self.myjit.jit.log_regs = False
        self.myjit.jit.log_mn = False


    def __call__(self):
        self.asm()
        self.run()
        self.check()


    def asm(self):
        blocs, symbol_pool = parse_asm.parse_txt(mn_x86, 32, self.TXT,
                                                 symbol_pool = self.myjit.ir_arch.symbol_pool)
        # fix shellcode addr
        symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0)
        s = StrPatchwork()
        patches = asmbloc.asm_resolve_final(mn_x86, blocs[0], symbol_pool)
        for offset, raw in patches.items():
            s[offset] = raw

        s = str(s)
        self.assembly = s

    def run(self):
        run_addr = 0
        self.myjit.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, self.assembly)

        self.myjit.push_uint32_t(0x1337beef)

        self.myjit.add_breakpoint(0x1337beef, lambda x:False)

        self.myjit.init_run(run_addr)
        self.myjit.continue_run()

        assert(self.myjit.pc == 0x1337beef)

    def check(self):
        raise NotImplementedError('abstract method')

def main():
    sc = assemble_text(asm_helloworld, [("L_MAIN", 0)]) 

    mach = Machine("x86_64")
    jitter = mach.jitter(jit_type="tcc")
    run_addr =0x40000000
    jitter.init_stack()
    jitter.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, sc)
    jitter.push_uint64_t(0xdeadbeef)
    jitter.add_breakpoint(0xdeadbeef, on_exit)
    #jitter.jit.log_regs = True
    jitter.jit.log_mn = True

    init_syscall(jitter)
    jitter.vm.add_memory_page(ADDR_COUNTER, PAGE_READ | PAGE_WRITE, "\x00" * 8)

    jitter.init_run(run_addr)
    jitter.continue_run()

    print "MOV: %d" % unpack("I", jitter.vm.get_mem(ADDR_COUNTER, 4))[0]

class Arch(object):
    """
    Parent class for Arch abstraction
    """

    # Architecture name
    _ARCH_ = None
    def __init__(self):
        self.machine = Machine(self._ARCH_)
        self.jitter = self.machine.jitter(self.options.jitter)

    @classmethod
    def update_parser(cls, parser):
        pass

 def __init__(self, testcreator, replayed_snapshot):
     '''
     @testcreator: TestCreator instance with associated information
     @replayed_snapshot: snapshot to be used
     '''
     self.isFuncFound = False
     self.filename = testcreator.program
     self.learned_addr = testcreator.address
     self.snapshot = replayed_snapshot
     self.replayexception = []
     self.abicls = testcreator.abicls
     self.machine = Machine(testcreator.machine)
     self.trace = testcreator.trace
     self.logger = testcreator.logger
     self.ira = self.machine.ira()
     self.ptr_size = self.ira.sizeof_pointer()/8

class Asm_Test(object):

    def __init__(self, jitter):
        self.myjit = Machine("mips32l").jitter(jitter)
        self.myjit.init_stack()

    def __call__(self):
        self.asm()
        self.run()
        self.check()

    def asm(self):
        blocks, loc_db = parse_asm.parse_txt(mn_mips32, 'l', self.TXT,
                                                  loc_db=self.myjit.ir_arch.loc_db)
        # fix shellcode addr
        loc_db.set_location_offset(loc_db.get_name_location("main"), 0x0)
        s = StrPatchwork()
        patches = asmblock.asm_resolve_final(mn_mips32, blocks, loc_db)
        for offset, raw in patches.items():
            s[offset] = raw

        s = str(s)
        self.assembly = s

    def run(self):
        run_addr = 0
        self.myjit.vm.add_memory_page(
            run_addr, PAGE_READ | PAGE_WRITE, self.assembly)

        self.myjit.cpu.RA = 0x1337beef

        self.myjit.add_breakpoint(0x1337beef, lambda x: False)

        self.myjit.init_run(run_addr)
        self.myjit.continue_run()

        assert(self.myjit.pc == 0x1337beef)

    def check(self):
        raise NotImplementedError('abstract method')

    def __init__(self, abicls, machine):
        self.abicls = abicls

        self.input_reg = {}
        self.output_reg = {}

        self._previous_addr = 0
        self._current_addr = 0
        self._instr_count = 0
        self._pending_call = []
        # Function addr -> list of information on calls
        self.function_calls = {}
        self.paths = DiGraph()

        self.in_memory = {}
        self.out_memory = {}

        self._ira = Machine(machine).ira()
        self._ptr_size = self._ira.sizeof_pointer()/8
        self.sp = self._ira.sp.name

class Asm_Test_16(Asm_Test):
    arch_name = "x86_16"
    arch_attrib = 16
    ret_addr = 0x1337

    def __init__(self, jitter_engine):
        self.myjit = Machine(self.arch_name).jitter(jitter_engine)
        self.myjit.stack_base = 0x1000
        self.myjit.stack_size = 0x1000
        self.myjit.init_stack()

    def init_machine(self):
        self.myjit.vm.add_memory_page(self.run_addr, PAGE_READ | PAGE_WRITE, self.assembly)
        self.myjit.push_uint16_t(self.ret_addr)
        self.myjit.add_breakpoint(self.ret_addr, lambda x:False)

class Asm_Test(object):
    run_addr = 0x0

    def __init__(self, jitter_engine):
        self.myjit = Machine(self.arch_name).jitter(jitter_engine)
        self.myjit.init_stack()

        self.myjit.jit.log_regs = False
        self.myjit.jit.log_mn = False

    def test_init(self):
        pass

    def prepare(self):
        pass

    def __call__(self):
        self.prepare()
        self.asm()
        self.init_machine()
        self.test_init()
        self.run()
        self.check()

    def run(self):

        self.myjit.init_run(self.run_addr)
        self.myjit.continue_run()

        assert(self.myjit.pc == self.ret_addr)

    def asm(self):
        blocks, symbol_pool = parse_asm.parse_txt(mn_x86, self.arch_attrib, self.TXT,
                                                  symbol_pool = self.myjit.ir_arch.symbol_pool)
        # fix shellcode addr
        symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0)
        s = StrPatchwork()
        patches = asmblock.asm_resolve_final(mn_x86, blocks, symbol_pool)
        for offset, raw in patches.items():
            s[offset] = raw

        s = str(s)
        self.assembly = s

    def check(self):
        raise NotImplementedError('abstract method')

console_handler = logging.StreamHandler()
console_handler.setFormatter(logging.Formatter("%(levelname)-5s: %(message)s"))
log.addHandler(console_handler)
log.setLevel(logging.INFO)

filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
    execfile(filename)


parser = ArgumentParser("Disassemble a binary")
parser.add_argument('filename', help="File to disassemble")
parser.add_argument('address', help="Starting address for disassembly engine",
                    nargs="*")
parser.add_argument('-m', '--architecture', help="architecture: " + \
                        ",".join(Machine.available_machine()))
parser.add_argument('-f', "--followcall", action="store_true",
                    help="Follow call instructions")
parser.add_argument('-b', "--blockwatchdog", default=None, type=int,
                    help="Maximum number of basic block to disassemble")
parser.add_argument('-n', "--funcswatchdog", default=None, type=int,
                    help="Maximum number of function to disassemble")
parser.add_argument('-r', "--recurfunctions", action="store_true",
                    help="Disassemble founded functions")
parser.add_argument('-v', "--verbose", action="store_true", help="Verbose mode")
parser.add_argument('-g', "--gen_ir", action="store_true",
                    help="Compute the intermediate representation")
parser.add_argument('-z', "--dis-nulstart-block", action="store_true",
                    help="Do not disassemble NULL starting block")
parser.add_argument('-l', "--dontdis-retcall", action="store_true",
                    help="If set, disassemble only call destinations")

 def __init__(self, **kwargs):
     self.machine = Machine(self._ARCH_)
     self.jitter = self.machine.jitter(self.options.jitter)

    execfile(filename)

parser = ArgumentParser(description="x86 32 basic Jitter")
parser.add_argument("filename", help="x86 32 shellcode filename")
parser.add_argument("-j", "--jitter",
                    help="Jitter engine. Possible values are : tcc (default), llvm",
                    default="tcc")
args = parser.parse_args()

def code_sentinelle(jitter):
    jitter.run = False
    jitter.pc = 0
    return True


myjit = Machine("x86_32").jitter(args.jitter)
myjit.init_stack()

data = open(args.filename).read()
run_addr = 0x40000000
myjit.vm.add_memory_page(run_addr, PAGE_READ | PAGE_WRITE, data)

myjit.jit.log_regs = True
myjit.jit.log_mn = True
myjit.push_uint32_t(0x1337beef)

myjit.add_breakpoint(0x1337beef, code_sentinelle)

myjit.init_run(run_addr)
myjit.continue_run()

from argparse import ArgumentParser
from pdb import pm
import json

from miasm2.analysis.machine import Machine
from miasm2.analysis.binary import Container
from miasm2.analysis.depgraph import DependencyGraph
from miasm2.expression.expression import ExprMem, ExprId, ExprInt32

parser = ArgumentParser("Dependency grapher")
parser.add_argument("filename", help="Binary to analyse")
parser.add_argument("func_addr", help="Function address")
parser.add_argument("target_addr", help="Address to start")
parser.add_argument("element", nargs="+", help="Elements to track")
parser.add_argument("-m", "--architecture",
                    help="Architecture (%s)" % Machine.available_machine())
parser.add_argument("-i", "--implicit", help="Use implicit tracking",
                    action="store_true")
parser.add_argument("--unfollow-mem", help="Stop on memory statements",
                    action="store_true")
parser.add_argument("--unfollow-call", help="Stop on call statements",
                    action="store_true")
parser.add_argument("--do-not-simplify", help="Do not simplify expressions",
                    action="store_true")
parser.add_argument("--rename-args",
                    help="Rename common arguments (@32[ESP_init] -> Arg1)",
                    action="store_true")
parser.add_argument("--json",
                    help="Output solution in JSON",
                    action="store_true")
args = parser.parse_args()