def cleanup(self):
"""Do end-of-loop iterator code"""
# Update the current count
if self.mode == DEC:
if self.step_size() == 1:
self.code.add(x86.dec(self.r_count))
else:
if self.r_step is not None:
if isinstance(self.r_step, memory.MemRef):
self.code.add(x86.mov(self.r_clobber, self.r_step))
self.code.add(x86.add(self.r_count, self.r_clobber))
else:
self.code.add(x86.add(self.r_count, self.r_step))
else:
self.code.add(x86.add(self.r_count, self.step_size()))
elif self.mode == INC:
if self.step_size() == 1:
self.code.add(x86.inc(self.r_count))
else:
if self.r_step is not None:
if isinstance(self.r_step, memory.MemRef):
self.code.add(x86.mov(self.r_clobber, self.r_step))
self.code.add(x86.add(self.r_count, self.r_clobber))
else:
self.code.add(x86.add(self.r_count, self.r_step))
else:
self.code.add(x86.add(self.r_count, self.step_size()))
return
def TestDECMemMem_ImmStep():
A = extarray.extarray('l', 1000)
B = extarray.extarray('l', 1000)
for i in xrange(1000):
A[i] = i
prgm = env.Program()
code = prgm.get_stream()
a = registers.esi
b = registers.edi
code.add(x86.mov(a, memory.MemRef(registers.ebp, 2*_ws)))
code.add(x86.mov(b, memory.MemRef(registers.ebp, 3*_ws)))
n = memory.MemRef(registers.esp)
#code.add(x86.mov(n, 1000))
code.add(x86.push(1000))
i_iter = syn_iter(code, n, mode=DEC, step=-4, count_reg = memory.MemRef(registers.esp, -1*_ws), clobber_reg=registers.eax)
j = registers.ebx
for i_ in i_iter:
code.add(x86.mov(j, i_))
code.add(x86.mov(registers.eax, memory.MemRef(a, index=j, scale=4)))
code.add(x86.mov(memory.MemRef(b, index=j, scale=4), registers.eax))
code.add(x86.add(registers.esp, 4))
params = env.ExecParams()
params.p1 = A.buffer_info()[0]-_ws
params.p2 = B.buffer_info()[0]-_ws
prgm += code
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B)-1, 0, -4):
assert(B[i] == i)
def TestCTRReg():
A = extarray.extarray('l', 1000)
B = extarray.extarray('l', 1000)
for i in xrange(1000):
A[i] = i
prgm = env.Program()
code = prgm.get_stream()
a = registers.esi
b = registers.edi
code.add(x86.mov(a, memory.MemRef(registers.ebp, 2 * _ws)))
code.add(x86.mov(b, memory.MemRef(registers.ebp, 3 * _ws)))
n = registers.ebx
code.add(x86.mov(n, 1000))
i_iter = syn_iter(code, n, mode=CTR)
for i_ in i_iter:
code.add(x86.mov(registers.eax, memory.MemRef(a, index=i_, scale=4)))
code.add(x86.mov(memory.MemRef(b, index=i_, scale=4), registers.eax))
params = env.ExecParams()
params.p1 = A.buffer_info()[0] - _ws
params.p2 = B.buffer_info()[0] - _ws
prgm += code
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B)):
assert (B[i] == i)
def cleanup(self):
"""Do end-of-loop iterator code"""
# Update the current count
if self.mode == DEC:
if self.step_size() == 1:
self.code.add(x86.dec(self.r_count))
else:
if self.r_step is not None:
if isinstance(self.r_step, memory.MemRef):
self.code.add(x86.mov(self.r_clobber, self.r_step))
self.code.add(x86.add(self.r_count, self.r_clobber))
else:
self.code.add(x86.add(self.r_count, self.r_step))
else:
self.code.add(x86.add(self.r_count, self.step_size()))
elif self.mode == INC:
if self.step_size() == 1:
self.code.add(x86.inc(self.r_count))
else:
if self.r_step is not None:
if isinstance(self.r_step, memory.MemRef):
self.code.add(x86.mov(self.r_clobber, self.r_step))
self.code.add(x86.add(self.r_count, self.r_clobber))
else:
self.code.add(x86.add(self.r_count, self.r_step))
else:
self.code.add(x86.add(self.r_count, self.step_size()))
return
def TestCTRReg():
A = extarray.extarray('l', 1000)
B = extarray.extarray('l', 1000)
for i in xrange(1000):
A[i] = i
prgm = env.Program()
code = prgm.get_stream()
a = registers.esi
b = registers.edi
code.add(x86.mov(a, memory.MemRef(registers.ebp, 2*_ws)))
code.add(x86.mov(b, memory.MemRef(registers.ebp, 3*_ws)))
n = registers.ebx
code.add(x86.mov(n, 1000))
i_iter = syn_iter(code, n, mode=CTR)
for i_ in i_iter:
code.add(x86.mov(registers.eax, memory.MemRef(a, index=i_, scale=4)))
code.add(x86.mov(memory.MemRef(b, index=i_, scale=4), registers.eax))
params = env.ExecParams()
params.p1 = A.buffer_info()[0]-_ws
params.p2 = B.buffer_info()[0]-_ws
prgm += code
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B)):
assert(B[i] == i)
def return_var(var):
if isinstance(var.reg, type(var.code.gp_return)):
var.code.add(x86.mov(var.code.gp_return, var))
#elif isinstance(var.reg, type(var.code.fp_return)):
# var.code.add(x86.fmrx(var.code.fp_return, var))
else:
raise Exception('Return not supported for %s registers' % (str(type(var.reg))))
return
def load_word(code, r_target, word): """ Generate the instruction sequence to load a word into r-target. This can be used for any value greater than 2^16. TODO - afriedle - what ranges does this work for on x86? """ return code.add(x86.mov(r_target, word))
def start(self, align=True):
if self.mode == CTR:
if self.external_start:
self.code.add(x86.mov(registers.ecx, self.r_start))
else:
self.code.add(x86.mov(registers.ecx, self.n))
elif self.mode == DEC:
if self.external_start:
if self.r_start == None:
raise Exception(
'No external start register was specified.')
if isinstance(self.r_count, memory.MemRef) and isinstance(
self.r_start, memory.MemRef):
if self.r_clobber == None:
raise Exception(
'Must specify clobber_reg if count_reg and start values are both stored in memory.'
)
self.code.add(x86.mov(self.r_clobber, self.r_start))
self.code.add(x86.mov(self.r_count, self.r_clobber))
else:
self.code.add(x86.mov(self.r_count, self.r_start))
else:
self.code.add(x86.mov(self.r_count, self.n))
elif self.mode == INC:
if self.external_stop:
if self.r_stop == None:
raise Exception('No external stop register was specified.')
if self.external_start:
if isinstance(self.r_count, memory.MemRef) and isinstance(
self.r_start, memory.MemRef):
self.code.add(x86_64.mov(self.r_clobber, self.r_start))
self.code.add(x86_64.mov(self.r_count, self.r_clobber))
else:
self.code.add(x86.mov(self.r_count, self.r_start))
else:
self.code.add(x86.mov(self.r_count, self.get_start()))
# /end mode if
if self.r_count is not None:
#self.current_count = var.SignedWord(code = self.code, reg = self.r_count)
self.current_count = self.r_count
# Label
self.start_label = self.code.prgm.get_unique_label("SYN_ITER_START")
self.code.add(self.start_label)
# Create continue/branch labels so they can be referenced; they will be
# added to the code in their appropriate locations.
self.continue_label = self.code.prgm.get_unique_label(
"SYN_ITER_CONTINUE")
return
def TestINCMemMem():
A = extarray.extarray('i', 1000)
B = extarray.extarray('i', 1000)
for i in xrange(1000):
A[i] = i
prgm = env.Program()
code = prgm.get_stream()
a = registers.esi
b = registers.edi
code.add(x86.mov(a, memory.MemRef(registers.ebp, 2 * _ws)))
code.add(x86.mov(b, memory.MemRef(registers.ebp, 3 * _ws)))
n = memory.MemRef(registers.ebp, 4 * _ws)
code.add(x86.mov(n, 1000))
i_iter = syn_iter(code,
n,
mode=INC,
count_reg=memory.MemRef(registers.ebp, 5 * _ws),
clobber_reg=registers.eax)
j = registers.ebx
for i_ in i_iter:
code.add(x86.mov(j, i_))
code.add(x86.mov(registers.eax, memory.MemRef(a, index=j, scale=4)))
code.add(x86.mov(memory.MemRef(b, index=j, scale=4), registers.eax))
params = env.ExecParams()
params.p1 = A.buffer_info()[0]
params.p2 = B.buffer_info()[0]
prgm += code
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B)):
assert (B[i] == i)
def start(self, align = True):
if self.mode == CTR:
if self.external_start:
self.code.add(x86.mov(registers.ecx, self.r_start))
else:
self.code.add(x86.mov(registers.ecx, self.n))
elif self.mode == DEC:
if self.external_start:
if self.r_start == None:
raise Exception('No external start register was specified.')
if isinstance(self.r_count, memory.MemRef) and isinstance(self.r_start, memory.MemRef):
if self.r_clobber == None:
raise Exception('Must specify clobber_reg if count_reg and start values are both stored in memory.')
self.code.add(x86.mov(self.r_clobber, self.r_start))
self.code.add(x86.mov(self.r_count, self.r_clobber))
else:
self.code.add(x86.mov(self.r_count, self.r_start))
else:
self.code.add(x86.mov(self.r_count, self.n))
elif self.mode == INC:
if self.external_stop:
if self.r_stop == None:
raise Exception('No external stop register was specified.')
if self.external_start:
if isinstance(self.r_count, memory.MemRef) and isinstance(self.r_start, memory.MemRef):
self.code.add(x86_64.mov(self.r_clobber, self.r_start))
self.code.add(x86_64.mov(self.r_count, self.r_clobber))
else:
self.code.add(x86.mov(self.r_count, self.r_start))
else:
self.code.add(x86.mov(self.r_count, self.get_start()))
# /end mode if
if self.r_count is not None:
#self.current_count = var.SignedWord(code = self.code, reg = self.r_count)
self.current_count = self.r_count
# Label
self.start_label = self.code.prgm.get_unique_label("SYN_ITER_START")
self.code.add(self.start_label)
# Create continue/branch labels so they can be referenced; they will be
# added to the code in their appropriate locations.
self.continue_label = self.code.prgm.get_unique_label("SYN_ITER_CONTINUE")
return
def _synthesize_prologue(self):
"""
Create the prologue.
This manages the register preservation requirements from the ABI.
"""
# Set up the call frame and push callee-save registers
self._prologue = [self.lbl_prologue,
x86.push(ebp, ignore_active = True),
x86.mov(ebp, esp, ignore_active = True),
x86.push(edi, ignore_active = True),
x86.push(esi, ignore_active = True),
x86.push(ebx, ignore_active = True)]
return
def end(self):
"""Do post-loop iterator code"""
if self.mode == CTR:
self.code.add(x86.loop(self.start_label))
elif self.mode == DEC:
# branch if r_count is not zero (CR)
# Note that this relies on someone (e.g. cleanup()) setting the
# condition register properly.
if self.step_size() == 1:
self.code.add(x86.jnz(self.start_label))
else:
self.code.add(x86.cmp(self.r_count, 0))
self.code.add(x86.jg(self.start_label))
elif self.mode == INC:
if self.external_stop:
if isinstance(self.r_count, memory.MemRef) and isinstance(
self.r_stop, memory.MemRef):
if self.r_clobber == None:
raise Exception(
'Must specify clobber_reg if count and stop values are both stored in memory.'
)
#self.code.add(x86.push(registers.eax))
#if self.r_count.base != registers.esp:
# self.code.add(x86.mov(registers.eax, self.r_count))
#else:
# oldm = self.r_count
# m = memory.MemRef(oldm.base, oldm.disp+8, oldm.index, oldm.scale, oldm.data_size)
# self.code.add(x86.mov(registers.eax, m))
#if self.r_stop.base != registers.esp:
# self.code.add(x86.cmp(registers.eax, self.r_stop))
#else:
# oldm = self.r_stop
# m = memory.MemRef(oldm.base, oldm.disp+8, oldm.index, oldm.scale, oldm.data_size)
# self.code.add(x86.cmp(registers.eax, m))
#self.code.add(x86.pop(registers.eax))
else:
self.code.add(x86.mov(self.r_clobber, self.r_count))
self.code.add(x86.cmp(self.r_clobber, self.r_stop))
else:
self.code.add(x86.cmp(self.r_count, self.r_stop))
else:
self.code.add(x86.cmp(self.r_count, self.n))
self.code.add(x86.jnge(self.start_label))
return
def TestInt():
from corepy.arch.x86.lib.memory import MemRef
code = InstructionStream()
proc = Processor()
params = x86_exec.ExecParams()
params.p1 = 32
code.add(x86.mov(eax, spe.MemRef(ebp, 8)))
#code.add(x86.xor(code.eax, code.eax))
code.add(x86.add(eax, 1200))
code.print_code(pro=False, epi=False, binary=True)
r = proc.execute(code, debug=True, params=params)
print 'int result:', r
assert (r == 1232)
return
def _synthesize_prologue(self):
"""
Create the prologue.
This manages the register preservation requirements from the ABI.
"""
# Set up the call frame and push callee-save registers
self._prologue = [
self.lbl_prologue,
x86.push(ebp, ignore_active=True),
x86.mov(ebp, esp, ignore_active=True),
x86.push(edi, ignore_active=True),
x86.push(esi, ignore_active=True),
x86.push(ebx, ignore_active=True)
]
return
def TestInt(): from corepy.arch.x86.lib.memory import MemRef code = InstructionStream() proc = Processor() params = x86_exec.ExecParams() params.p1 = 32 code.add(x86.mov(eax, MemRef(ebp, 8))) #code.add(x86.xor(code.eax, code.eax)) code.add(x86.add(eax, 1200)) code.print_code(pro = False, epi = False, binary = True) r = proc.execute(code, debug = True, params = params) print 'int result:', r assert(r == 1232) return
def end(self):
"""Do post-loop iterator code"""
if self.mode == CTR:
self.code.add(x86.loop(self.start_label))
elif self.mode == DEC:
# branch if r_count is not zero (CR)
# Note that this relies on someone (e.g. cleanup()) setting the
# condition register properly.
if self.step_size() == 1:
self.code.add(x86.jnz(self.start_label))
else:
self.code.add(x86.cmp(self.r_count, 0))
self.code.add(x86.jg(self.start_label))
elif self.mode == INC:
if self.external_stop:
if isinstance(self.r_count, memory.MemRef) and isinstance(self.r_stop, memory.MemRef):
if self.r_clobber == None:
raise Exception('Must specify clobber_reg if count and stop values are both stored in memory.')
#self.code.add(x86.push(registers.eax))
#if self.r_count.base != registers.esp:
# self.code.add(x86.mov(registers.eax, self.r_count))
#else:
# oldm = self.r_count
# m = memory.MemRef(oldm.base, oldm.disp+8, oldm.index, oldm.scale, oldm.data_size)
# self.code.add(x86.mov(registers.eax, m))
#if self.r_stop.base != registers.esp:
# self.code.add(x86.cmp(registers.eax, self.r_stop))
#else:
# oldm = self.r_stop
# m = memory.MemRef(oldm.base, oldm.disp+8, oldm.index, oldm.scale, oldm.data_size)
# self.code.add(x86.cmp(registers.eax, m))
#self.code.add(x86.pop(registers.eax))
else:
self.code.add(x86.mov(self.r_clobber, self.r_count))
self.code.add(x86.cmp(self.r_clobber, self.r_stop))
else:
self.code.add(x86.cmp(self.r_count, self.r_stop))
else:
self.code.add(x86.cmp(self.r_count, self.n))
self.code.add(x86.jnge(self.start_label))
return
def TestDECMemMem_MemStep():
A = extarray.extarray('l', 1000)
B = extarray.extarray('l', 1000)
for i in xrange(1000):
A[i] = i
prgm = env.Program()
code = prgm.get_stream()
a = registers.esi
b = registers.edi
code.add(x86.mov(a, memory.MemRef(registers.ebp, 2 * _ws)))
code.add(x86.mov(b, memory.MemRef(registers.ebp, 3 * _ws)))
n = memory.MemRef(registers.esp, 0)
code.add(x86.sub(registers.esp, 12))
code.add(x86.mov(n, 1000))
#code.add(x86.push(1000))
s = memory.MemRef(registers.esp, 2 * _ws)
code.add(x86.mov(s, -4))
i_iter = syn_iter(code,
n,
mode=DEC,
step=s,
count_reg=memory.MemRef(registers.esp, 1 * _ws),
clobber_reg=registers.eax)
j = registers.ebx
for i_ in i_iter:
code.add(x86.mov(j, i_))
code.add(x86.mov(registers.eax, memory.MemRef(a, index=j, scale=4)))
code.add(x86.mov(memory.MemRef(b, index=j, scale=4), registers.eax))
code.add(x86.add(registers.esp, 12))
params = env.ExecParams()
params.p1 = A.buffer_info()[0] - _ws
params.p2 = B.buffer_info()[0] - _ws
prgm += code
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B) - 1, 0, -4):
assert (B[i] == i)
import corepy.arch.x86.platform as env from corepy.arch.x86.lib.memory import MemRef prgm = env.Program() code = prgm.get_stream() proc = env.Processor() # Generate sub-stream # Multiple eax by 2, add 1 subcode = prgm.get_stream() subcode.add(x86.shl(eax, 1)) subcode.add(x86.add(eax, 1)) # Initialize a register, insert code code.add(x86.mov(eax, 5)) code.add(subcode) # Add 3, insert again code.add(x86.add(eax, 3)) code.add(subcode) prgm.add(code) prgm.print_code() ret = proc.execute(prgm, mode="int") print "ret", ret prgm = env.Program() code = prgm.get_stream()
import corepy.arch.x86.platform as env from corepy.arch.x86.lib.memory import MemRef prgm = env.Program() code = prgm.get_stream() proc = env.Processor() # Generate sub-stream # Multiple eax by 2, add 1 subcode = prgm.get_stream() subcode.add(x86.shl(eax, 1)) subcode.add(x86.add(eax, 1)) # Initialize a register, insert code code.add(x86.mov(eax, 5)) code.add(subcode) # Add 3, insert again code.add(x86.add(eax, 3)) code.add(subcode) prgm.add(code) prgm.print_code() ret = proc.execute(prgm, mode='int') print "ret", ret prgm = env.Program() code = prgm.get_stream() # Use a register from the parent code in the subcode directly
def Test():
prgm = env.Program()
code = prgm.get_stream()
proc = env.Processor()
params = env.ExecParams()
params.p1 = 3
mr32 = MemRef(ebp, 8)
mr8 = MemRef(ebp, 8, data_size = 8)
lbl1 = prgm.get_label("lbl1")
lbl2 = prgm.get_label("lbl2")
code.add(x86_isa.xor(eax, eax))
code.add(x86_isa.cmp(eax, 1))
code.add(x86_isa.jne(lbl1))
code.add(x86_isa.ret())
code.add(lbl1)
code.add(x86_isa.cmp(eax, 1))
code.add(x86_isa.je(lbl2))
code.add(x86_isa.add(eax, 12))
code.add(lbl2)
prgm += code
ret = proc.execute(prgm)
print "ret", ret
assert(ret == 12)
prgm = env.Program()
code = prgm.get_stream()
fwd_lbl = prgm.get_label("FORWARD")
bck_lbl = prgm.get_label("BACKWARD")
code.add(x86_isa.xor(eax, eax))
code.add(bck_lbl)
code.add(x86_isa.cmp(eax, 1))
code.add(x86_isa.jne(fwd_lbl))
for i in xrange(0, 65):
code.add(x86_isa.pop(edi))
code.add(fwd_lbl)
prgm += code
ret = proc.execute(prgm, mode = 'int')
assert(ret == 0)
prgm = env.Program()
code = prgm.get_stream()
loop_lbl = prgm.get_label("LOOP")
out_lbl = prgm.get_label("OUT")
skip_lbl = prgm.get_label("SKIP")
code.add(x86_isa.xor(eax, eax))
code.add(loop_lbl)
r_tmp = prgm.acquire_register()
for i in range(0, 1):
for i in xrange(0, 24):
code.add(x86_isa.add(r_tmp, MemRef(esp, 4)))
code.add(x86_isa.add(eax, 4))
code.add(x86_isa.cmp(eax, 20))
code.add(x86_isa.je(out_lbl))
for i in xrange(0, 24):
code.add(x86_isa.add(r_tmp, MemRef(esp, 4)))
code.add(x86_isa.cmp(eax, 32))
code.add(x86_isa.jne(loop_lbl))
code.add(out_lbl)
code.add(x86_isa.jmp(skip_lbl))
for i in xrange(0, 2):
code.add(x86_isa.add(r_tmp, MemRef(esp, 4)))
code.add(skip_lbl)
prgm.release_register(r_tmp)
prgm += code
ret = proc.execute(prgm, mode = 'int')
print "ret", ret
assert(ret == 20)
prgm = env.Program()
code = prgm.get_stream()
loop_lbl = prgm.get_label("LOOP")
else_lbl = prgm.get_label("ELSE")
finish_lbl = prgm.get_label("finish")
code.add(x86_isa.mov(eax, -1))
code.add(x86_isa.mov(edx, 0))
code.add(loop_lbl)
code.add(x86_isa.add(eax, 1))
code.add(x86_isa.cmp(eax, 16))
code.add(x86_isa.jge(finish_lbl))
code.add(x86_isa.add(edx, eax))
code.add(x86_isa.mov(edx, edi))
code.add(x86_isa.and_(edi, 0x1))
code.add(x86_isa.jnz(else_lbl))
code.add(x86_isa.add(edx, 1))
code.add(x86_isa.jmp(loop_lbl))
code.add(else_lbl)
code.add(x86_isa.add(edx, edi))
code.add(x86_isa.jmp(loop_lbl))
code.add(finish_lbl)
code.add(x86_isa.mov(eax, edx))
prgm += code
ret = proc.execute(prgm, mode = 'int')
print "ret", ret
assert(ret == 1)
prgm = env.Program()
code = prgm.get_stream()
loop_lbl = prgm.get_label("LOOP")
code.add(x86_isa.xor(eax, eax))
code.add(x86_isa.xor(ecx, ecx))
code.add(x86_isa.mov(edx, 1))
code.add(loop_lbl)
code.add(x86_isa.inc(eax))
code.add(x86_isa.cmp(eax, 7))
code.add(x86_isa.cmove(ecx, edx))
code.add(x86_isa.jecxz(loop_lbl))
prgm += code
ret = proc.execute(prgm, mode = 'int')
print "ret", ret
assert(ret == 7)
prgm = env.Program()
code = prgm.get_stream()
code.add(x86_isa.add(eax, 200))
code.add(x86_isa.xor(eax, eax))
code.add(x86_isa.add(al, 32))
code.add(x86_isa.add(bl, 32))
code.add(x86_isa.xor(bl, bl))
code.add(x86_isa.mov(mr8, al))
code.add(x86_isa.add(mr32, 0))
code.add(x86_isa.mov(eax, mr32))
code.add(x86_isa.mov(al, mr8))
code.add(x86_isa.imul(ax, ax, 4))
code.add(x86_isa.imul(ebx, eax, 10))
code.add(x86_isa.mov(cx, 1232))
code.add(x86_isa.sub(ax, cx))
code.add(x86_isa.xor(eax,eax))
code.add(x86_isa.mov(eax,ebx))
code.add(x86_isa.clc())
code.add(x86_isa.rcl(eax, 1))
code.add(x86_isa.rcr(eax, 1))
prgm += code
#ret = proc.execute(code, debug = True, params = params)
id1 = proc.execute(prgm, params = params, mode = 'int', async = True)
id2 = proc.execute(prgm, params = params, mode = 'int', async = True)
ret = proc.execute(prgm, params = params, mode = 'int')
print "Return main thread: %d" % (ret)
ret = proc.join(id1)
print "Return thread 1: %d" % (ret)
ret = proc.join(id2)
print "Return thread 2: %d" % (ret)
prgm = env.Program()
code = prgm.get_stream()
code.add(x86_isa.fldpi())
code.add(x86_isa.fld1())
code.add(x86_isa.fadd(st0, st0))
code.add(x86_isa.fmulp())
code.add(x86_isa.fsin())
code.add(x86_isa.fcos())
code.add(x86_isa.fld1())
code.add(x86_isa.fyl2xp1())
prgm += code
ret = proc.execute(prgm, params = params, mode = 'fp')
print "Return main thread: %f" % (ret)
prgm = env.Program()
code = prgm.get_stream()
code.add(x86_isa.movd(xmm0, mr32))
code.add(x86_isa.mov(ebx, mr32))
code.add(x86_isa.movd(xmm1, ebx))
code.add(x86_isa.paddq(xmm0, xmm1))
code.add(x86_isa.pextrw(ecx, xmm0, 0))
code.add(x86_isa.pxor(mm1, mm1))
code.add(x86_isa.pinsrw(mm1, ecx, 0))
code.add(x86_isa.movq2dq(xmm0, mm1))
code.add(x86_isa.movdq2q(mm2, xmm0))
code.add(x86_isa.movd(edx,mm2))
code.add(x86_isa.movd(xmm5,edx))
code.add(x86_isa.movd(ecx, xmm5))
code.add(x86_isa.pxor(xmm6, xmm6))
code.add(x86_isa.pinsrw(xmm6, ecx, 0))
code.add(x86_isa.movd(eax, xmm6))
code.add(x86_isa.emms())
prgm += code
prgm.print_code(hex = True)
ret = proc.execute(prgm, params = params, mode = 'int')
print "Return main thread: %d" % (ret)
# Try the LOCK prefix
prgm = env.Program()
code = prgm.get_stream()
code.add(x86_isa.xor(eax, eax))
code.add(x86_isa.add(mr32, eax))
code.add(x86_isa.add(mr32, eax, lock = True))
prgm += code
prgm.print_code(hex = True)
proc.execute(prgm, params = params)
return
