Author: Maciej Fijalkowski <[email protected]>
Branch: jitframe-on-heap
Changeset: r60096:47864e6b39c1
Date: 2013-01-15 20:30 +0200
http://bitbucket.org/pypy/pypy/changeset/47864e6b39c1/
Log: rip off some unused tests
diff --git a/pypy/jit/backend/x86/assembler.py
b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -1853,6 +1853,7 @@
mc.JMP_r(X86_64_SCRATCH_REG.value)
# write tight data that describes the failure recovery
positions = [0] * len(guardtok.fail_locs)
+ gcpattern = 0
for i, loc in enumerate(guardtok.fail_locs):
if loc is None:
positions[i] = -1
@@ -1864,10 +1865,13 @@
v = len(gpr_reg_mgr_cls.all_regs) + loc.value
else:
v = gpr_reg_mgr_cls.all_reg_indexes[loc.value]
+ if guardtok.failargs[i].type == REF:
+ gcpattern |= v
positions[i] = v * WORD
# write down the positions of locs
guardtok.faildescr.rd_locs = positions
# write down the GC pattern
+ guardtok.faildescr.rd_gcpattern = gcpattern
return startpos
def rebuild_faillocs_from_descr(self, descr, inputargs):
diff --git a/pypy/jit/backend/x86/test/test_assembler.py
b/pypy/jit/backend/x86/test/test_assembler.py
--- a/pypy/jit/backend/x86/test/test_assembler.py
+++ b/pypy/jit/backend/x86/test/test_assembler.py
@@ -45,217 +45,6 @@
def hide(self, cpu):
return rffi.cast(llmemory.GCREF, 123)
-def test_write_failure_recovery_description():
- assembler = Assembler386(FakeCPU())
- mc = FakeMC()
- failargs = [BoxInt(), BoxPtr(), BoxFloat()] * 3
- failargs.insert(6, None)
- failargs.insert(7, None)
- locs = [X86FrameManager.frame_pos(0, INT),
- X86FrameManager.frame_pos(1, REF),
- X86FrameManager.frame_pos(10, FLOAT),
- X86FrameManager.frame_pos(100, INT),
- X86FrameManager.frame_pos(101, REF),
- X86FrameManager.frame_pos(110, FLOAT),
- None,
- None,
- ebx,
- esi,
- xmm2]
- assert len(failargs) == len(locs)
- assembler.write_failure_recovery_description(mc, failargs, locs)
- base = 8 + 8*IS_X86_64
- nums = [Assembler386.DESCR_INT + 4*(base+0),
- Assembler386.DESCR_REF + 4*(base+1),
- Assembler386.DESCR_FLOAT + 4*(base+10),
- Assembler386.DESCR_INT + 4*(base+100),
- Assembler386.DESCR_REF + 4*(base+101),
- Assembler386.DESCR_FLOAT + 4*(base+110),
- Assembler386.CODE_HOLE,
- Assembler386.CODE_HOLE,
- Assembler386.DESCR_INT + 4*ebx.value,
- Assembler386.DESCR_REF + 4*esi.value,
- Assembler386.DESCR_FLOAT + 4*xmm2.value]
- double_byte_nums = []
- for num in nums[3:6]:
- double_byte_nums.append((num & 0x7F) | 0x80)
- double_byte_nums.append(num >> 7)
- assert mc.content == (nums[:3] + double_byte_nums + nums[6:] +
- [assembler.CODE_STOP])
-
- # also test rebuild_faillocs_from_descr(), which should not
- # reproduce the holes at all
- bytecode = lltype.malloc(rffi.UCHARP.TO, len(mc.content), flavor='raw',
- immortal=True)
- for i in range(len(mc.content)):
- assert 0 <= mc.content[i] <= 255
- bytecode[i] = rffi.cast(rffi.UCHAR, mc.content[i])
- bytecode_addr = rffi.cast(lltype.Signed, bytecode)
- newlocs = assembler.rebuild_faillocs_from_descr(bytecode_addr)
- assert ([loc.assembler() for loc in newlocs] ==
- [loc.assembler() for loc in locs if loc is not None])
-
-# ____________________________________________________________
-
-def test_failure_recovery_func_no_floats():
- do_failure_recovery_func(withfloats=False)
-
-def test_failure_recovery_func_with_floats():
- do_failure_recovery_func(withfloats=True)
-
-def do_failure_recovery_func(withfloats):
- import random
- S = lltype.GcStruct('S')
-
- def get_random_int():
- return random.randrange(-10000, 10000)
-
- def get_random_ptr():
- return lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S))
-
- def get_random_float():
- # Returns <float>, <low word>, <high word>
- # NB: on 64-bit, <low word> will be the entire float and <high word>
- # will be random garbage from malloc!
- assert withfloats
- value = random.random() - 0.5
- # make sure it fits into 64 bits
- tmp = lltype.malloc(rffi.LONGP.TO, 2, flavor='raw',
- track_allocation=False)
- rffi.cast(rffi.DOUBLEP, tmp)[0] = value
- return rffi.cast(rffi.DOUBLEP, tmp)[0], tmp[0], tmp[1]
-
- if IS_X86_32:
- main_registers = X86RegisterManager.all_regs
- xmm_registers = X86XMMRegisterManager.all_regs
- elif IS_X86_64:
- main_registers = X86_64_RegisterManager.all_regs
- xmm_registers = X86_64_XMMRegisterManager.all_regs
-
- # memory locations: 26 integers, 26 pointers, 26 floats
- # main registers: half of them as signed and the other half as ptrs
- # xmm registers: all floats, from xmm0 to xmm(7|15)
- # holes: 8
- locations = []
- baseloc = 4
- for i in range(26+26+26):
- if baseloc < 128:
- baseloc += random.randrange(2, 20)
- else:
- baseloc += random.randrange(2, 1000)
- locations.append(baseloc)
- random.shuffle(locations)
- content = ([('int', locations.pop()) for _ in range(26)] +
- [('ptr', locations.pop()) for _ in range(26)] +
- [(['int', 'ptr'][random.randrange(0, 2)], reg)
- for reg in main_registers])
- if withfloats:
- content += ([('float', locations.pop()) for _ in range(26)] +
- [('float', reg) for reg in xmm_registers])
- for i in range(8):
- content.append(('hole', None))
- random.shuffle(content)
-
- # prepare the expected target arrays, the descr_bytecode,
- # the 'registers' and the 'stack' arrays according to 'content'
- xmmregisters = lltype.malloc(rffi.LONGP.TO, 16+ACTUAL_CPU.NUM_REGS+1,
- flavor='raw', immortal=True)
- registers = rffi.ptradd(xmmregisters, 16)
- stacklen = baseloc + 30
- stack = lltype.malloc(rffi.LONGP.TO, stacklen, flavor='raw',
- immortal=True)
- expected_ints = [None] * len(content)
- expected_ptrs = [None] * len(content)
- expected_floats = [None] * len(content)
-
- def write_in_stack(loc, value):
- assert loc >= 0
- ofs = get_ebp_ofs(loc)
- assert ofs < 0
- assert (ofs % WORD) == 0
- stack[stacklen + ofs//WORD] = value
-
- descr_bytecode = []
- for i, (kind, loc) in enumerate(content):
- if kind == 'hole':
- num = Assembler386.CODE_HOLE
- else:
- if kind == 'float':
- value, lo, hi = get_random_float()
- expected_floats[i] = longlong.getfloatstorage(value)
- kind = Assembler386.DESCR_FLOAT
- if isinstance(loc, RegLoc):
- if WORD == 4:
- xmmregisters[2*loc.value] = lo
- xmmregisters[2*loc.value+1] = hi
- elif WORD == 8:
- xmmregisters[loc.value] = lo
- else:
- if WORD == 4:
- write_in_stack(loc, hi)
- write_in_stack(loc+1, lo)
- elif WORD == 8:
- write_in_stack(loc, lo)
- else:
- if kind == 'int':
- value = get_random_int()
- expected_ints[i] = value
- kind = Assembler386.DESCR_INT
- elif kind == 'ptr':
- value = get_random_ptr()
- expected_ptrs[i] = value
- kind = Assembler386.DESCR_REF
- value = rffi.cast(rffi.LONG, value)
- else:
- assert 0, kind
- if isinstance(loc, RegLoc):
- registers[loc.value] = value
- else:
- write_in_stack(loc, value)
-
- if isinstance(loc, RegLoc):
- num = kind + 4*loc.value
- else:
- num = kind + Assembler386.CODE_FROMSTACK + (4*loc)
- while num >= 0x80:
- descr_bytecode.append((num & 0x7F) | 0x80)
- num >>= 7
- descr_bytecode.append(num)
-
- descr_bytecode.append(Assembler386.CODE_STOP)
- descr_bytecode.append(0xC3) # fail_index = 0x1C3
- descr_bytecode.append(0x01)
- descr_bytecode.append(0x00)
- descr_bytecode.append(0x00)
- descr_bytecode.append(0xCC) # end marker
- descr_bytes = lltype.malloc(rffi.UCHARP.TO, len(descr_bytecode),
- flavor='raw', immortal=True)
- for i in range(len(descr_bytecode)):
- assert 0 <= descr_bytecode[i] <= 255
- descr_bytes[i] = rffi.cast(rffi.UCHAR, descr_bytecode[i])
- registers[ACTUAL_CPU.NUM_REGS] = rffi.cast(rffi.LONG, descr_bytes)
- registers[ebp.value] = rffi.cast(rffi.LONG, stack) + WORD*stacklen
-
- XXX # rewrite
-
- # run!
- assembler = Assembler386(FakeCPU())
- deadframe = assembler.failure_recovery_func(registers)
- deadframe = lltype.cast_opaque_ptr(jitframe.DEADFRAMEPTR, deadframe)
- assert deadframe.jf_descr == rffi.cast(llmemory.GCREF, 123)
-
- # check the fail_boxes
- for i in range(len(content)):
- if expected_ints[i] is not None:
- assert deadframe.jf_values[i].int == expected_ints[i]
- if expected_ptrs[i] is not None:
- assert deadframe.jf_values[i].ref == expected_ptrs[i]
- # note: we expect *exact* results below. If you have only
- # an approximate result, it might mean that only the first 32
- # bits of the float were correctly saved and restored.
- if expected_floats[i] is not None:
- assert deadframe.jf_values[i].float == expected_floats[i]
-
# ____________________________________________________________
class TestRegallocPushPop(object):
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
