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 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