Beispiel #1
0
def load_double(code, reg, val):
  data = extarray.extarray('d', (val,))
  data.change_type('I')

  # reg better be an mmx or xmm, should we check?
  code.add(x86.push(data[0]))
  code.add(x86.push(data[1]))
  code.add(x86.pshufd(reg, mem.MemRef(regs.rsp, data_size = 128), 0x44))
  return code.add(x86.add(regs.rsp, 8))
Beispiel #2
0
  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
Beispiel #3
0
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)
Beispiel #4
0
def TestDECMem():
    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.push(1000))
    i_iter = syn_iter(code, n, mode=DEC, count_reg=registers.ecx)
    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))

    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(1, len(B)):
        assert (B[i] == i)
Beispiel #5
0
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))
Beispiel #6
0
    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
Beispiel #7
0
def TestDECMemMem_RegStep():
    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.mov(n, 1000))
    code.add(x86.push(1000))
    s = registers.edx
    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, 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)