Beispiel #1
0
 def _(bs):
     ints = len([x for x in arg_types if x is type_impl.Int or x is type_impl.Str or x is Raw or x is type_impl.NoneType or isinstance(x, _FuncPtr) or x is type_impl.Bool])
     floats = len([x for x in arg_types if x is type_impl.Float])
     floats_orig = floats
     pos = 0
     for arg_type in reversed(arg_types):
         type = bs.flow.stack.pop()
         assert arg_type is type, (type, arg_type)
         if type is type_impl.Int or type is type_impl.Bool:
             ints -= 1
             bs.code += isa.mov(int_regs[ints], MemRef(registers.rsp, pos))
             pos += 8
         elif isinstance(type, _FuncPtr):
             ints -= 1
             bs.code += isa.mov(int_regs[ints], MemRef(registers.rsp, pos))
             pos += 8
         elif type is type_impl.NoneType:
             ints -= 1
             bs.code += isa.mov(int_regs[ints], 0)
         elif type is Raw:
             ints -= 1
             bs.code += isa.mov(int_regs[ints], MemRef(registers.rsp, pos))
             pos += 8
             bs.code += isa.add(int_regs[ints], 8)
         elif type is type_impl.Float:
             floats -= 1
             bs.code += isa.movsd(float_regs[floats], MemRef(registers.rsp, pos))
             pos += 8
         elif type is type_impl.Str:
             ints -= 1
             bs.code += isa.mov(int_regs[ints], MemRef(registers.rsp, pos))
             bs.code += isa.test(int_regs[ints], 1)
             short = bs.program.get_unique_label()
             end = bs.program.get_unique_label()
             bs.code += isa.jnz(short)
             # long
             bs.code += isa.add(int_regs[ints], 8)
             bs.code += isa.jmp(end)
             bs.code += short
             # short
             bs.code += isa.shr(MemRef(registers.rsp, pos), 8)
             bs.code += isa.lea(int_regs[ints], MemRef(registers.rsp, pos, data_size=None))
             bs.code += end
             pos += 8
         else:
             assert False, type
     assert bs.flow.stack.pop() is self
     bs.code += isa.mov(registers.rbx, ctypes.cast(self.func, ctypes.c_void_p).value)
     bs.code += isa.mov(registers.r12, registers.rsp)
     bs.code += isa.and_(registers.rsp, -16)
     bs.code += isa.mov(registers.rax, floats)
     bs.code += isa.call(registers.rbx)
     bs.code += isa.mov(registers.rsp, registers.r12)
     bs.code += isa.add(registers.rsp, pos)
     bs.code += isa.push(registers.rax)
     bs.flow.stack.append(type_impl.Int)
Beispiel #2
0
    def end(self):
        """Do post-loop iterator code"""
        if self.mode == CTR:
            self.code.add(x86_64.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_64.jnz(self.start_label))
            else:
                self.code.add(x86_64.cmp(self.r_count, 0))
                self.code.add(x86_64.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_64.push(registers.rax))
                        #if self.r_count.base != registers.rsp:
                        #  self.code.add(x86_64.mov(registers.rax, 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_64.mov(registers.rax, m))
                        #if self.r_stop.base != registers.rsp:
                        #  self.code.add(x86_64.cmp(registers.rax, 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_64.cmp(registers.rax, m))
                        #self.code.add(x86_64.pop(registers.rax))
                    else:
                        self.code.add(x86_64.mov(self.r_clobber, self.r_count))
                        self.code.add(x86_64.cmp(self.r_clobber, self.r_stop))
                else:
                    self.code.add(x86_64.cmp(self.r_count, self.r_stop))
            else:
                self.code.add(x86_64.cmp(self.r_count, self.n))
            self.code.add(x86_64.jnge(self.start_label))

        return
Beispiel #3
0
  def end(self):
    """Do post-loop iterator code"""
    if self.mode == CTR:
      self.code.add(x86_64.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_64.jnz(self.start_label))
      else:
        self.code.add(x86_64.cmp(self.r_count, 0))
        self.code.add(x86_64.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_64.push(registers.rax))
            #if self.r_count.base != registers.rsp:
            #  self.code.add(x86_64.mov(registers.rax, 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_64.mov(registers.rax, m))
            #if self.r_stop.base != registers.rsp:
            #  self.code.add(x86_64.cmp(registers.rax, 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_64.cmp(registers.rax, m))
            #self.code.add(x86_64.pop(registers.rax))
          else:
            self.code.add(x86_64.mov(self.r_clobber, self.r_count))
            self.code.add(x86_64.cmp(self.r_clobber, self.r_stop))
        else:
          self.code.add(x86_64.cmp(self.r_count, self.r_stop))
      else:
        self.code.add(x86_64.cmp(self.r_count, self.n))
      self.code.add(x86_64.jnge(self.start_label))   

    return
Beispiel #4
0
data[0] = 0

prgm = env.Program()
code = prgm.get_stream()
x86.set_active_code(code)

x86.mov(rax, 1)
x86.mov(rcx, ITERS)
x86.mov(rdi, dbi[0])

lbl_loop = prgm.get_unique_label("loop")
code.add(lbl_loop)

x86.add(MemRef(rdi), rax)
x86.dec(rcx)
x86.jnz(lbl_loop)

prgm += code
prgm.print_code(hex = True)

proc = env.Processor()
t1 = time.time()
ids = [proc.execute(prgm, async = True) for i in xrange(0, THREADS)]
[proc.join(i) for i in ids]
t2 = time.time()

print "time", t2 - t1
print "val", data[0], ITERS * THREADS
print "passed?", data[0] == ITERS * THREADS

data[0] = 0

prgm = env.Program()
code = prgm.get_stream()
x86.set_active_code(code)

x86.mov(rax, 1)
x86.mov(rcx, ITERS)
x86.mov(rdi, dbi[0])

lbl_loop = prgm.get_unique_label("loop")
code.add(lbl_loop)

x86.add(MemRef(rdi), rax)
x86.dec(rcx)
x86.jnz(lbl_loop)

prgm += code
prgm.print_code(hex=True)

proc = env.Processor()
t1 = time.time()
ids = [proc.execute(prgm, async=True) for i in xrange(0, THREADS)]
[proc.join(i) for i in ids]
t2 = time.time()

print "time", t2 - t1
print "val", data[0], ITERS * THREADS
print "passed?", data[0] == ITERS * THREADS

# This case locks like it should, so should be correct.
Beispiel #6
0
def Test():
    code = env.InstructionStream()
    proc = env.Processor()
    params = env.ExecParams()
    params.p1 = 3
    mr32 = MemRef(rbp, 16, data_size=32)
    mr8 = MemRef(rbp, 16, data_size=8)

    lbl1 = code.get_label("lbl1")
    lbl2 = code.get_label("lbl2")

    code.add(x86.xor(rax, rax))

    code.add(x86.cmp(rax, 1))
    code.add(x86.jne(lbl1))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(lbl1)
    code.add(x86.cmp(rax, 1))
    code.add(x86.je(lbl2))
    code.add(x86.add(rax, 12))
    code.add(lbl2)

    # printer.PrintInstructionStream(code, printer.x86_64_Nasm(function_name="foobar"))
    ret = proc.execute(code)
    print "ret", ret
    assert (ret == 12)

    print "W00T"

    code.reset()

    code.add(x86.xor(rax, rax))

    code.add(x86.cmp(rax, 1))
    code.add(x86.jne(28))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(x86.cmp(eax, 1))
    code.add(x86.je(37))
    code.add(x86.add(rax, 12))

    code.print_code(hex=True, pro=True, epi=True)
    print "a"
    ret = proc.execute(code)
    print "b"
    print "ret", ret
    assert (ret == 12)

    print "w00t 2"

    code.reset()

    call_lbl = code.get_label("call_fn")

    code.add(x86.xor(rax, rax))
    code.add(x86.call(call_lbl))
    code.add(x86.jmp(code.lbl_epilogue))
    code.add(x86.mov(rax, 75))
    code.add(x86.mov(rax, 42))
    code.add(call_lbl)
    code.add(x86.mov(rax, 15))
    code.add(x86.ret())

    code.print_code()
    ret = proc.execute(code)
    print "ret", ret
    assert (ret == 15)

    code.reset()

    fwd_lbl = code.get_label("FORWARD")
    bck_lbl = code.get_label("BACKWARD")

    code.add(x86.xor(rax, rax))
    code.add(bck_lbl)
    code.add(x86.cmp(rax, 1))
    code.add(x86.jne(fwd_lbl))
    for i in xrange(0, 65):
        code.add(x86.pop(r15))
    code.add(fwd_lbl)

    ret = proc.execute(code, mode='int')
    assert (ret == 0)

    code.reset()

    loop_lbl = code.get_label("LOOP")
    out_lbl = code.get_label("OUT")
    skip_lbl = code.get_label("SKIP")

    code.add(x86.xor(rax, rax))
    code.add(loop_lbl)
    for i in range(0, 1):
        for i in xrange(0, 24):
            code.add(x86.add(r15, MemRef(rsp, 4)))

        code.add(x86.add(rax, 4))
        code.add(x86.cmp(rax, 20))
        code.add(x86.je(out_lbl))

        for i in xrange(0, 24):
            code.add(x86.add(r15, MemRef(rsp, 4)))

        code.add(x86.cmp(rax, 32))
        code.add(x86.jne(loop_lbl))

    code.add(out_lbl)

    code.add(x86.jmp(skip_lbl))
    for i in xrange(0, 2):
        code.add(x86.add(r15, MemRef(rsp, 4)))
    code.add(skip_lbl)

    ret = proc.execute(code, mode='int')
    print "ret", ret
    assert (ret == 20)

    code.reset()

    loop_lbl = code.get_label("LOOP")
    else_lbl = code.get_label("ELSE")
    finish_lbl = code.get_label("finish")

    code.add(x86.mov(rax, 0))
    code.add(x86.mov(rdx, 0))

    code.add(loop_lbl)

    code.add(x86.add(rax, 1))
    code.add(x86.cmp(rax, 16))
    code.add(x86.jge(finish_lbl))

    code.add(x86.add(rdx, rax))
    code.add(x86.mov(r8, rdx))
    code.add(x86.and_(r8, 0x1))
    code.add(x86.jnz(else_lbl))

    code.add(x86.add(rdx, 1))
    code.add(x86.jmp(loop_lbl))

    code.add(else_lbl)
    code.add(x86.add(rdx, r8))
    code.add(x86.jmp(loop_lbl))

    code.add(finish_lbl)
    code.add(x86.mov(rax, rdx))

    ret = proc.execute(code, mode='int')
    print "ret", ret
    assert (ret == 135)

    code.reset()

    loop_lbl = code.get_label("LOOP")

    code.add(x86.xor(rax, rax))
    code.add(x86.xor(rcx, rcx))
    code.add(x86.mov(rdx, 1))

    code.add(loop_lbl)
    code.add(x86.inc(rax))
    code.add(x86.cmp(rax, 7))
    code.add(x86.cmove(rcx, rdx))
    code.add(x86.jrcxz(loop_lbl))

    code.print_code(hex=True)
    ret = proc.execute(code, mode='int')
    print "ret", ret
    assert (ret == 7)

    code.reset()

    code.add(x86.mov(rax, MemRef(rbp, 16)))
    code.add(x86.xor(rbx, rbx))
    code.add(x86.mov(rbx, -1))
    code.add(x86.mov(cl, 1))
    code.add(x86.shld(rax, rbx, cl))
    code.print_code(hex=True)
    ret = proc.execute(code, params=params, mode='int')
    print "ret", ret
    assert (ret == 7)

    # code.reset()

    # code.add(x86.add(eax, 200))
    # code.add(x86.xor(eax, eax))
    # code.add(x86.add(al, 32))
    # code.add(x86.add(bl, 32))
    # code.add(x86.xor(bl, bl))
    # code.add(x86.mov(mr8, al))
    # code.add(x86.add(mr32, 0))
    # code.add(x86.mov(eax, mr32))
    # code.add(x86.mov(al, mr8))
    #
    # code.add(x86.imul(ax, ax, 4))
    # code.add(x86.imul(eax, ebx, 10))
    # code.add(x86.mov(cx, 1232))
    # code.add(x86.sub(ax, cx))
    # code.add(x86.xor(eax,eax))
    # code.add(x86.mov(eax,ebx))
    # code.add(x86.clc())
    # code.add(x86.rcl(eax, 1))
    # code.add(x86.rcr(eax, 1))

    # #ret = proc.execute(code, debug = True, params = params)
    # id1 = proc.execute(code, params = params, mode = 'int', async = True)
    # id2 = proc.execute(code, params = params, mode = 'int', async = True)
    # ret = proc.execute(code, params = params, mode = 'int')
    # print "Return main thread: %d" % (ret)
    # assert(ret == 1280)
    # ret = proc.join(id1)
    # print "Return thread 1: %d" % (ret)
    # assert(ret == 1280)
    # ret = proc.join(id2)
    # print "Return thread 2: %d" % (ret)
    # assert(ret == 1280)

    code.reset()

    code.add(x86.fldpi())
    code.add(x86.pxor(xmm0, xmm0))
    code.add(x86.fld1())
    code.add(x86.fadd(st0, st0))
    code.add(x86.fmulp())
    code.add(x86.fsin())
    code.add(x86.fcos())
    code.add(x86.fld1())
    code.add(x86.fyl2xp1())

    # x86_64 now uses xmm0 to return floats, not st0.  So here, just make room
    # on the stack, convert the FP result to an int and store it on the stack,
    # then pop it into rax, the int return register.
    code.add(x86.push(rax))
    code.add(x86.fistp(MemRef(rsp)))
    code.add(x86.pop(rax))

    code.print_code(hex=True)
    ret = proc.execute(code, params=params, mode='int')
    assert (ret == 1)
    print "Return main thread: %d" % (ret)

    code.reset()

    lbl_ok = code.get_label("OK")
    code.add(x86.emms())
    code.add(x86.movd(xmm0, mr32))
    code.add(x86.mov(ebx, mr32))

    code.add(x86.cmp(ebx, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.movd(eax, xmm0))
    code.add(x86.cmp(eax, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.ud2())

    code.add(lbl_ok)
    code.add(x86.xor(eax, eax))
    code.add(x86.movd(xmm1, ebx))
    code.add(x86.paddq(xmm0, xmm1))
    code.add(x86.pextrw(ecx, xmm0, 0))
    code.add(x86.pinsrw(mm1, ecx, 0))
    code.add(x86.movq2dq(xmm0, mm1))
    code.add(x86.movdq2q(mm2, xmm0))
    code.add(x86.movd(edx, mm2))
    code.add(x86.movd(xmm5, edx))
    code.add(x86.movd(ecx, xmm5))
    code.add(x86.pinsrw(xmm6, ecx, 0))
    code.add(x86.movd(eax, xmm6))

    code.print_code(hex=True)
    ret = proc.execute(code, params=params, mode='int')
    print "Return main thread: %d" % (ret)
    assert (ret == 6)

    code.reset()

    # Test immediate size encodings
    code.add(x86.add(eax, 300))
    code.add(x86.add(ax, 300))
    code.add(x86.add(ax, 30))
    code.add(x86.mov(eax, 16))
    code.add(x86.mov(eax, 300))

    code.reset()
    code.add(x86.add(eax, 0xDEADBEEF))
    code.add(x86.add(ebx, 0xDEADBEEF))
    code.print_code(hex=True)

    # Try the LOCK prefix
    code.reset()
    code.add(x86.xor(eax, eax))
    code.add(x86.add(mr32, eax))
    code.add(x86.add(mr32, eax, lock=True))
    #code.print_code(hex = True)

    proc.execute(code, params=params)

    code.reset()

    code.add(x86.mov(edx, 0x1234))
    code.add(x86.mov(eax, 0xFFFF))
    code.add(x86.xchg(edx, eax))

    code.print_code(hex=True)
    ret = proc.execute(code, params=params)
    print "ret:", ret
    assert (ret == 0x1234)

    code.reset()

    code.add(x86.mov(rax, rsp))
    code.add(x86.pushfq())
    code.add(x86.sub(rax, rsp))
    code.add(x86.add(rsp, rax))

    code.print_code(hex=True)
    ret = proc.execute(code, params=params)
    print "ret:", ret
    assert (ret == 8)

    code.reset()

    data = extarray.extarray('H', xrange(0, 16))

    # code.add(x86.push(rdi))
    code.add(x86.mov(rdi, data.buffer_info()[0]))
    code.add(x86.movaps(xmm1, MemRef(rdi, data_size=128)))
    code.add(x86.pextrw(rax, xmm1, 0))
    code.add(x86.pextrw(rbx, xmm1, 1))
    code.add(x86.pextrw(rcx, xmm1, 2))
    code.add(x86.pextrw(rdx, xmm1, 3))
    code.add(x86.shl(rbx, 16))
    code.add(x86.shl(rcx, 32))
    code.add(x86.shl(rdx, 48))
    code.add(x86.or_(rax, rbx))
    code.add(x86.or_(rax, rcx))
    code.add(x86.or_(rax, rdx))
    # code.add(x86.pop(rdi))

    code.print_code(hex=True)
    ret = proc.execute(code, mode='int')
    print "ret %x" % ret
    assert (ret == 0x0003000200010000)

    code.reset()
    L1 = code.get_label("L1")
    code.add(x86.xor(rax, rax))
    code.add(x86.mov(rcx, 3))
    code.add(L1)
    code.add(x86.add(rax, 1))
    code.add(x86.loop(L1))

    code.print_code(hex=True)
    ret = proc.execute(code, mode='int')
    print "ret %x" % ret
    assert (ret == 0x03)

    return
def Test():
    prgm = env.Program()
    code = prgm.get_stream()
    proc = env.Processor()
    params = env.ExecParams()
    params.p1 = 3

    lbl1 = prgm.get_label("lbl1")
    lbl2 = prgm.get_label("lbl2")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(lbl1))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(lbl1)
    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.je(lbl2))
    code.add(x86.add(prgm.gp_return, 12))
    code.add(lbl2)

    prgm.add(code)
    #prgm.print_code(pro = True, epi = True, hex = True)
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 12)

    prgm.reset()
    code.reset()

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(28))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.je(37))
    code.add(x86.add(prgm.gp_return, 12))

    prgm.add(code)
    prgm.print_code(hex=True, pro=True, epi=True)
    ret = proc.execute(prgm)
    print "ret", ret
    assert (ret == 12)

    prgm.reset()
    code.reset()

    call_lbl = prgm.get_label("call_fn")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(x86.call(call_lbl))
    code.add(x86.jmp(prgm.lbl_epilogue))
    code.add(x86.mov(prgm.gp_return, 75))
    code.add(x86.mov(prgm.gp_return, 42))
    code.add(call_lbl)
    code.add(x86.mov(prgm.gp_return, 15))
    code.add(x86.ret())

    prgm.add(code)
    prgm.print_code()
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 15)

    prgm.reset()
    code.reset()

    fwd_lbl = prgm.get_label("FORWARD")
    bck_lbl = prgm.get_label("BACKWARD")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(bck_lbl)
    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(fwd_lbl))
    r_foo = prgm.acquire_register()
    for i in xrange(0, 65):
        code.add(x86.pop(r_foo))
    prgm.release_register(r_foo)
    code.add(fwd_lbl)

    prgm.add(code)
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 0)

    prgm.reset()
    code.reset()

    loop_lbl = prgm.get_label("LOOP")
    out_lbl = prgm.get_label("OUT")
    skip_lbl = prgm.get_label("SKIP")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(loop_lbl)
    r_foo = prgm.acquire_register()
    for i in range(0, 1):
        for i in xrange(0, 24):
            code.add(x86.add(r_foo, MemRef(rsp, 4)))

        code.add(x86.add(prgm.gp_return, 4))
        code.add(x86.cmp(prgm.gp_return, 20))
        code.add(x86.je(out_lbl))

        for i in xrange(0, 24):
            code.add(x86.add(r_foo, MemRef(rsp, 4)))

        code.add(x86.cmp(prgm.gp_return, 32))
        code.add(x86.jne(loop_lbl))

    code.add(out_lbl)

    code.add(x86.jmp(skip_lbl))
    for i in xrange(0, 2):
        code.add(x86.add(r_foo, MemRef(rsp, 4)))
    code.add(skip_lbl)

    prgm.release_register(r_foo)
    prgm.add(code)
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 20)

    prgm.reset()
    code.reset()

    r_tmp = prgm.acquire_registers(2)

    loop_lbl = prgm.get_label("LOOP")
    else_lbl = prgm.get_label("ELSE")
    finish_lbl = prgm.get_label("finish")

    code.add(x86.mov(prgm.gp_return, 0))
    code.add(x86.mov(r_tmp[0], 0))

    code.add(loop_lbl)

    code.add(x86.add(prgm.gp_return, 1))
    code.add(x86.cmp(prgm.gp_return, 16))
    code.add(x86.jge(finish_lbl))

    code.add(x86.add(r_tmp[0], prgm.gp_return))
    code.add(x86.mov(r_tmp[1], r_tmp[0]))
    code.add(x86.and_(r_tmp[1], 0x1))
    code.add(x86.jnz(else_lbl))

    code.add(x86.add(r_tmp[0], 1))
    code.add(x86.jmp(loop_lbl))

    code.add(else_lbl)
    code.add(x86.add(r_tmp[0], r_tmp[1]))
    code.add(x86.jmp(loop_lbl))

    code.add(finish_lbl)
    code.add(x86.mov(prgm.gp_return, r_tmp[0]))

    prgm.release_registers(r_tmp)

    prgm.add(code)
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 135)

    prgm.reset()
    code.reset()

    loop_lbl = prgm.get_label("LOOP")

    r_one = prgm.acquire_register()
    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(x86.xor(rcx, rcx))
    code.add(x86.mov(r_one, 1))

    code.add(loop_lbl)
    code.add(x86.inc(prgm.gp_return))
    code.add(x86.cmp(prgm.gp_return, 7))
    code.add(x86.cmove(rcx, r_one))
    code.add(x86.jrcxz(loop_lbl))

    prgm.release_register(r_one)

    prgm.add(code)
    prgm.print_code(hex=True)
    ret = proc.execute(prgm, mode='int')
    print "ret", ret
    assert (ret == 7)

    prgm.reset()
    code.reset()

    r_tmp = prgm.acquire_register()
    code.add(x86.mov(prgm.gp_return, rdi))
    code.add(x86.xor(r_tmp, r_tmp))
    code.add(x86.mov(r_tmp, -1))
    code.add(x86.mov(cl, 1))
    code.add(x86.shld(prgm.gp_return, r_tmp, cl))

    prgm.release_register(r_tmp)
    prgm.add(code)
    ret = proc.execute(prgm, params=params, mode='int')
    print "ret", ret
    assert (ret == 7)

    prgm.reset()
    code.reset()

    code.add(x86.add(eax, 200))
    code.add(x86.xor(eax, eax))
    code.add(x86.add(al, 32))
    code.add(x86.add(bl, 32))
    code.add(x86.xor(bl, bl))
    code.add(x86.mov(dil, al))
    code.add(x86.add(rdi, 0))
    code.add(x86.mov(eax, edi))
    code.add(x86.mov(al, dil))

    code.add(x86.imul(ax, ax, 4))
    code.add(x86.imul(eax, ebx, 10))
    code.add(x86.mov(cx, 1232))
    code.add(x86.sub(ax, cx))
    code.add(x86.xor(eax, eax))
    code.add(x86.mov(eax, ebx))
    code.add(x86.clc())
    code.add(x86.rcl(eax, 1))
    code.add(x86.rcr(eax, 1))

    prgm.add(code)
    #ret = proc.execute(prgm, 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)
    assert (ret == 1280)
    ret = proc.join(id1)
    print "Return thread 1: %d" % (ret)
    assert (ret == 1280)
    ret = proc.join(id2)
    print "Return thread 2: %d" % (ret)
    assert (ret == 1280)

    prgm.reset()
    code.reset()

    code.add(x86.fldpi())
    code.add(x86.pxor(xmm0, xmm0))
    code.add(x86.fld1())
    code.add(x86.fadd(st0, st0))
    code.add(x86.fmulp())
    code.add(x86.fsin())
    code.add(x86.fcos())
    code.add(x86.fld1())
    code.add(x86.fyl2xp1())

    # x86_64 now uses xmm0 to return floats, not st0.  So here, just make room
    # on the stack, convert the FP result to an int and store it on the stack,
    # then pop it into rax, the int return register.
    code.add(x86.push(prgm.gp_return))
    code.add(x86.fistp(MemRef(rsp)))
    code.add(x86.pop(prgm.gp_return))

    prgm.add(code)
    prgm.print_code(hex=True)
    ret = proc.execute(prgm, params=params, mode='int')
    assert (ret == 1)
    print "Return main thread: %d" % (ret)

    prgm.reset()
    code.reset()

    lbl_ok = prgm.get_label("OK")
    code.add(x86.emms())
    code.add(x86.movd(xmm0, edi))
    code.add(x86.mov(ebx, edi))

    code.add(x86.cmp(ebx, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.movd(eax, xmm0))
    code.add(x86.cmp(eax, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.ud2())

    code.add(lbl_ok)
    code.add(x86.xor(eax, eax))
    code.add(x86.movd(xmm1, ebx))
    code.add(x86.paddq(xmm0, xmm1))
    code.add(x86.pextrw(ecx, xmm0, 0))
    code.add(x86.pxor(mm1, mm1))
    code.add(x86.pinsrw(mm1, ecx, 0))
    code.add(x86.movq2dq(xmm0, mm1))
    code.add(x86.movdq2q(mm2, xmm0))
    code.add(x86.movd(edx, mm2))
    code.add(x86.movd(xmm5, edx))
    code.add(x86.movd(ecx, xmm5))
    code.add(x86.pxor(xmm6, xmm6))
    code.add(x86.pinsrw(xmm6, ecx, 0))
    code.add(x86.movd(eax, xmm6))

    prgm.add(code)
    prgm.print_code(hex=True)
    ret = proc.execute(prgm, params=params, mode='int')
    print "Return main thread: %d" % (ret)
    assert (ret == 6)

    prgm.reset()
    code.reset()

    code.add(x86.mov(edx, 0x1234))
    code.add(x86.mov(eax, 0xFFFF))
    code.add(x86.xchg(edx, eax))

    prgm.add(code)
    prgm.print_code(hex=True)
    ret = proc.execute(prgm, params=params)
    print "ret:", ret
    assert (ret == 0x1234)

    prgm.reset()
    code.reset()

    code.add(x86.mov(prgm.gp_return, rsp))
    code.add(x86.pushfq())
    code.add(x86.sub(prgm.gp_return, rsp))
    code.add(x86.add(rsp, prgm.gp_return))

    prgm.add(code)
    prgm.print_code(hex=True)
    ret = proc.execute(prgm, params=params)
    print "ret:", ret
    assert (ret == 8)

    prgm.reset()
    code.reset()

    data = extarray.extarray('H', xrange(0, 16))

    r_128 = prgm.acquire_register(reg_type=XMMRegister)
    regs = prgm.acquire_registers(4)

    code.add(x86.mov(regs[0], data.buffer_info()[0]))
    code.add(x86.movaps(r_128, MemRef(regs[0], data_size=128)))
    code.add(x86.pextrw(prgm.gp_return, r_128, 0))
    code.add(x86.pextrw(regs[1], r_128, 1))
    code.add(x86.pextrw(regs[2], r_128, 2))
    code.add(x86.pextrw(regs[3], r_128, 3))
    code.add(x86.shl(regs[1], 16))
    code.add(x86.shl(regs[2], 32))
    code.add(x86.shl(regs[3], 48))
    code.add(x86.or_(prgm.gp_return, regs[1]))
    code.add(x86.or_(prgm.gp_return, regs[2]))
    code.add(x86.or_(prgm.gp_return, regs[3]))

    prgm.release_register(r_128)
    prgm.release_registers(regs)

    prgm.add(code)
    prgm.print_code()
    ret = proc.execute(prgm, mode='int')
    print "ret %x" % ret
    assert (ret == 0x0003000200010000)

    prgm.reset()
    code.reset()

    util.load_float(code, xmm0, 3.14159)

    prgm.add(code)
    ret = proc.execute(prgm, mode='fp')
    print "ret", ret
    assert (ret - 3.14159 < 0.00001)

    return
def Test():
    prgm = env.Program()
    code = prgm.get_stream()
    proc = env.Processor()
    params = env.ExecParams()
    params.p1 = 3

    lbl1 = prgm.get_label("lbl1")
    lbl2 = prgm.get_label("lbl2")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(lbl1))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(lbl1)
    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.je(lbl2))
    code.add(x86.add(prgm.gp_return, 12))
    code.add(lbl2)

    prgm.add(code)
    #prgm.print_code(pro = True, epi = True, hex = True) 
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 12)

    prgm.reset()
    code.reset()

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(28))

    code.add(x86.ud2())
    code.add(x86.ud2())

    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.je(37))
    code.add(x86.add(prgm.gp_return, 12))

    prgm.add(code)
    prgm.print_code(hex = True, pro = True, epi = True) 
    ret = proc.execute(prgm)
    print "ret", ret
    assert(ret == 12)

    prgm.reset()
    code.reset()

    call_lbl = prgm.get_label("call_fn")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(x86.call(call_lbl))
    code.add(x86.jmp(prgm.lbl_epilogue))
    code.add(x86.mov(prgm.gp_return, 75))
    code.add(x86.mov(prgm.gp_return, 42))
    code.add(call_lbl)
    code.add(x86.mov(prgm.gp_return, 15))
    code.add(x86.ret())

    prgm.add(code)
    prgm.print_code()
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 15)


    prgm.reset()
    code.reset()

    fwd_lbl = prgm.get_label("FORWARD")
    bck_lbl = prgm.get_label("BACKWARD")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(bck_lbl)
    code.add(x86.cmp(prgm.gp_return, 1))
    code.add(x86.jne(fwd_lbl))
    r_foo = prgm.acquire_register()
    for i in xrange(0, 65):
      code.add(x86.pop(r_foo))
    prgm.release_register(r_foo)
    code.add(fwd_lbl)

    prgm.add(code)
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 0)


    prgm.reset()
    code.reset()

    loop_lbl = prgm.get_label("LOOP")
    out_lbl = prgm.get_label("OUT")
    skip_lbl = prgm.get_label("SKIP")

    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(loop_lbl)
    r_foo = prgm.acquire_register()
    for i in range(0, 1):
      for i in xrange(0, 24):
        code.add(x86.add(r_foo, MemRef(rsp, 4)))

      code.add(x86.add(prgm.gp_return, 4))
      code.add(x86.cmp(prgm.gp_return, 20))
      code.add(x86.je(out_lbl))

      for i in xrange(0, 24):
        code.add(x86.add(r_foo, MemRef(rsp, 4)))

      code.add(x86.cmp(prgm.gp_return, 32))
      code.add(x86.jne(loop_lbl))

    code.add(out_lbl)

    code.add(x86.jmp(skip_lbl))
    for i in xrange(0, 2):
      code.add(x86.add(r_foo, MemRef(rsp, 4)))
    code.add(skip_lbl)

    prgm.release_register(r_foo)
    prgm.add(code)
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 20)


    prgm.reset()
    code.reset()

    r_tmp = prgm.acquire_registers(2)

    loop_lbl = prgm.get_label("LOOP")
    else_lbl = prgm.get_label("ELSE")
    finish_lbl = prgm.get_label("finish")

    code.add(x86.mov(prgm.gp_return, 0))
    code.add(x86.mov(r_tmp[0], 0))

    code.add(loop_lbl)

    code.add(x86.add(prgm.gp_return, 1))
    code.add(x86.cmp(prgm.gp_return, 16))
    code.add(x86.jge(finish_lbl))

    code.add(x86.add(r_tmp[0], prgm.gp_return))
    code.add(x86.mov(r_tmp[1], r_tmp[0]))
    code.add(x86.and_(r_tmp[1], 0x1))
    code.add(x86.jnz(else_lbl))

    code.add(x86.add(r_tmp[0], 1))
    code.add(x86.jmp(loop_lbl))

    code.add(else_lbl)
    code.add(x86.add(r_tmp[0], r_tmp[1]))
    code.add(x86.jmp(loop_lbl))

    code.add(finish_lbl)
    code.add(x86.mov(prgm.gp_return, r_tmp[0]))

    prgm.release_registers(r_tmp)

    prgm.add(code)
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 135)


    prgm.reset()
    code.reset()

    loop_lbl = prgm.get_label("LOOP")

    r_one = prgm.acquire_register()
    code.add(x86.xor(prgm.gp_return, prgm.gp_return))
    code.add(x86.xor(rcx, rcx))
    code.add(x86.mov(r_one, 1))

    code.add(loop_lbl)
    code.add(x86.inc(prgm.gp_return))
    code.add(x86.cmp(prgm.gp_return, 7))
    code.add(x86.cmove(rcx, r_one))
    code.add(x86.jrcxz(loop_lbl))

    prgm.release_register(r_one)

    prgm.add(code)
    prgm.print_code(hex = True)
    ret = proc.execute(prgm, mode = 'int')
    print "ret", ret
    assert(ret == 7)


    prgm.reset()
    code.reset()

    r_tmp = prgm.acquire_register()
    code.add(x86.mov(prgm.gp_return, rdi))
    code.add(x86.xor(r_tmp, r_tmp))
    code.add(x86.mov(r_tmp, -1))
    code.add(x86.mov(cl, 1))
    code.add(x86.shld(prgm.gp_return, r_tmp, cl))

    prgm.release_register(r_tmp)
    prgm.add(code)
    ret = proc.execute(prgm, params = params, mode = 'int')
    print "ret", ret
    assert(ret == 7)


    prgm.reset()
    code.reset()

    code.add(x86.add(eax, 200))
    code.add(x86.xor(eax, eax))
    code.add(x86.add(al, 32))
    code.add(x86.add(bl, 32))
    code.add(x86.xor(bl, bl))
    code.add(x86.mov(dil, al))
    code.add(x86.add(rdi, 0))
    code.add(x86.mov(eax, edi))
    code.add(x86.mov(al, dil))

    code.add(x86.imul(ax, ax, 4))
    code.add(x86.imul(eax, ebx, 10))
    code.add(x86.mov(cx, 1232))
    code.add(x86.sub(ax, cx))
    code.add(x86.xor(eax,eax))
    code.add(x86.mov(eax,ebx))
    code.add(x86.clc())
    code.add(x86.rcl(eax, 1))
    code.add(x86.rcr(eax, 1))


    prgm.add(code)
    #ret = proc.execute(prgm, 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)
    assert(ret == 1280)
    ret = proc.join(id1)
    print "Return thread 1: %d" % (ret)
    assert(ret == 1280)
    ret = proc.join(id2)
    print "Return thread 2: %d" % (ret)
    assert(ret == 1280)


    prgm.reset()
    code.reset()

    code.add(x86.fldpi())
    code.add(x86.pxor(xmm0, xmm0))
    code.add(x86.fld1())
    code.add(x86.fadd(st0, st0))
    code.add(x86.fmulp())
    code.add(x86.fsin())
    code.add(x86.fcos())
    code.add(x86.fld1())
    code.add(x86.fyl2xp1())

    # x86_64 now uses xmm0 to return floats, not st0.  So here, just make room
    # on the stack, convert the FP result to an int and store it on the stack,
    # then pop it into rax, the int return register.
    code.add(x86.push(prgm.gp_return))
    code.add(x86.fistp(MemRef(rsp)))
    code.add(x86.pop(prgm.gp_return))

    prgm.add(code)
    prgm.print_code(hex = True)
    ret = proc.execute(prgm, params = params, mode = 'int')
    assert(ret == 1)
    print "Return main thread: %d" % (ret)


    prgm.reset()
    code.reset()

    lbl_ok = prgm.get_label("OK")
    code.add(x86.emms())
    code.add(x86.movd(xmm0, edi))
    code.add(x86.mov(ebx, edi))

    code.add(x86.cmp(ebx, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.movd(eax, xmm0))
    code.add(x86.cmp(eax, 3))
    code.add(x86.je(lbl_ok))
    code.add(x86.ud2())

    code.add(lbl_ok)
    code.add(x86.xor(eax, eax))
    code.add(x86.movd(xmm1, ebx))
    code.add(x86.paddq(xmm0, xmm1))
    code.add(x86.pextrw(ecx, xmm0, 0))
    code.add(x86.pxor(mm1, mm1))
    code.add(x86.pinsrw(mm1, ecx, 0))
    code.add(x86.movq2dq(xmm0, mm1))
    code.add(x86.movdq2q(mm2, xmm0))
    code.add(x86.movd(edx,mm2))
    code.add(x86.movd(xmm5,edx))
    code.add(x86.movd(ecx, xmm5))
    code.add(x86.pxor(xmm6, xmm6))
    code.add(x86.pinsrw(xmm6, ecx, 0))
    code.add(x86.movd(eax, xmm6))

    prgm.add(code)
    prgm.print_code(hex = True)
    ret = proc.execute(prgm, params = params, mode = 'int')
    print "Return main thread: %d" % (ret)
    assert(ret == 6)


    prgm.reset()
    code.reset()

    code.add(x86.mov(edx, 0x1234))
    code.add(x86.mov(eax, 0xFFFF))
    code.add(x86.xchg(edx, eax))

    prgm.add(code)
    prgm.print_code(hex = True)
    ret = proc.execute(prgm, params = params)
    print "ret:", ret
    assert(ret == 0x1234)


    prgm.reset()
    code.reset()

    code.add(x86.mov(prgm.gp_return, rsp))
    code.add(x86.pushfq())
    code.add(x86.sub(prgm.gp_return, rsp))
    code.add(x86.add(rsp, prgm.gp_return))

    prgm.add(code)
    prgm.print_code(hex = True)
    ret = proc.execute(prgm, params = params)
    print "ret:", ret
    assert(ret == 8)


    prgm.reset()
    code.reset()

    data = extarray.extarray('H', xrange(0, 16))

    r_128 = prgm.acquire_register(reg_type = XMMRegister)
    regs = prgm.acquire_registers(4)

    code.add(x86.mov(regs[0], data.buffer_info()[0]))
    code.add(x86.movaps(r_128, MemRef(regs[0], data_size = 128)))
    code.add(x86.pextrw(prgm.gp_return, r_128, 0))
    code.add(x86.pextrw(regs[1], r_128, 1))
    code.add(x86.pextrw(regs[2], r_128, 2))
    code.add(x86.pextrw(regs[3], r_128, 3))
    code.add(x86.shl(regs[1], 16))
    code.add(x86.shl(regs[2], 32))
    code.add(x86.shl(regs[3], 48))
    code.add(x86.or_(prgm.gp_return, regs[1]))
    code.add(x86.or_(prgm.gp_return, regs[2]))
    code.add(x86.or_(prgm.gp_return, regs[3]))

    prgm.release_register(r_128)
    prgm.release_registers(regs)

    prgm.add(code)
    prgm.print_code()
    ret = proc.execute(prgm, mode = 'int')
    print "ret %x" % ret
    assert(ret == 0x0003000200010000)


    prgm.reset()
    code.reset()

    util.load_float(code, xmm0, 3.14159)

    prgm.add(code)
    ret = proc.execute(prgm, mode = 'fp')
    print "ret", ret
    assert(ret - 3.14159 < 0.00001)

    return
Beispiel #9
0
 def _(bs):
     ints = len([
         x for x in arg_types if x is type_impl.Int
         or x is type_impl.Str or x is Raw or x is type_impl.NoneType
         or isinstance(x, _FuncPtr) or x is type_impl.Bool
     ])
     floats = len([x for x in arg_types if x is type_impl.Float])
     floats_orig = floats
     pos = 0
     for arg_type in reversed(arg_types):
         type = bs.flow.stack.pop()
         assert arg_type is type, (type, arg_type)
         if type is type_impl.Int or type is type_impl.Bool:
             ints -= 1
             bs.code += isa.mov(int_regs[ints],
                                MemRef(registers.rsp, pos))
             pos += 8
         elif isinstance(type, _FuncPtr):
             ints -= 1
             bs.code += isa.mov(int_regs[ints],
                                MemRef(registers.rsp, pos))
             pos += 8
         elif type is type_impl.NoneType:
             ints -= 1
             bs.code += isa.mov(int_regs[ints], 0)
         elif type is Raw:
             ints -= 1
             bs.code += isa.mov(int_regs[ints],
                                MemRef(registers.rsp, pos))
             pos += 8
             bs.code += isa.add(int_regs[ints], 8)
         elif type is type_impl.Float:
             floats -= 1
             bs.code += isa.movsd(float_regs[floats],
                                  MemRef(registers.rsp, pos))
             pos += 8
         elif type is type_impl.Str:
             ints -= 1
             bs.code += isa.mov(int_regs[ints],
                                MemRef(registers.rsp, pos))
             bs.code += isa.test(int_regs[ints], 1)
             short = bs.program.get_unique_label()
             end = bs.program.get_unique_label()
             bs.code += isa.jnz(short)
             # long
             bs.code += isa.add(int_regs[ints], 8)
             bs.code += isa.jmp(end)
             bs.code += short
             # short
             bs.code += isa.shr(MemRef(registers.rsp, pos), 8)
             bs.code += isa.lea(
                 int_regs[ints],
                 MemRef(registers.rsp, pos, data_size=None))
             bs.code += end
             pos += 8
         else:
             assert False, type
     assert bs.flow.stack.pop() is self
     bs.code += isa.mov(registers.rbx,
                        ctypes.cast(self.func, ctypes.c_void_p).value)
     bs.code += isa.mov(registers.r12, registers.rsp)
     bs.code += isa.and_(registers.rsp, -16)
     bs.code += isa.mov(registers.rax, floats)
     bs.code += isa.call(registers.rbx)
     bs.code += isa.mov(registers.rsp, registers.r12)
     bs.code += isa.add(registers.rsp, pos)
     bs.code += isa.push(registers.rax)
     bs.flow.stack.append(type_impl.Int)