def TestCTRImm():
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.r8
b = registers.r9
#code.add(x86_64.mov(a, memory.MemRef(registers.rbp, 2*_ws)))
#code.add(x86_64.mov(b, memory.MemRef(registers.rbp, 3*_ws)))
code.add(x86_64.mov(a, registers.rdi))
code.add(x86_64.mov(b, registers.rsi))
i_iter = syn_iter(code, 1000, mode=CTR)
for i_ in i_iter:
code.add(x86_64.mov(registers.r11, memory.MemRef(a, index=i_,
scale=8)))
code.add(x86_64.mov(memory.MemRef(b, index=i_, scale=8),
registers.r11))
prgm.add(code)
params = env.ExecParams()
params.p1 = A.buffer_info()[0] - _ws
params.p2 = B.buffer_info()[0] - _ws
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B)):
assert (B[i] == i)
def load_double(code, reg, val):
data = extarray.extarray('d', (val, ))
data.change_type('L')
# reg better be an mmx or xmm, should we check?
code.add(x86.push(data[0]))
code.add(x86.pshufd(reg, mem.MemRef(regs.rsp, data_size=128), 0x44))
return code.add(x86.add(regs.rsp, 8))
def load_float(code, reg, val, clear=False):
data = extarray.extarray('f', (val, ))
data.change_type('I')
# reg better be an mmx or xmm, should we check?
code.add(x86.push(data[0]))
code.add(x86.pshufd(reg, mem.MemRef(regs.rsp, data_size=128), 0))
return code.add(x86.add(regs.rsp, 8))
def CpuidAsmInit():
import corepy.arch.x86_64.isa as x86
import corepy.arch.x86_64.types.registers as reg
import corepy.arch.x86_64.platform as env
import corepy.arch.x86_64.lib.memory as mem
global CpuidCode
global CpuidProc
global CpuidParams
CpuidCode = env.InstructionStream()
CpuidProc = env.Processor()
CpuidParams = env.ExecParams()
CpuidCode.add(x86.mov(reg.rax, mem.MemRef(reg.rbp, 16))) # parameter 1
CpuidCode.add(x86.mov(reg.rcx, mem.MemRef(reg.rbp, 24))) # parameter 2
CpuidCode.add(x86.mov(reg.rdi, mem.MemRef(reg.rbp, 32))) # parameter 3
CpuidCode.add(x86.push(reg.rax)) # save input parameter
CpuidCode.add(x86.cpuid())
CpuidCode.add(x86.mov(mem.MemRef(reg.edi, 0, data_size=32), reg.eax))
CpuidCode.add(x86.mov(mem.MemRef(reg.edi, 4, data_size=32), reg.ebx))
CpuidCode.add(x86.mov(mem.MemRef(reg.edi, 8, data_size=32), reg.ecx))
CpuidCode.add(x86.mov(mem.MemRef(reg.edi, 12, data_size=32), reg.edx))
CpuidCode.add(x86.pop(reg.rax)) # restore input parameter as return value
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.r8
b = registers.r9
#code.add(x86_64.mov(a, memory.MemRef(registers.rbp, 2*_ws)))
#code.add(x86_64.mov(b, memory.MemRef(registers.rbp, 3*_ws)))
code.add(x86_64.mov(a, registers.rdi))
code.add(x86_64.mov(b, registers.rsi))
n = memory.MemRef(registers.rsp, 0)
code.add(x86_64.mov(n, 1000))
s = memory.MemRef(registers.rsp, -2 * _ws)
code.add(x86_64.mov(s, -4))
i_iter = syn_iter(code,
n,
mode=DEC,
step=s,
count_reg=memory.MemRef(registers.rsp, -1 * _ws),
clobber_reg=registers.rax)
j = registers.rsi
for i_ in i_iter:
code.add(x86_64.mov(j, i_))
code.add(x86_64.mov(registers.r11, memory.MemRef(a, index=j, scale=8)))
code.add(x86_64.mov(memory.MemRef(b, index=j, scale=8), registers.r11))
prgm.add(code)
params = env.ExecParams()
params.p1 = A.buffer_info()[0] - _ws
params.p2 = B.buffer_info()[0] - _ws
proc = env.Processor()
proc.execute(prgm, mode='int', params=params)
for i in range(len(B) - 1, 0, -4):
assert (B[i] == i)
def load_float(code, reg, val, clear=False):
data = extarray.extarray('f', (val, ))
data.change_type('I')
# reg better be an mmx or xmm, should we check?
code.add(x86.push(data[0]))
code.add(x86.movd(reg, mem.MemRef(regs.rsp, data_size=32)))
ret = code.add(x86.add(regs.rsp, 8))
if clear == False:
# Need to duplicate the value out across now
# Assumes reg is xmm
ret = x86.pshufd(reg, reg, 0)
return ret
def __init__(self):
import corepy.lib.printer as printer
import corepy.arch.x86_64.isa as x86
import corepy.arch.x86_64.types.registers as reg
import corepy.arch.x86_64.platform as env
import corepy.arch.x86_64.lib.memory as mem
self.code = env.InstructionStream()
self.proc = env.Processor()
self.params = env.ExecParams()
self.code.add(x86.mov(reg.rax, mem.MemRef(reg.rbp, 16)))
self.code.add(x86.mov(reg.dx, 0x0cf8))
self.code.add(x86.out(reg.dx, reg.eax))
self.code.add(x86.mov(reg.dx, 0x0cfc))
self.code.add(x86.in_(reg.eax, reg.dx))
def MsrAsmInit():
import corepy.arch.x86_64.isa as x86
import corepy.arch.x86_64.types.registers as reg
import corepy.arch.x86_64.lib.memory as mem
# WrMsrAsm (EDX, EAX, ECX)
# MSR[ECX] = EDX:EAX;
global WrMsrAsm
WrMsrAsm = env.InstructionStream()
WrMsrAsm.add(x86.mov(reg.rdx, mem.MemRef(reg.rbp,
16))) # parameter 1, rdx, IN
WrMsrAsm.add(x86.mov(reg.rax, mem.MemRef(reg.rbp,
24))) # parameter 2, rax, IN
WrMsrAsm.add(x86.mov(reg.rcx, mem.MemRef(reg.rbp,
32))) # parameter 3, rcx, IN
WrMsrAsm.add(x86.push(reg.rcx))
WrMsrAsm.add(x86.wrmsr())
WrMsrAsm.add(x86.pop(reg.rax))
# RdMsrAsm (EDX, EAX, ECX)
# EDX:EAX = MSR[ECX];
global RdMsrAsm
RdMsrAsm = env.InstructionStream()
RdMsrAsm.add(x86.mov(reg.rdi, mem.MemRef(reg.rbp,
16))) # parameter 1, rdx, OUT
RdMsrAsm.add(x86.mov(reg.rsi, mem.MemRef(reg.rbp,
24))) # parameter 2, rax, OUT
RdMsrAsm.add(x86.mov(reg.rcx, mem.MemRef(reg.rbp,
32))) # parameter 3, rcx, IN
WrMsrAsm.add(x86.push(reg.rcx))
RdMsrAsm.add(x86.rdmsr())
RdMsrAsm.add(x86.mov(mem.MemRef(reg.rdi),
reg.rdx)) # parameter 1, rdx, OUT
RdMsrAsm.add(x86.mov(mem.MemRef(reg.rsi),
reg.rax)) # parameter 2, rax, OUT
WrMsrAsm.add(x86.pop(reg.rax))
#code.cache_code()
#code.print_code(pro = True, epi = True)
#PrintInstructionStream(code, Default(show_prologue = True, show_epilogue = True, line_numbers = True, show_hex = True))
#PrintInstructionStream(code, Default())
#PrintInstructionStream(code, SPU_Asm(comment_chan = True))
import corepy.arch.x86_64.platform as env
import corepy.arch.x86_64.isa as x86
import corepy.arch.x86_64.types.registers as regs
import corepy.arch.x86_64.lib.memory as mem
code = env.InstructionStream()
code.add(x86.mov(regs.rax, 0xDEADBEEF))
code.add(x86.add(regs.rax, 0xDEADBEEF))
code.add(x86.call(-6))
code.add(
x86.div(
mem.MemRef(regs.r8,
1048576,
regs.r13,
4,
data_size=16,
addr_size=32)))
code.add(x86.sub(regs.rax, 0xBEEF))
code.add(x86.mov(regs.rax, mem.MemRef(regs.rbp, 8)))
code.cache_code()
PrintInstructionStream(code, Default(show_hex=True))
PrintInstructionStream(code, x86_64_Nasm(function_name="foobar"))
