1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
#!/usr/bin/env python
#-*- coding:utf-8 -*-
import os
import tempfile
import ctypes
from distutils.sysconfig import get_python_inc
from subprocess import check_call
from hashlib import md5
from miasm2.ir.ir2C import irblocs2C
from miasm2.jitter import jitcore, Jitgcc
from miasm2.core.utils import keydefaultdict
def gen_core(arch, attrib):
lib_dir = os.path.dirname(os.path.realpath(__file__))
txt = ""
txt += '#include "%s/queue.h"\n' % lib_dir
txt += '#include "%s/vm_mngr.h"\n' % lib_dir
txt += '#include "%s/vm_mngr_py.h"\n' % lib_dir
txt += '#include "%s/JitCore.h"\n' % lib_dir
txt += '#include "%s/arch/JitCore_%s.h"\n' % (lib_dir, arch.name)
txt += r'''
#define RAISE(errtype, msg) {PyObject* p; p = PyErr_Format( errtype, msg ); return p;}
'''
return txt
def gen_C_source(ir_arch, func_code):
c_source = ""
c_source += "\n".join(func_code)
c_source = gen_core(ir_arch.arch, ir_arch.attrib) + c_source
c_source = "#include <Python.h>\n" + c_source
return c_source
class myresolver(object):
def __init__(self, offset):
self.offset = offset
def ret(self):
return "return PyLong_FromUnsignedLongLong(0x%X);" % self.offset
class resolver(object):
def __init__(self):
self.resolvers = keydefaultdict(myresolver)
def get_resolver(self, offset):
return self.resolvers[offset]
class JitCore_Gcc(jitcore.JitCore):
"JiT management, using GCC as backend"
def __init__(self, ir_arch, bs=None):
self.jitted_block_delete_cb = self.deleteCB
super(JitCore_Gcc, self).__init__(ir_arch, bs)
self.resolver = resolver()
self.gcc_states = {}
self.ir_arch = ir_arch
self.tempdir = os.path.join(tempfile.gettempdir(), "miasm_gcc_cache")
try:
os.mkdir(self.tempdir, 0755)
except OSError:
pass
if not os.access(self.tempdir, os.R_OK | os.W_OK):
raise RuntimeError(
'Cannot access gcc cache directory %s ' % self.tempdir)
self.exec_wrapper = Jitgcc.gcc_exec_bloc
self.libs = None
self.include_files = None
def deleteCB(self, offset):
pass
def load(self):
lib_dir = os.path.dirname(os.path.realpath(__file__))
libs = [os.path.join(lib_dir, 'VmMngr.so'),
os.path.join(lib_dir,
'arch/JitCore_%s.so' % (self.ir_arch.arch.name))]
include_files = [os.path.dirname(__file__),
get_python_inc()]
self.include_files = include_files
self.libs = libs
def jit_gcc_compil(self, f_name, func_code):
func_hash = md5(func_code).hexdigest()
fname_out = os.path.join(self.tempdir, "%s.so" % func_hash)
if not os.access(fname_out, os.R_OK | os.X_OK):
# Create unique C file
fdesc, fname_in = tempfile.mkstemp(suffix=".c")
os.write(fdesc, func_code)
os.close(fdesc)
# Create unique SO file
_, fname_tmp = tempfile.mkstemp(suffix=".so")
inc_dir = ["-I%s" % inc for inc in self.include_files]
libs = ["%s" % lib for lib in self.libs]
args = ["gcc"] + ["-O3"] + [
"-shared", "-fPIC", fname_in, '-o', fname_tmp] + inc_dir + libs
check_call(args)
# Move temporary file to final file
os.rename(fname_tmp, fname_out)
lib = ctypes.cdll.LoadLibrary(fname_out)
func = getattr(lib, f_name)
addr = ctypes.cast(func, ctypes.c_void_p).value
return None, addr
def jitirblocs(self, label, irblocs):
f_name = "bloc_%s" % label.name
f_declaration = 'int %s(block_id * BlockDst, JitCpu* jitcpu)' % f_name
out = irblocs2C(self.ir_arch, self.resolver, label, irblocs,
gen_exception_code=True,
log_mn=self.log_mn,
log_regs=self.log_regs)
out = [f_declaration + '{'] + out + ['}\n']
c_code = out
func_code = gen_C_source(self.ir_arch, c_code)
# open('tmp_%.4d.c'%self.jitcount, "w").write(func_code)
self.jitcount += 1
gcc_state, mcode = self.jit_gcc_compil(f_name, func_code)
self.lbl2jitbloc[label.offset] = mcode
self.gcc_states[label.offset] = gcc_state
|