Author: Maciej Fijalkowski <[email protected]>
Branch: jitframe-on-heap
Changeset: r60048:7ca517276be9
Date: 2013-01-14 15:23 +0200
http://bitbucket.org/pypy/pypy/changeset/7ca517276be9/
Log: simplification and fixes. runner test seems to pass
diff --git a/pypy/jit/backend/llsupport/llmodel.py
b/pypy/jit/backend/llsupport/llmodel.py
--- a/pypy/jit/backend/llsupport/llmodel.py
+++ b/pypy/jit/backend/llsupport/llmodel.py
@@ -78,31 +78,9 @@
return (rffi.cast(lltype.Signed, _exception_emulator) +
rffi.sizeof(lltype.Signed))
- def propagate_exception():
- exc = _exception_emulator[1]
- _exception_emulator[0] = 0
- _exception_emulator[1] = 0
- assert self.propagate_exception_v >= 0
- faildescr = self.get_fail_descr_from_number(
- self.propagate_exception_v)
- faildescr = faildescr.hide(self)
- if not exc:
- deadframe = self.deadframe_memoryerror
- if not deadframe.jf_descr:
- deadframe.jf_descr = faildescr
- else:
- assert deadframe.jf_descr == faildescr
- else:
- XXX
- deadframe = lltype.malloc(jitframe.DEADFRAME, 0)
- deadframe.jf_guard_exc = rffi.cast(llmemory.GCREF, exc)
- deadframe.jf_descr = faildescr
- return lltype.cast_opaque_ptr(llmemory.GCREF, deadframe)
-
self.pos_exception = pos_exception
self.pos_exc_value = pos_exc_value
self.insert_stack_check = lambda: (0, 0, 0)
- self._propagate_exception = propagate_exception
def _setup_exception_handling_translated(self):
@@ -124,46 +102,9 @@
slowpathaddr = rffi.cast(lltype.Signed, f)
return endaddr, lengthaddr, slowpathaddr
- def propagate_exception():
- addr = llop.get_exception_addr(llmemory.Address)
- addr.address[0] = llmemory.NULL
- addr = llop.get_exc_value_addr(llmemory.Address)
- exc = rffi.cast(llmemory.GCREF, addr.address[0])
- addr.address[0] = llmemory.NULL
- assert self.propagate_exception_v >= 0
- faildescr = self.get_fail_descr_from_number(
- self.propagate_exception_v)
- faildescr = faildescr.hide(self)
- XXX
- deadframe = lltype.nullptr(jitframe.DEADFRAME)
- if exc:
- try:
- deadframe = lltype.malloc(jitframe.DEADFRAME, 0)
- deadframe.jf_guard_exc = rffi.cast(llmemory.GCREF, exc)
- deadframe.jf_descr = faildescr
- except MemoryError:
- deadframe = lltype.nullptr(jitframe.DEADFRAME)
- if not deadframe:
- deadframe = self.deadframe_memoryerror
- if not deadframe.jf_descr:
- exc = MemoryError()
- exc = cast_instance_to_base_ptr(exc)
- exc = lltype.cast_opaque_ptr(llmemory.GCREF, exc)
- deadframe.jf_guard_exc = exc
- deadframe.jf_descr = faildescr
- else:
- assert deadframe.jf_descr == faildescr
- return lltype.cast_opaque_ptr(llmemory.GCREF, deadframe)
-
self.pos_exception = pos_exception
self.pos_exc_value = pos_exc_value
self.insert_stack_check = insert_stack_check
- self._propagate_exception = propagate_exception
-
- PROPAGATE_EXCEPTION = lltype.Ptr(lltype.FuncType([], llmemory.GCREF))
-
- def get_propagate_exception(self):
- return llhelper(self.PROPAGATE_EXCEPTION, self._propagate_exception)
def grab_exc_value(self, deadframe):
deadframe = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, deadframe)
diff --git a/pypy/jit/backend/test/runner_test.py
b/pypy/jit/backend/test/runner_test.py
--- a/pypy/jit/backend/test/runner_test.py
+++ b/pypy/jit/backend/test/runner_test.py
@@ -3364,7 +3364,7 @@
fail = self.cpu.get_latest_descr(deadframe)
assert fail.identifier == excdescr.identifier
exc = self.cpu.grab_exc_value(deadframe)
- assert exc == "memoryerror!"
+ assert not exc
def test_math_sqrt(self):
if not self.cpu.supports_floats:
diff --git a/pypy/jit/backend/x86/arch.py b/pypy/jit/backend/x86/arch.py
--- a/pypy/jit/backend/x86/arch.py
+++ b/pypy/jit/backend/x86/arch.py
@@ -43,6 +43,7 @@
if WORD == 4:
# XXX rethink the fixed size
# ebp + ebx + esi + edi + 4 extra words + force_index = 9 words
+ XX
FRAME_FIXED_SIZE = 6
SAVED_REGISTERS = 1 # range(1, 5)
MY_COPY_OF_REGS = 5 # range(5, 9)
@@ -50,10 +51,9 @@
JITFRAME_FIXED_SIZE = 29 # 13 GPR + 16 XMM
# reg, we don't save it
else:
- # rbp + rbx + r12 + r13 + r14 + r15 + 11 extra words + force_index = 18
- FRAME_FIXED_SIZE = 6
- SAVED_REGISTERS = 1 # range(1, 7)
- MY_COPY_OF_REGS = 7 # range(7, 18)
+ # rbp + rbx + r12 + r13 + r14 + r15 + 12 extra words + return address = 18
+ FRAME_FIXED_SIZE = 19
+ PASS_ON_MY_FRAME = 12
JITFRAME_FIXED_SIZE = 29 # 13 GPR + 16 XMM
# reg, we don't save it
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
@@ -13,7 +13,8 @@
from pypy.jit.backend.x86.regalloc import (RegAlloc, get_ebp_ofs, _get_scale,
gpr_reg_mgr_cls, xmm_reg_mgr_cls, _valid_addressing_size)
from pypy.jit.backend.x86.arch import (FRAME_FIXED_SIZE, WORD, IS_X86_64,
- JITFRAME_FIXED_SIZE, IS_X86_32)
+ JITFRAME_FIXED_SIZE, IS_X86_32,
+ PASS_ON_MY_FRAME)
from pypy.jit.backend.x86.regloc import (eax, ecx, edx, ebx, esp, ebp, esi,
edi,
xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, r8, r9, r10, r11,
r12, r13, r14, r15, X86_64_SCRATCH_REG, X86_64_XMM_SCRATCH_REG,
@@ -194,6 +195,7 @@
mc.MOV_br(ofs, reg.value)
#
if shadow_stack:
+ xxx
# ---- shadowstack ----
mc.SUB_ri(esp.value, 16 - WORD) # stack alignment of 16 bytes
if IS_X86_32:
@@ -253,10 +255,12 @@
#
self.mc = codebuf.MachineCodeBlockWrapper()
#
- # Call the helper, which will return a dead frame object with
- # the correct exception set, or MemoryError by default
- addr = rffi.cast(lltype.Signed, self.cpu.get_propagate_exception())
- self.mc.CALL(imm(addr))
+ # read and reset the current exception
+
+ self._store_and_reset_exception(eax)
+ ofs = self.cpu.get_ofs_of_frame_field('jf_guard_exc')
+ self.mc.MOV_br(ofs, eax.value)
+ self.mc.MOV_ri(eax.value, self.cpu.propagate_exception_v)
#
self._call_footer()
rawstart = self.mc.materialize(self.cpu.asmmemmgr, [])
@@ -267,6 +271,7 @@
_, _, slowpathaddr = self.cpu.insert_stack_check()
if slowpathaddr == 0 or self.cpu.propagate_exception_v < 0:
return # no stack check (for tests, or non-translated)
+ xxx
#
# make a "function" that is called immediately at the start of
# an assembler function. In particular, the stack looks like:
@@ -750,16 +755,15 @@
# Also, make sure this is consistent with FRAME_FIXED_SIZE.
# XXX should be LEA?
self.mc.SUB_ri(esp.value, FRAME_FIXED_SIZE * WORD)
- self.mc.MOV_sr(0, ebp.value)
+ self.mc.MOV_sr(PASS_ON_MY_FRAME * WORD, ebp.value)
if IS_X86_64:
- descrs = self.cpu.gc_ll_descr.getframedescrs(self.cpu)
- _, ofs, _ = unpack_arraydescr(descrs.arraydescr)
+ ofs = self.cpu.get_baseofs_of_frame_field()
self.mc.LEA_rm(ebp.value, (edi.value, ofs))
else:
xxx
for i, loc in enumerate(self.cpu.CALLEE_SAVE_REGISTERS):
- self.mc.MOV_sr((i + 1) * WORD, loc.value)
+ self.mc.MOV_sr((PASS_ON_MY_FRAME + i + 1) * WORD, loc.value)
gcrootmap = self.cpu.gc_ll_descr.gcrootmap
if gcrootmap and gcrootmap.is_shadow_stack:
@@ -769,6 +773,7 @@
if self.stack_check_slowpath == 0:
pass # no stack check (e.g. not translated)
else:
+ xxx
endaddr, lengthaddr, _ = self.cpu.insert_stack_check()
self.mc.MOV(eax, heap(endaddr)) # MOV eax, [start]
self.mc.SUB(eax, esp) # SUB eax, current
@@ -790,9 +795,9 @@
for i in range(len(self.cpu.CALLEE_SAVE_REGISTERS)-1, -1, -1):
self.mc.MOV_rs(self.cpu.CALLEE_SAVE_REGISTERS[i].value,
- (i + 1) * WORD)
+ (i + 1 + PASS_ON_MY_FRAME) * WORD)
- self.mc.MOV_rs(ebp.value, 0)
+ self.mc.MOV_rs(ebp.value, PASS_ON_MY_FRAME * WORD)
self.mc.ADD_ri(esp.value, FRAME_FIXED_SIZE * WORD)
self.mc.RET()
@@ -1105,6 +1110,20 @@
unused_xmm = [xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0]
on_stack = 0
+ # count the stack depth
+ floats = 0
+ for i in range(start, len(arglocs)):
+ arg = arglocs[i]
+ if arg.is_float() or argtypes and argtypes[i - start] == 'S':
+ floats += 1
+ all_args = len(arglocs) - start
+ stack_depth = (max(all_args - floats - len(unused_gpr), 0) +
+ max(floats - len(unused_xmm), 0))
+ align = 0
+ if stack_depth > PASS_ON_MY_FRAME:
+ stack_depth = align_stack_words(stack_depth)
+ align = (stack_depth - PASS_ON_MY_FRAME)
+ self.mc.SUB_ri(esp.value, align * WORD)
for i in range(start, len(arglocs)):
loc = arglocs[i]
if loc.is_float():
@@ -1131,10 +1150,6 @@
dst_locs.append(RawEspLoc(on_stack * WORD, INT))
on_stack += 1
- align = align_stack_words(on_stack + 1) - 1
- if align:
- self.mc.SUB_ri(esp.value, align * WORD)
-
# Handle register arguments: first remap the xmm arguments
remap_frame_layout(self, xmm_src_locs, xmm_dst_locs,
X86_64_XMM_SCRATCH_REG)
@@ -1663,6 +1678,9 @@
self.mc.MOV(loc1, heap(self.cpu.pos_exception()))
self.mc.CMP(loc1, loc)
self.implement_guard(guard_token, 'NE')
+ self._store_and_reset_exception(resloc)
+
+ def _store_and_reset_exception(self, resloc=None):
if resloc is not None:
self.mc.MOV(resloc, heap(self.cpu.pos_exc_value()))
self.mc.MOV(heap(self.cpu.pos_exception()), imm0)
@@ -1856,11 +1874,8 @@
if exc:
# save ebx into 'jf_guard_exc'
- from pypy.jit.backend.llsupport.descr import unpack_fielddescr
- descrs = self.cpu.gc_ll_descr.getframedescrs(self.cpu)
- offset, size, _ = unpack_fielddescr(descrs.jf_guard_exc)
- _, base_offset, _ = unpack_arraydescr(descrs.arraydescr)
- mc.MOV_br(offset - base_offset, ebx.value)
+ offset = self.cpu.get_ofs_of_frame_field('jf_guard_exc')
+ mc.MOV_br(offset, ebx.value)
# now we return from the complete frame, which starts from
# _call_header_with_stack_check(). The LEA in _call_footer below
@@ -1961,17 +1976,13 @@
def _store_force_index(self, guard_op):
faildescr = guard_op.getdescr()
fail_index = self.cpu.get_fail_descr_number(faildescr)
- descrs = self.cpu.gc_ll_descr.getframedescrs(self.cpu)
- base_ofs = self.cpu.unpack_arraydescr(descrs.arraydescr)
- ofs = self.cpu.unpack_fielddescr(descrs.jf_force_index)
- self.mc.MOV_bi(ofs - base_ofs, fail_index)
+ ofs = self.cpu.get_ofs_of_frame_field('jf_force_index')
+ self.mc.MOV_bi(ofs, fail_index)
return fail_index
def _emit_guard_not_forced(self, guard_token):
- descrs = self.cpu.gc_ll_descr.getframedescrs(self.cpu)
- base_ofs = self.cpu.unpack_arraydescr(descrs.arraydescr)
- ofs_fail = self.cpu.unpack_fielddescr(descrs.jf_descr)
- self.mc.CMP_bi(ofs_fail - base_ofs, 0)
+ ofs = self.cpu.get_ofs_of_frame_field('jf_descr')
+ self.mc.CMP_bi(ofs, 0)
self.implement_guard(guard_token, 'NE')
def genop_guard_call_may_force(self, op, guard_op, guard_token,
diff --git a/pypy/jit/backend/x86/regalloc.py b/pypy/jit/backend/x86/regalloc.py
--- a/pypy/jit/backend/x86/regalloc.py
+++ b/pypy/jit/backend/x86/regalloc.py
@@ -24,7 +24,7 @@
from pypy.jit.backend.llsupport.regalloc import FrameManager, RegisterManager,\
TempBox, compute_vars_longevity, is_comparison_or_ovf_op
from pypy.jit.backend.x86.arch import WORD, JITFRAME_FIXED_SIZE
-from pypy.jit.backend.x86.arch import IS_X86_32, IS_X86_64, MY_COPY_OF_REGS
+from pypy.jit.backend.x86.arch import IS_X86_32, IS_X86_64
from pypy.jit.backend.x86 import rx86
from pypy.rlib.rarithmetic import r_longlong
@@ -41,12 +41,12 @@
esi: 2,
edi: 3,
}
- REGLOC_TO_COPY_AREA_OFS = {
- ecx: MY_COPY_OF_REGS + 0 * WORD,
- ebx: MY_COPY_OF_REGS + 1 * WORD,
- esi: MY_COPY_OF_REGS + 2 * WORD,
- edi: MY_COPY_OF_REGS + 3 * WORD,
- }
+ #REGLOC_TO_COPY_AREA_OFS = {
+ # ecx: MY_COPY_OF_REGS + 0 * WORD,
+ # ebx: MY_COPY_OF_REGS + 1 * WORD,
+ # esi: MY_COPY_OF_REGS + 2 * WORD,
+ # edi: MY_COPY_OF_REGS + 3 * WORD,
+ #}
def call_result_location(self, v):
return eax
@@ -75,19 +75,19 @@
r14: 4,
r15: 5,
}
- REGLOC_TO_COPY_AREA_OFS = {
- ecx: MY_COPY_OF_REGS + 0 * WORD,
- ebx: MY_COPY_OF_REGS + 1 * WORD,
- esi: MY_COPY_OF_REGS + 2 * WORD,
- edi: MY_COPY_OF_REGS + 3 * WORD,
- r8: MY_COPY_OF_REGS + 4 * WORD,
- r9: MY_COPY_OF_REGS + 5 * WORD,
- r10: MY_COPY_OF_REGS + 6 * WORD,
- r12: MY_COPY_OF_REGS + 7 * WORD,
- r13: MY_COPY_OF_REGS + 8 * WORD,
- r14: MY_COPY_OF_REGS + 9 * WORD,
- r15: MY_COPY_OF_REGS + 10 * WORD,
- }
+ #REGLOC_TO_COPY_AREA_OFS = {
+ # ecx: MY_COPY_OF_REGS + 0 * WORD,
+ # ebx: MY_COPY_OF_REGS + 1 * WORD,
+ # esi: MY_COPY_OF_REGS + 2 * WORD,
+ # edi: MY_COPY_OF_REGS + 3 * WORD,
+ # r8: MY_COPY_OF_REGS + 4 * WORD,
+ # r9: MY_COPY_OF_REGS + 5 * WORD,
+ # r10: MY_COPY_OF_REGS + 6 * WORD,
+ # r12: MY_COPY_OF_REGS + 7 * WORD,
+ # r13: MY_COPY_OF_REGS + 8 * WORD,
+ # r14: MY_COPY_OF_REGS + 9 * WORD,
+ #3 r15: MY_COPY_OF_REGS + 10 * WORD,
+ #}
class X86XMMRegisterManager(RegisterManager):
diff --git a/pypy/jit/backend/x86/runner.py b/pypy/jit/backend/x86/runner.py
--- a/pypy/jit/backend/x86/runner.py
+++ b/pypy/jit/backend/x86/runner.py
@@ -208,6 +208,18 @@
ofs = self.unpack_arraydescr(descr)
self.write_float_at_mem(newframe, ofs + index, value)
+ @specialize.arg(1)
+ def get_ofs_of_frame_field(self, name):
+ descrs = self.gc_ll_descr.getframedescrs(self)
+ base_ofs = self.unpack_arraydescr(descrs.arraydescr)
+ ofs = self.unpack_fielddescr(getattr(descrs, name))
+ return ofs - base_ofs
+
+ def get_baseofs_of_frame_field(self):
+ descrs = self.gc_ll_descr.getframedescrs(self)
+ base_ofs = self.unpack_arraydescr(descrs.arraydescr)
+ return base_ofs
+
class CPU386(AbstractX86CPU):
backend_name = 'x86'
WORD = 4
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
