[pypy-svn] r70204 - in pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86: . test
arigo at codespeak.net
arigo at codespeak.net
Fri Dec 18 19:14:25 CET 2009
Author: arigo
Date: Fri Dec 18 19:14:24 2009
New Revision: 70204
Modified:
pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/jump.py
pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/regalloc.py
pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/test/test_jump.py
Log:
Make test_jump.py pass again.
Modified: pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/jump.py
==============================================================================
--- pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/jump.py (original)
+++ pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/jump.py Fri Dec 18 19:14:24 2009
@@ -1,22 +1,6 @@
import sys
from pypy.tool.pairtype import extendabletype
-from pypy.jit.backend.x86.ri386 import *
-
-class __extend__(OPERAND):
- __metaclass__ = extendabletype
- def _getregkey(self):
- raise AssertionError("should only happen to registers and frame "
- "positions")
-
-class __extend__(REG):
- __metaclass__ = extendabletype
- def _getregkey(self):
- return ~self.op
-
-class __extend__(MODRM):
- __metaclass__ = extendabletype
- def _getregkey(self):
- return self.position
+from pypy.jit.backend.x86.regalloc import AssemblerLocation, StackLoc, RegLoc
def remap_frame_layout(assembler, src_locations, dst_locations, tmpreg):
@@ -27,7 +11,7 @@
srccount[dst._getregkey()] = 0
for i in range(len(dst_locations)):
src = src_locations[i]
- if isinstance(src, IMM32):
+ if not isinstance(src, AssemblerLocation): # if it's a constant
continue
key = src._getregkey()
if key in srccount:
@@ -46,7 +30,7 @@
srccount[key] = -1 # means "it's done"
pending_dests -= 1
src = src_locations[i]
- if not isinstance(src, IMM32):
+ if isinstance(src, AssemblerLocation):
key = src._getregkey()
if key in srccount:
srccount[key] -= 1
@@ -80,7 +64,11 @@
assert pending_dests == 0
def _move(assembler, src, dst, tmpreg):
- if isinstance(dst, MODRM) and isinstance(src, MODRM):
- assembler.regalloc_mov(src, tmpreg)
- src = tmpreg
- assembler.regalloc_mov(src, dst)
+ if isinstance(dst, StackLoc):
+ if isinstance(src, StackLoc):
+ assembler.regalloc_load(src, tmpreg)
+ src = tmpreg
+ assembler.regalloc_store(src, dst)
+ else:
+ assert isinstance(dst, RegLoc)
+ assembler.regalloc_load(src, dst)
Modified: pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/regalloc.py
==============================================================================
--- pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/regalloc.py (original)
+++ pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/regalloc.py Fri Dec 18 19:14:24 2009
@@ -5,14 +5,14 @@
from pypy.jit.metainterp.history import (Box, Const, ConstInt, ConstPtr,
ResOperation, ConstAddr, BoxPtr,
LoopToken, INT, REF, FLOAT)
-from pypy.jit.backend.x86.ri386 import *
+from pypy.jit.backend.x86 import rx86
from pypy.rpython.lltypesystem import lltype, ll2ctypes, rffi, rstr
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.unroll import unrolling_iterable
from pypy.rlib import rgc
from pypy.jit.backend.llsupport import symbolic
-from pypy.jit.backend.x86.jump import remap_frame_layout
from pypy.jit.metainterp.resoperation import rop
+from pypy.jit.metainterp.history import AbstractValue
from pypy.jit.backend.llsupport.descr import BaseFieldDescr, BaseArrayDescr
from pypy.jit.backend.llsupport.descr import BaseCallDescr, BaseSizeDescr
from pypy.jit.backend.llsupport.regalloc import FrameManager, RegisterManager,\
@@ -22,6 +22,37 @@
FRAME_FIXED_SIZE = 5 # ebp + ebx + esi + edi + force_index = 5 words
FORCE_INDEX_OFS = -4*WORD
+
+class AssemblerLocation(AbstractValue):
+ __slots__ = 'value'
+ def _getregkey(self):
+ return self.value
+
+class StackLoc(AssemblerLocation):
+ def __init__(self, position, ebp_offset):
+ assert ebp_offset < 0 # so no confusion with RegLoc._loc
+ self.position = position
+ self.value = ebp_offset
+ def __repr__(self):
+ return '%d(%%ebp)' % (self.value,)
+
+class RegLoc(AssemblerLocation):
+ def __init__(self, regnum):
+ assert regnum >= 0
+ self.value = regnum
+ def __repr__(self):
+ return rx86.R.names[self.value]
+
+class XmmRegLoc(RegLoc):
+ def __repr__(self):
+ return rx86.R.xmmnames[self.value]
+
+REGLOCS = [RegLoc(i) for i in range(8)]
+XMMREGLOCS = [XmmRegLoc(i) for i in range(8)]
+eax, ecx, edx, ebx, esp, ebp, esi, edi = REGLOCS
+xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7 = XMMREGLOCS
+
+
width_of_type = {
INT : 1,
REF : 1,
@@ -38,20 +69,6 @@
def call_result_location(self, v):
return eax
- def convert_to_imm(self, c):
- if isinstance(c, ConstInt):
- return imm(c.value)
- elif isinstance(c, ConstPtr):
- if we_are_translated() and c.value and rgc.can_move(c.value):
- print "convert_to_imm: ConstPtr needs special care"
- raise AssertionError
- return imm(rffi.cast(lltype.Signed, c.value))
- elif isinstance(c, ConstAddr):
- return imm(ll2ctypes.cast_adr_to_int(c.value))
- else:
- print "convert_to_imm: got a %s" % c
- raise AssertionError
-
BASE_CONSTANT_SIZE = 1000
@@ -73,15 +90,15 @@
self.constant_arrays = [self.new_const_array()]
self.constant_array_counter = 0
- def convert_to_imm(self, c):
- if self.constant_array_counter >= BASE_CONSTANT_SIZE:
- self.constant_arrays.append(self.new_const_array())
- self.constant_array_counter = 0
- res = self.constant_array_counter
- self.constant_array_counter += 1
- arr = self.constant_arrays[-1]
- arr[res] = c.getfloat()
- return self.get_addr_of_const_float(-1, res)
+## def convert_to_imm(self, c):
+## if self.constant_array_counter >= BASE_CONSTANT_SIZE:
+## self.constant_arrays.append(self.new_const_array())
+## self.constant_array_counter = 0
+## res = self.constant_array_counter
+## self.constant_array_counter += 1
+## arr = self.constant_arrays[-1]
+## arr[res] = c.getfloat()
+## return self.get_addr_of_const_float(-1, res)
def get_addr_of_const_float(self, num_arr, num_pos):
arr = self.constant_arrays[num_arr]
@@ -98,14 +115,12 @@
@staticmethod
def frame_pos(i, size):
if size == 1:
- res = mem(ebp, get_ebp_ofs(i))
+ return StackLoc(i, get_ebp_ofs(i))
elif size == 2:
- res = mem64(ebp, get_ebp_ofs(i + 1))
+ return StackLoc(i, get_ebp_ofs(i + 1))
else:
print "Unimplemented size %d" % i
raise NotImplementedError("unimplemented size %d" % i)
- res.position = i
- return res
class RegAlloc(object):
exc = False
@@ -152,8 +167,8 @@
def _process_inputargs(self, inputargs):
# XXX we can sort out here by longevity if we need something
# more optimal
- floatlocs = [None] * len(inputargs)
- nonfloatlocs = [None] * len(inputargs)
+ floatlocs = [-1] * len(inputargs)
+ nonfloatlocs = [-1] * len(inputargs)
# Don't use all_regs[0] for passing arguments around a loop.
# Must be kept in sync with consider_jump().
# XXX this should probably go to llsupport/regalloc.py
@@ -878,6 +893,7 @@
consider_unicodegetitem = consider_strgetitem
def consider_jump(self, op, ignored):
+ from pypy.jit.backend.x86.jump import remap_frame_layout
assembler = self.assembler
assert self.jump_target_descr is None
descr = op.descr
Modified: pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/test/test_jump.py
==============================================================================
--- pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/test/test_jump.py (original)
+++ pypy/branch/remove-ri386-multimethod-2/pypy/jit/backend/x86/test/test_jump.py Fri Dec 18 19:14:24 2009
@@ -1,5 +1,7 @@
-from pypy.jit.backend.x86.ri386 import *
+from pypy.jit.metainterp.history import ConstInt
from pypy.jit.backend.x86.regalloc import X86FrameManager
+from pypy.jit.backend.x86.regalloc import StackLoc, RegLoc
+from pypy.jit.backend.x86.regalloc import eax, ebx, ecx, edx, esi, edi
from pypy.jit.backend.x86.jump import remap_frame_layout
frame_pos = X86FrameManager.frame_pos
@@ -8,8 +10,15 @@
def __init__(self):
self.ops = []
- def regalloc_mov(self, from_loc, to_loc):
- self.ops.append(('mov', from_loc, to_loc))
+ def regalloc_load(self, from_loc, to_loc):
+ assert isinstance(from_loc, (RegLoc, StackLoc, ConstInt))
+ assert isinstance(to_loc, RegLoc)
+ self.ops.append(('load', from_loc, to_loc))
+
+ def regalloc_store(self, from_loc, to_loc):
+ assert isinstance(from_loc, (RegLoc, ConstInt))
+ assert isinstance(to_loc, StackLoc)
+ self.ops.append(('store', from_loc, to_loc))
def regalloc_push(self, loc):
self.ops.append(('push', loc))
@@ -25,11 +34,7 @@
continue
assert len(op1) == len(op2)
for x, y in zip(op1, op2):
- if isinstance(x, MODRM) and isinstance(y, MODRM):
- assert x.byte == y.byte
- assert x.extradata == y.extradata
- else:
- assert x == y
+ assert x == y
assert len(self.ops) == len(expected)
return True
@@ -52,9 +57,9 @@
def test_simple_registers():
assembler = MockAssembler()
remap_frame_layout(assembler, [eax, ebx, ecx], [edx, esi, edi], '?')
- assert assembler.ops == [('mov', eax, edx),
- ('mov', ebx, esi),
- ('mov', ecx, edi)]
+ assert assembler.ops == [('load', eax, edx),
+ ('load', ebx, esi),
+ ('load', ecx, edi)]
def test_simple_framelocs():
assembler = MockAssembler()
@@ -63,10 +68,10 @@
s20 = frame_pos(20, 1)
s24 = frame_pos(221, 1)
remap_frame_layout(assembler, [s8, eax, s12], [s20, s24, edi], edx)
- assert assembler.ops == [('mov', s8, edx),
- ('mov', edx, s20),
- ('mov', eax, s24),
- ('mov', s12, edi)]
+ assert assembler.ops == [('load', s8, edx),
+ ('store', edx, s20),
+ ('store', eax, s24),
+ ('load', s12, edi)]
def test_reordering():
assembler = MockAssembler()
@@ -76,10 +81,10 @@
s24 = frame_pos(1, 1)
remap_frame_layout(assembler, [eax, s8, s20, ebx],
[s8, ebx, eax, edi], '?')
- assert assembler.got([('mov', ebx, edi),
- ('mov', s8, ebx),
- ('mov', eax, s8),
- ('mov', s20, eax)])
+ assert assembler.got([('load', ebx, edi),
+ ('load', s8, ebx),
+ ('store', eax, s8),
+ ('load', s20, eax)])
def test_cycle():
assembler = MockAssembler()
@@ -90,9 +95,9 @@
remap_frame_layout(assembler, [eax, s8, s20, ebx],
[s8, ebx, eax, s20], '?')
assert assembler.got([('push', s8),
- ('mov', eax, s8),
- ('mov', s20, eax),
- ('mov', ebx, s20),
+ ('store', eax, s8),
+ ('load', s20, eax),
+ ('store', ebx, s20),
('pop', ebx)])
def test_cycle_2():
@@ -107,37 +112,37 @@
[eax, s8, edi, s20, eax, s20, s24, esi, s2, s3],
[s8, s20, edi, eax, edx, s24, ebx, s12, s3, s2],
ecx)
- assert assembler.got([('mov', eax, edx),
- ('mov', s24, ebx),
- ('mov', esi, s12),
- ('mov', s20, ecx),
- ('mov', ecx, s24),
+ assert assembler.got([('load', eax, edx),
+ ('load', s24, ebx),
+ ('store', esi, s12),
+ ('load', s20, ecx),
+ ('store', ecx, s24),
('push', s8),
- ('mov', eax, s8),
- ('mov', s20, eax),
+ ('store', eax, s8),
+ ('load', s20, eax),
('pop', s20),
('push', s3),
- ('mov', s2, ecx),
- ('mov', ecx, s3),
+ ('load', s2, ecx),
+ ('store', ecx, s3),
('pop', s2)])
def test_constants():
assembler = MockAssembler()
- c3 = imm(3)
+ c3 = ConstInt(3)
remap_frame_layout(assembler, [c3], [eax], '?')
- assert assembler.ops == [('mov', c3, eax)]
+ assert assembler.ops == [('load', c3, eax)]
assembler = MockAssembler()
s12 = frame_pos(12, 1)
remap_frame_layout(assembler, [c3], [s12], '?')
- assert assembler.ops == [('mov', c3, s12)]
+ assert assembler.ops == [('store', c3, s12)]
def test_constants_and_cycle():
assembler = MockAssembler()
- c3 = imm(3)
+ c3 = ConstInt(3)
s12 = frame_pos(13, 1)
remap_frame_layout(assembler, [ebx, c3, s12],
[s12, eax, ebx], edi)
- assert assembler.ops == [('mov', c3, eax),
+ assert assembler.ops == [('load', c3, eax),
('push', s12),
- ('mov', ebx, s12),
+ ('store', ebx, s12),
('pop', ebx)]
More information about the Pypy-commit
mailing list