from __future__ import division

import ctypes

import os

import traceback

import struct

import ast

import struct

import array

from corepy.lib.extarray import extarray

from corepy.arch.x86_64.platform.linux.x86_64_exec import make_executable

import corepy.arch.x86_64.isa as isa

import corepy.arch.x86_64.types.registers as registers

from corepy.arch.x86_64.lib.memory import MemRef

import corepy.arch.x86_64.platform as platform

DEBUG = 0

def debug(program, name):

print "end", name

class Program(platform.Program):

self.render_code.references = self.references # shared, not copied

class BareProgram(Program):

self._epilogue = []

class cdict(dict):

return value

def memoize(f):

return _

class fake_int(long):

return not self >= other

'''

def get_call(addr):

program = BareProgram()

code = program.get_stream()

code += isa.mov(registers.rax, fake_int(addr))

code += isa.call(registers.rax)

program.add(code)

program.cache_code()

return program.render_code

def get_mov_rax(addr):

program = BareProgram()

code = program.get_stream()

code += isa.mov(registers.rax, fake_int(addr))

program.add(code)

program.cache_code()

return program.render_code

def get_jmp(addr):

program = BareProgram()

code = program.get_stream()

code += isa.mov(registers.rax, fake_int(addr))

code += isa.jmp(registers.rax)

program.add(code)

program.cache_code()

return program.render_code

'''

def get_jmp(addr):

return array.array('B', l)

def get_call(addr):

return array.array('B', l)

def get_mov_rax(addr):

l = [72, 184]

l.extend(struct.unpack("8B", struct.pack("l", addr)))

return array.array('B', l)

delayed = []

def execute_delayed():

for func in delayed:

func()

delayed[:] = []

def add_delayed(func):

delayed.append(func)

def called_from_asm(func):

return f

class UpdatableMovRax(object):

self.caller_program.render_code[self.caller_start.position:self.caller_end.position] = get_mov_rax(self.value)

patch_len = len(get_jmp(0))

callback_type = ctypes.CFUNCTYPE(None, ctypes.c_int64)

def get_asm_glue_old(dest_addr):

return program.render_code

def get_asm_glue(dest):

return l

redirections = 0

triggered_redirections = 0

def add_redirection(caller_code, callback):

caller_program.references.append(code)

def get_redirection(callback):

return program

def post():

if DEBUG:

print "redirection stats:", triggered_redirections, "/", redirections

@called_from_asm

def print_int64(i):

print i,

print_int64_cfunc = ctypes.CFUNCTYPE(None, ctypes.c_int64)(print_int64)

print_int64_addr = ctypes.cast(print_int64_cfunc, ctypes.c_void_p).value

@called_from_asm

def print_double(i):

print struct.unpack("d", struct.pack("l", i))[0],

print_double_cfunc = ctypes.CFUNCTYPE(None, ctypes.c_int64)(print_double)

print_double_addr = ctypes.cast(print_double_cfunc, ctypes.c_void_p).value

@called_from_asm

def print_string(i):

import type_impl

print type_impl.Str.to_python(struct.pack("l", i)),

print_string_cfunc = ctypes.CFUNCTYPE(None, ctypes.c_int64)(print_string)

print_string_addr = ctypes.cast(print_string_cfunc, ctypes.c_void_p).value

@called_from_asm

def print_nl():

print

print_nl_cfunc = ctypes.CFUNCTYPE(None)(print_nl)

print_nl_addr = ctypes.cast(print_nl_cfunc, ctypes.c_void_p).value

malloc_addr = ctypes.cast(ctypes.CDLL("libc.so.6").malloc, ctypes.c_void_p).value

free_addr = ctypes.cast(ctypes.CDLL("libc.so.6").free, ctypes.c_void_p).value

realloc_addr = ctypes.cast(ctypes.CDLL("libc.so.6").realloc, ctypes.c_void_p).value

sprintf_addr = ctypes.cast(ctypes.CDLL("libc.so.6").sprintf, ctypes.c_void_p).value

memcmp_addr = ctypes.cast(ctypes.CDLL("libc.so.6").memcmp, ctypes.c_void_p).value

def dump(node, annotate_fields=True, include_attributes=False):

return _format(node)

def unlift(bs, func, desc):

bs.this.append(compiler.end)

def unlift_noncached(bs, func, desc):

bs.program.references.append(code)

def hash_dict(d):

return v

import compiler

def read_top(bs, regs):

return type, res

def pop(bs, regs):

return type, res

def push(bs, (type, regs)):

bs.flow.stack.append(type)

good_regs = [registers.rbx, registers.rcx, registers.rdx, registers.rdi, registers.rsi, registers.r9, registers.r10, registers.r11, registers.r12]

def swap(bs):

push(bs, b)

def rev3(bs):

push(bs, c)

def rem1(bs):

push(bs, a)

def rem2(bs):

push(bs, a)

def dup(bs):

regs = list(good_regs)

a = read_top(bs, regs)

push(bs, a)

def lower(bs, n):

push(bs, a)

def discard(bs, n=1):

bs.code += isa.add(registers.rsp, 8 * d)

def discard2(bs):

bs.code += isa.add(registers.rsp, 8*(type.size+type1.size))

def dup_lower(bs, level):

bs.flow.stack.append(type)

class WatchedValue(object):

watcher(new)

def branch_on_watched(bs, watched, func): # should have an argument on whether to merge like unlift does (unlift versions should be merged too)

func(value)(bs)

def arg_check(bs, args, should):

return True

class OffsetListProxy(object):

return self.source.__getitem__(item)

if __name__ == "__main__":

print repr(get_jmp(0))

print repr(get_call(0))

print repr(get_mov_rax(0))

print repr(get_asm_glue_old(0))

blocks = []

count = 10000

def go(i=0):

return program.inst_addr()

program = Program()

code = program.get_stream()

add_redirection(code, lambda rdi: get_call(go()))

program.add(code)

processor = platform.Processor()

import time

start = time.time()

processor.execute(program)

end = time.time()

print (end - start)/count*1000, "ms per"

print count/(end-start), "hz"