[pypy-svn] r74223 - in pypy/branch/blackhole-improvement/pypy/jit: backend backend/llgraph codewriter metainterp metainterp/test
arigo at codespeak.net
arigo at codespeak.net
Thu Apr 29 16:08:22 CEST 2010
Author: arigo
Date: Thu Apr 29 16:08:20 2010
New Revision: 74223
Modified:
pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py
pypy/branch/blackhole-improvement/pypy/jit/backend/model.py
pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitter.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/resoperation.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_basic.py
pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_blackhole.py
Log:
General progress. Also reimplement int_{add,sub,mul}_ovf.
Modified: pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/backend/llgraph/runner.py Thu Apr 29 16:08:20 2010
@@ -263,17 +263,6 @@
# ----------
- def clear_exception(self):
- llimpl.clear_exception()
-
- def get_overflow_error(self):
- return (self.cast_adr_to_int(llimpl.get_overflow_error()),
- llimpl.get_overflow_error_value())
-
- def get_zero_division_error(self):
- return (self.cast_adr_to_int(llimpl.get_zero_division_error()),
- llimpl.get_zero_division_error_value())
-
def sizeof(self, S):
assert not isinstance(S, lltype.Ptr)
return self.getdescr(symbolic.get_size(S))
@@ -329,42 +318,42 @@
# ---------- the backend-dependent operations ----------
- def do_arraylen_gc(self, arraybox, arraydescr):
- array = arraybox.getref_base()
- return history.BoxInt(llimpl.do_arraylen_gc(arraydescr, array))
-
- def do_strlen(self, stringbox):
- string = stringbox.getref_base()
- return history.BoxInt(llimpl.do_strlen(0, string))
-
- def do_strgetitem(self, stringbox, indexbox):
- string = stringbox.getref_base()
- index = indexbox.getint()
- return history.BoxInt(llimpl.do_strgetitem(0, string, index))
-
- def do_unicodelen(self, stringbox):
- string = stringbox.getref_base()
- return history.BoxInt(llimpl.do_unicodelen(0, string))
-
- def do_unicodegetitem(self, stringbox, indexbox):
- string = stringbox.getref_base()
- index = indexbox.getint()
- return history.BoxInt(llimpl.do_unicodegetitem(0, string, index))
-
- def do_getarrayitem_gc(self, arraybox, indexbox, arraydescr):
- assert isinstance(arraydescr, Descr)
- array = arraybox.getref_base()
- index = indexbox.getint()
- if arraydescr.typeinfo == REF:
- return history.BoxPtr(llimpl.do_getarrayitem_gc_ptr(array, index))
- elif arraydescr.typeinfo == INT:
- return history.BoxInt(llimpl.do_getarrayitem_gc_int(array, index,
- self.memo_cast))
- elif arraydescr.typeinfo == FLOAT:
- return history.BoxFloat(llimpl.do_getarrayitem_gc_float(array,
- index))
- else:
- raise NotImplementedError
+## def do_arraylen_gc(self, arraybox, arraydescr):
+## array = arraybox.getref_base()
+## return history.BoxInt(llimpl.do_arraylen_gc(arraydescr, array))
+
+## def do_strlen(self, stringbox):
+## string = stringbox.getref_base()
+## return history.BoxInt(llimpl.do_strlen(0, string))
+
+## def do_strgetitem(self, stringbox, indexbox):
+## string = stringbox.getref_base()
+## index = indexbox.getint()
+## return history.BoxInt(llimpl.do_strgetitem(0, string, index))
+
+## def do_unicodelen(self, stringbox):
+## string = stringbox.getref_base()
+## return history.BoxInt(llimpl.do_unicodelen(0, string))
+
+## def do_unicodegetitem(self, stringbox, indexbox):
+## string = stringbox.getref_base()
+## index = indexbox.getint()
+## return history.BoxInt(llimpl.do_unicodegetitem(0, string, index))
+
+## def do_getarrayitem_gc(self, arraybox, indexbox, arraydescr):
+## assert isinstance(arraydescr, Descr)
+## array = arraybox.getref_base()
+## index = indexbox.getint()
+## if arraydescr.typeinfo == REF:
+## return history.BoxPtr(llimpl.do_getarrayitem_gc_ptr(array, index))
+## elif arraydescr.typeinfo == INT:
+## return history.BoxInt(llimpl.do_getarrayitem_gc_int(array, index,
+## self.memo_cast))
+## elif arraydescr.typeinfo == FLOAT:
+## return history.BoxFloat(llimpl.do_getarrayitem_gc_float(array,
+## index))
+## else:
+## raise NotImplementedError
## def do_getfield_gc(self, structbox, fielddescr):
## assert isinstance(fielddescr, Descr)
@@ -424,9 +413,9 @@
assert isinstance(fielddescr, Descr)
return llimpl.do_getfield_raw_float(struct, fielddescr.ofs)
- def do_new(self, size):
- assert isinstance(size, Descr)
- return history.BoxPtr(llimpl.do_new(size.ofs))
+## def do_new(self, size):
+## assert isinstance(size, Descr)
+## return history.BoxPtr(llimpl.do_new(size.ofs))
def bh_new(self, sizedescr):
assert isinstance(sizedescr, Descr)
@@ -444,31 +433,31 @@
result_adr = llmemory.cast_ptr_to_adr(struct.typeptr)
return llmemory.cast_adr_to_int(result_adr)
- def do_new_array(self, countbox, size):
- assert isinstance(size, Descr)
- count = countbox.getint()
- return history.BoxPtr(llimpl.do_new_array(size.ofs, count))
+## def do_new_array(self, countbox, size):
+## assert isinstance(size, Descr)
+## count = countbox.getint()
+## return history.BoxPtr(llimpl.do_new_array(size.ofs, count))
def bh_new_array(self, arraydescr, length):
assert isinstance(arraydescr, Descr)
return llimpl.do_new_array(arraydescr.ofs, length)
- def do_setarrayitem_gc(self, arraybox, indexbox, newvaluebox, arraydescr):
- assert isinstance(arraydescr, Descr)
- array = arraybox.getref_base()
- index = indexbox.getint()
- if arraydescr.typeinfo == REF:
- newvalue = newvaluebox.getref_base()
- llimpl.do_setarrayitem_gc_ptr(array, index, newvalue)
- elif arraydescr.typeinfo == INT:
- newvalue = newvaluebox.getint()
- llimpl.do_setarrayitem_gc_int(array, index, newvalue,
- self.memo_cast)
- elif arraydescr.typeinfo == FLOAT:
- newvalue = newvaluebox.getfloat()
- llimpl.do_setarrayitem_gc_float(array, index, newvalue)
- else:
- raise NotImplementedError
+## def do_setarrayitem_gc(self, arraybox, indexbox, newvaluebox, arraydescr):
+## assert isinstance(arraydescr, Descr)
+## array = arraybox.getref_base()
+## index = indexbox.getint()
+## if arraydescr.typeinfo == REF:
+## newvalue = newvaluebox.getref_base()
+## llimpl.do_setarrayitem_gc_ptr(array, index, newvalue)
+## elif arraydescr.typeinfo == INT:
+## newvalue = newvaluebox.getint()
+## llimpl.do_setarrayitem_gc_int(array, index, newvalue,
+## self.memo_cast)
+## elif arraydescr.typeinfo == FLOAT:
+## newvalue = newvaluebox.getfloat()
+## llimpl.do_setarrayitem_gc_float(array, index, newvalue)
+## else:
+## raise NotImplementedError
def bh_setarrayitem_gc_r(self, arraydescr, array, index, newvalue):
assert isinstance(arraydescr, Descr)
@@ -532,28 +521,28 @@
assert isinstance(fielddescr, Descr)
llimpl.do_setfield_raw_float(struct, fielddescr.ofs, newvalue)
- def do_same_as(self, box1):
- return box1.clonebox()
+## def do_same_as(self, box1):
+## return box1.clonebox()
- def do_newstr(self, lengthbox):
- length = lengthbox.getint()
- return history.BoxPtr(llimpl.do_newstr(0, length))
-
- def do_newunicode(self, lengthbox):
- length = lengthbox.getint()
- return history.BoxPtr(llimpl.do_newunicode(0, length))
-
- def do_strsetitem(self, stringbox, indexbox, newvaluebox):
- string = stringbox.getref_base()
- index = indexbox.getint()
- newvalue = newvaluebox.getint()
- llimpl.do_strsetitem(0, string, index, newvalue)
-
- def do_unicodesetitem(self, stringbox, indexbox, newvaluebox):
- string = stringbox.getref_base()
- index = indexbox.getint()
- newvalue = newvaluebox.getint()
- llimpl.do_unicodesetitem(0, string, index, newvalue)
+## def do_newstr(self, lengthbox):
+## length = lengthbox.getint()
+## return history.BoxPtr(llimpl.do_newstr(0, length))
+
+## def do_newunicode(self, lengthbox):
+## length = lengthbox.getint()
+## return history.BoxPtr(llimpl.do_newunicode(0, length))
+
+## def do_strsetitem(self, stringbox, indexbox, newvaluebox):
+## string = stringbox.getref_base()
+## index = indexbox.getint()
+## newvalue = newvaluebox.getint()
+## llimpl.do_strsetitem(0, string, index, newvalue)
+
+## def do_unicodesetitem(self, stringbox, indexbox, newvaluebox):
+## string = stringbox.getref_base()
+## index = indexbox.getint()
+## newvalue = newvaluebox.getint()
+## llimpl.do_unicodesetitem(0, string, index, newvalue)
def bh_call_i(self, func, calldescr, args_i, args_r, args_f):
self._prepare_call(INT, calldescr, args_i, args_r, args_f)
@@ -581,9 +570,9 @@
for x in args_f:
llimpl.do_call_pushfloat(x)
- def do_cast_ptr_to_int(self, ptrbox):
- return history.BoxInt(llimpl.cast_to_int(ptrbox.getref_base(),
- self.memo_cast))
+## def do_cast_ptr_to_int(self, ptrbox):
+## return history.BoxInt(llimpl.cast_to_int(ptrbox.getref_base(),
+## self.memo_cast))
def bh_cast_ptr_to_int(self, ptr):
return llimpl.cast_to_int(ptr)
@@ -596,7 +585,7 @@
return self.get_fail_descr_from_number(fail_index)
-class OOtypeCPU(BaseCPU):
+class OOtypeCPU_xxx_disabled(BaseCPU):
is_oo = True
ts = oohelper
@@ -915,4 +904,4 @@
import pypy.jit.metainterp.executor
pypy.jit.metainterp.executor.make_execute_list(LLtypeCPU)
-pypy.jit.metainterp.executor.make_execute_list(OOtypeCPU)
+##pypy.jit.metainterp.executor.make_execute_list(OOtypeCPU)
Modified: pypy/branch/blackhole-improvement/pypy/jit/backend/model.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/backend/model.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/backend/model.py Thu Apr 29 16:08:20 2010
@@ -155,32 +155,6 @@
# lltype specific operations
# --------------------------
- def do_arraylen_gc(self, arraybox, arraydescr):
- raise NotImplementedError
-
- def do_strlen(self, stringbox):
- raise NotImplementedError
-
- def do_strgetitem(self, stringbox, indexbox):
- raise NotImplementedError
-
- def do_unicodelen(self, stringbox):
- raise NotImplementedError
-
- def do_unicodegetitem(self, stringbox, indexbox):
- raise NotImplementedError
-
- def do_getarrayitem_gc(self, arraybox, indexbox, arraydescr):
- raise NotImplementedError
-
- def do_arraycopy(self, calldescr, fnptr, sourcebox, destbox,
- source_startbox, dest_startbox, lengthbox, arraydescr):
- return self.do_call([fnptr, sourcebox, destbox, source_startbox,
- dest_startbox, lengthbox], calldescr)
-
- def do_getfield_gc(self, structbox, fielddescr):
- raise NotImplementedError
-
def bh_getfield_gc_i(self, struct, fielddescr):
raise NotImplementedError
def bh_getfield_gc_c(self, struct, fielddescr):
@@ -192,9 +166,6 @@
def bh_getfield_gc_f(self, struct, fielddescr):
raise NotImplementedError
- def do_getfield_raw(self, structbox, fielddescr):
- raise NotImplementedError
-
def bh_getfield_raw_i(self, struct, fielddescr):
raise NotImplementedError
def bh_getfield_raw_c(self, struct, fielddescr):
@@ -206,28 +177,14 @@
def bh_getfield_raw_f(self, struct, fielddescr):
raise NotImplementedError
- def do_new(self, sizedescr):
- raise NotImplementedError
-
def bh_new(self, sizedescr):
raise NotImplementedError
-
- def do_new_with_vtable(self, classbox):
- raise NotImplementedError
-
def bh_new_with_vtable(self, sizevtabledescr):
raise NotImplementedError
-
- def bh_classof(self, struct):
- raise NotImplementedError
-
- def do_new_array(self, lengthbox, arraydescr):
- raise NotImplementedError
-
def bh_new_array(self, arraydescr, length):
raise NotImplementedError
- def do_setarrayitem_gc(self, arraybox, indexbox, newvaluebox, arraydescr):
+ def bh_classof(self, struct):
raise NotImplementedError
def bh_setarrayitem_gc_i(self, arraydescr, array, index, newvalue):
@@ -237,12 +194,6 @@
def bh_setarrayitem_gc_f(self, arraydescr, array, index, newvalue):
raise NotImplementedError
- def do_setarrayitem_raw(self, arraybox, indexbox, newvaluebox, arraydescr):
- raise NotImplementedError
-
- def do_setfield_gc(self, structbox, newvaluebox, fielddescr):
- raise NotImplementedError
-
def bh_setfield_gc_i(self, struct, fielddescr, newvalue):
raise NotImplementedError
def bh_setfield_gc_c(self, struct, fielddescr, newvalue):
@@ -254,9 +205,6 @@
def bh_setfield_gc_f(self, struct, fielddescr, newvalue):
raise NotImplementedError
- def do_setfield_raw(self, structbox, newvaluebox, fielddescr):
- raise NotImplementedError
-
def bh_setfield_raw_i(self, struct, fielddescr, newvalue):
raise NotImplementedError
def bh_setfield_raw_c(self, struct, fielddescr, newvalue):
@@ -268,19 +216,6 @@
def bh_setfield_raw_f(self, struct, fielddescr, newvalue):
raise NotImplementedError
- def do_newstr(self, lengthbox):
- raise NotImplementedError
-
- def do_newunicode(self, lengthbox):
- raise NotImplementedError
-
- def do_strsetitem(self, stringbox, indexbox, charbox):
- raise NotImplementedError
-
- def do_unicodesetitem(self, stringbox, indexbox, charbox):
- raise NotImplementedError
-
- # blackhole interface
def bh_call_i(self, func, calldescr, args_i, args_r, args_f):
raise NotImplementedError
def bh_call_r(self, func, calldescr, args_i, args_r, args_f):
@@ -290,41 +225,8 @@
def bh_call_v(self, func, calldescr, args_i, args_r, args_f):
raise NotImplementedError
- def do_call(self, args, calldescr):
- raise NotImplementedError
-
- def do_call_assembler(self, args, token):
- raise NotImplementedError
-
- def do_call_loopinvariant(self, args, calldescr):
- return self.do_call(args, calldescr)
-
- def do_cond_call_gc_wb(self, args, calldescr):
- raise NotImplementedError
-
- def do_cast_ptr_to_int(self, ptrbox):
- raise NotImplementedError
-
def bh_cast_ptr_to_int(self, ptr):
raise NotImplementedError
- def do_call_may_force(self, args, calldescr):
- return self.do_call(args, calldescr)
-
def force(self, force_token):
raise NotImplementedError
-
- # ootype specific operations
- # --------------------------
-
- def do_runtimenew(self, classbox):
- raise NotImplementedError
-
- def do_oosend(self, args, descr):
- raise NotImplementedError
-
- def do_instanceof(self, instancebox, typedescr):
- raise NotImplementedError
-
- def typedescr2classbox(self, descr):
- raise NotImplementedError
Modified: pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitter.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitter.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/codewriter/jitter.py Thu Apr 29 16:08:20 2010
@@ -387,6 +387,9 @@
else:
raise NoOp
+ def rewrite_op_bool_not(self, op):
+ return SpaceOperation('int_is_zero', op.args, op.result)
+
# ____________________________________________________________
def _with_prefix(prefix):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py Thu Apr 29 16:08:20 2010
@@ -1,6 +1,7 @@
from pypy.rlib.unroll import unrolling_iterable
-from pypy.rlib.rarithmetic import intmask, LONG_BIT, r_uint
+from pypy.rlib.rarithmetic import intmask, LONG_BIT, r_uint, ovfcheck
from pypy.rlib.objectmodel import we_are_translated
+from pypy.rlib.debug import make_sure_not_resized
from pypy.tool.sourcetools import func_with_new_name
from pypy.rpython.lltypesystem import lltype, llmemory, rclass
from pypy.rpython.lltypesystem.lloperation import llop
@@ -28,6 +29,8 @@
value = intmask(value << (LONG_BIT-8)) >> (LONG_BIT-8)
return value
+NULL = lltype.nullptr(llmemory.GCREF.TO)
+
class BlackholeInterpBuilder(object):
verbose = True
@@ -76,6 +79,7 @@
def _get_method(self, name, argcodes):
#
def handler(self, code, position):
+ assert position >= 0
args = ()
next_argcode = 0
for argtype in argtypes:
@@ -118,6 +122,7 @@
elif argtype == 'R': reg = self.registers_r[index]
elif argtype == 'F': reg = self.registers_f[index]
value.append(reg)
+ make_sure_not_resized(value)
position += length
elif argtype == 'self':
value = self
@@ -200,6 +205,7 @@
return BlackholeInterpreter(self)
def release_interp(self, interp):
+ interp.cleanup_registers_r()
self.blackholeinterps.append(interp)
@@ -210,10 +216,11 @@
self.dispatch_loop = builder.dispatch_loop
self.descrs = builder.descrs
self.op_catch_exception = builder.op_catch_exception
+ self.cleanup_required_in_registers_r = -1
#
if we_are_translated():
default_i = 0
- default_r = lltype.nullptr(llmemory.GCREF.TO)
+ default_r = NULL
default_f = 0.0
else:
default_i = MissingValue()
@@ -237,6 +244,9 @@
self.copy_constants(self.registers_r, jitcode.constants_r)
self.copy_constants(self.registers_f, jitcode.constants_f)
code = jitcode.code
+ self.cleanup_required_in_registers_r = max(
+ self.cleanup_required_in_registers_r,
+ ord(code[-1]))
while True:
try:
self.dispatch_loop(self, code, position)
@@ -246,10 +256,34 @@
# ...
except Exception, e:
if not we_are_translated():
- if not isinstance(e, LLException):
- raise
+ if isinstance(e, LLException):
+ pass # ok
+ elif isinstance(e, OverflowError):
+ e = self.get_standard_error_exception(OverflowError)
+ else:
+ raise # leave other exceptions be propagated
position = self.handle_exception_in_frame(e, code)
+ def get_result_i(self):
+ return self.registers_i[0]
+
+ def get_result_r(self):
+ return self.registers_r[0]
+
+ def get_result_f(self):
+ return self.registers_f[0]
+
+ def cleanup_registers_r(self):
+ # To avoid keeping references alive, this cleans up the registers_r.
+ # It does not clear the references set by copy_constants(), but
+ # these are all prebuilt constants anyway.
+ i = self.cleanup_required_in_registers_r
+ self.cleanup_required_in_registers_r = -1
+ while i >= 0:
+ self.registers_r[i] = NULL
+ i -= 1
+ self.exception_last_value = None
+
def handle_exception_in_frame(self, e, code):
# This frame raises an exception. First try to see if
# the exception is handled in the frame itself.
@@ -265,6 +299,14 @@
target = ord(code[position+1]) | (ord(code[position+2])<<8)
return target
+ def get_standard_error_exception(self, Class):
+ rtyper = self.cpu.rtyper
+ exdata = rtyper.getexceptiondata()
+ clsdef = rtyper.annotator.bookkeeper.getuniqueclassdef(Class)
+ evalue = exdata.get_standard_ll_exc_instance(rtyper, clsdef)
+ etype = rclass.ll_type(evalue)
+ return LLException(etype, evalue)
+
# XXX must be specialized
# XXX the real performance impact of the following loop is unclear
def copy_constants(self, registers, constants):
@@ -282,15 +324,40 @@
@arguments("i", "i", returns="i")
def opimpl_int_add(a, b):
- return a + b
+ return intmask(a + b)
@arguments("i", "i", returns="i")
def opimpl_int_sub(a, b):
- return a - b
+ return intmask(a - b)
@arguments("i", "i", returns="i")
def opimpl_int_mul(a, b):
- return a * b
+ return intmask(a * b)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_int_add_ovf(a, b):
+ return ovfcheck(a + b)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_int_sub_ovf(a, b):
+ return ovfcheck(a - b)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_int_mul_ovf(a, b):
+ return ovfcheck(a * b)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_int_floordiv(a, b):
+ return llop.int_floordiv(lltype.Signed, a, b)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_uint_floordiv(a, b):
+ c = llop.uint_floordiv(lltype.Unsigned, r_uint(a), r_uint(b))
+ return intmask(c)
+
+ @arguments("i", "i", returns="i")
+ def opimpl_int_mod(a, b):
+ return llop.int_mod(lltype.Signed, a, b)
@arguments("i", "i", returns="i")
def opimpl_int_and(a, b):
@@ -305,69 +372,99 @@
return a ^ b
@arguments("i", "i", returns="i")
- def opimpl_int_floordiv(a, b):
- return llop.int_floordiv(lltype.Signed, a, b)
+ def opimpl_int_rshift(a, b):
+ return a >> b
@arguments("i", "i", returns="i")
- def opimpl_int_mod(a, b):
- return llop.int_mod(lltype.Signed, a, b)
+ def opimpl_int_lshift(a, b):
+ return intmask(a << b)
@arguments("i", "i", returns="i")
- def opimpl_uint_floordiv(a, b):
- c = llop.uint_floordiv(lltype.Unsigned, r_uint(a), r_uint(b))
+ def opimpl_uint_rshift(a, b):
+ c = r_uint(a) >> r_uint(b)
return intmask(c)
+ @arguments("i", returns="i")
+ def opimpl_int_neg(a):
+ return intmask(-a)
+
+ @arguments("i", returns="i")
+ def opimpl_int_invert(a):
+ return intmask(~a)
+
@arguments("i", "i", returns="i")
def opimpl_int_lt(a, b):
- return int(a < b)
+ return intmask(a < b)
@arguments("i", "i", returns="i")
def opimpl_int_le(a, b):
- return int(a <= b)
+ return intmask(a <= b)
@arguments("i", "i", returns="i")
def opimpl_int_eq(a, b):
- return int(a == b)
+ return intmask(a == b)
@arguments("i", "i", returns="i")
def opimpl_int_ne(a, b):
- return int(a != b)
+ return intmask(a != b)
@arguments("i", "i", returns="i")
def opimpl_int_gt(a, b):
- return int(a > b)
+ return intmask(a > b)
@arguments("i", "i", returns="i")
def opimpl_int_ge(a, b):
- return int(a >= b)
+ return intmask(a >= b)
@arguments("i", returns="i")
def opimpl_int_is_zero(a):
- return int(not a)
+ return intmask(not a)
@arguments("i", returns="i")
def opimpl_int_is_true(a):
- return int(bool(a))
+ return intmask(bool(a))
+
+ @arguments("i", "i", returns="i")
+ def opimpl_uint_lt(a, b):
+ return intmask(r_uint(a) < r_uint(b))
+ @arguments("i", "i", returns="i")
+ def opimpl_uint_le(a, b):
+ return intmask(r_uint(a) <= r_uint(b))
+ @arguments("i", "i", returns="i")
+ def opimpl_uint_gt(a, b):
+ return intmask(r_uint(a) > r_uint(b))
+ @arguments("i", "i", returns="i")
+ def opimpl_uint_ge(a, b):
+ return intmask(r_uint(a) >= r_uint(b))
@arguments("r", "r", returns="i")
def opimpl_ptr_eq(a, b):
- return int(a == b)
+ return intmask(a == b)
@arguments("r", "r", returns="i")
def opimpl_ptr_ne(a, b):
- return int(a != b)
+ return intmask(a != b)
@arguments("r", returns="i")
def opimpl_ptr_iszero(a):
- return int(not a)
+ return intmask(not a)
@arguments("r", returns="i")
def opimpl_ptr_nonzero(a):
- return int(bool(a))
+ return intmask(bool(a))
@arguments("self", "i")
def opimpl_int_return(self, a):
- self.result_i = a
+ self.registers_i[0] = a
+ raise LeaveFrame
+ @arguments("self", "r")
+ def opimpl_ref_return(self, a):
+ self.registers_r[0] = a
+ raise LeaveFrame
+ @arguments("self", "f")
+ def opimpl_float_return(self, a):
+ self.registers_f[0] = a
+ raise LeaveFrame
+ @arguments("self")
+ def opimpl_void_return(self):
raise LeaveFrame
@arguments("i", returns="i")
def opimpl_int_copy(a):
return a
-
@arguments("r", returns="r")
def opimpl_ref_copy(a):
return a
-
@arguments("f", returns="f")
def opimpl_float_copy(a):
return a
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py Thu Apr 29 16:08:20 2010
@@ -12,129 +12,8 @@
from pypy.jit.metainterp.resoperation import rop
-# Operations in the _ALWAYS_PURE part of the table of resoperation.py
-# must return a ConstInt or ConstPtr. Other operations must return
-# a BoxInt or BoxPtr or None.
-
# ____________________________________________________________
-def do_int_add(cpu, box1, box2):
- return ConstInt(intmask(box1.getint() + box2.getint()))
-
-def do_int_sub(cpu, box1, box2):
- return ConstInt(intmask(box1.getint() - box2.getint()))
-
-def do_int_mul(cpu, box1, box2):
- return ConstInt(intmask(box1.getint() * box2.getint()))
-
-def do_int_floordiv(cpu, box1, box2):
- z = llop.int_floordiv(lltype.Signed, box1.getint(), box2.getint())
- return ConstInt(z)
-
-def do_uint_floordiv(cpu, box1, box2):
- z = llop.uint_floordiv(lltype.Unsigned, r_uint(box1.getint()),
- r_uint(box2.getint()))
- return ConstInt(intmask(z))
-
-def do_int_mod(cpu, box1, box2):
- z = llop.int_mod(lltype.Signed, box1.getint(), box2.getint())
- return ConstInt(z)
-
-def do_int_and(cpu, box1, box2):
- return ConstInt(box1.getint() & box2.getint())
-
-def do_int_or(cpu, box1, box2):
- return ConstInt(box1.getint() | box2.getint())
-
-def do_int_xor(cpu, box1, box2):
- return ConstInt(box1.getint() ^ box2.getint())
-
-def do_int_rshift(cpu, box1, box2):
- return ConstInt(box1.getint() >> box2.getint())
-
-def do_int_lshift(cpu, box1, box2):
- return ConstInt(intmask(box1.getint() << box2.getint()))
-
-def do_uint_rshift(cpu, box1, box2):
- v = r_uint(box1.getint()) >> r_uint(box2.getint())
- return ConstInt(intmask(v))
-
-# ----------
-
-def do_int_lt(cpu, box1, box2):
- return ConstInt(box1.getint() < box2.getint())
-
-def do_int_le(cpu, box1, box2):
- return ConstInt(box1.getint() <= box2.getint())
-
-def do_int_eq(cpu, box1, box2):
- return ConstInt(box1.getint() == box2.getint())
-
-def do_int_ne(cpu, box1, box2):
- return ConstInt(box1.getint() != box2.getint())
-
-def do_int_gt(cpu, box1, box2):
- return ConstInt(box1.getint() > box2.getint())
-
-def do_int_ge(cpu, box1, box2):
- return ConstInt(box1.getint() >= box2.getint())
-
-def do_uint_lt(cpu, box1, box2):
- return ConstInt(r_uint(box1.getint()) < r_uint(box2.getint()))
-
-def do_uint_le(cpu, box1, box2):
- return ConstInt(r_uint(box1.getint()) <= r_uint(box2.getint()))
-
-def do_uint_gt(cpu, box1, box2):
- return ConstInt(r_uint(box1.getint()) > r_uint(box2.getint()))
-
-def do_uint_ge(cpu, box1, box2):
- return ConstInt(r_uint(box1.getint()) >= r_uint(box2.getint()))
-
-# ----------
-
-def do_int_is_true(cpu, box1):
- return ConstInt(bool(box1.getint()))
-
-def do_int_neg(cpu, box1):
- return ConstInt(intmask(-box1.getint()))
-
-def do_int_invert(cpu, box1):
- return ConstInt(~box1.getint())
-
-def do_bool_not(cpu, box1):
- return ConstInt(not box1.getint())
-
-def do_same_as(cpu, box1):
- return box1
-
-def do_oois(cpu, box1, box2):
- tp = box1.type
- assert tp == box2.type
- if tp == INT:
- x = box1.getint() == box2.getint()
- elif tp == REF:
- x = box1.getref_base() == box2.getref_base()
- else:
- assert False
- return ConstInt(x)
-
-def do_ooisnot(cpu, box1, box2):
- tp = box1.type
- assert tp == box2.type
- if tp == INT:
- x = box1.getint() != box2.getint()
- elif tp == REF:
- x = box1.getref_base() != box2.getref_base()
- else:
- assert False
- return ConstInt(x)
-
-def do_subclassof(cpu, box1, box2):
- return ConstInt(cpu.ts.subclassOf(cpu, box1, box2))
-
-# ----------
-
def do_int_add_ovf(cpu, box1, box2):
x = box1.getint()
y = box2.getint()
@@ -243,6 +122,7 @@
def make_execute_list(cpuclass):
+ return # XXX
from pypy.jit.backend.model import AbstractCPU
if 0: # enable this to trace calls to do_xxx
def wrap(fn):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/pyjitpl.py Thu Apr 29 16:08:20 2010
@@ -45,9 +45,9 @@
def __init__(self, metainterp):
self.metainterp = metainterp
- self.boxes_i = [None] * 256
- self.boxes_r = [None] * 256
- self.boxes_f = [None] * 256
+ self.registers_i = [None] * 256
+ self.registers_r = [None] * 256
+ self.registers_f = [None] * 256
def setup(self, jitcode, greenkey=None):
assert isinstance(jitcode, JitCode)
@@ -57,25 +57,38 @@
# this is not None for frames that are recursive portal calls
self.greenkey = greenkey
# copy the constants in place
- self.copy_constants(self.boxes_i, jitcode.constants_i, ConstInt)
- self.copy_constants(self.boxes_r, jitcode.constants_r, ConstPtr)
- self.copy_constants(self.boxes_f, jitcode.constants_f, ConstFloat)
-
- def copy_constants(self, boxes, constants, ConstClass):
- """Copy jitcode.constants[0] to boxes[255],
- jitcode.constants[1] to boxes[254],
- jitcode.constants[2] to boxes[253], etc."""
+ self.copy_constants(self.registers_i, jitcode.constants_i, ConstInt)
+ self.copy_constants(self.registers_r, jitcode.constants_r, ConstPtr)
+ self.copy_constants(self.registers_f, jitcode.constants_f, ConstFloat)
+
+ def copy_constants(self, registers, constants, ConstClass):
+ """Copy jitcode.constants[0] to registers[255],
+ jitcode.constants[1] to registers[254],
+ jitcode.constants[2] to registers[253], etc."""
i = len(constants) - 1
while i >= 0:
j = 255 - i
assert j >= 0
- boxes[j] = ConstClass(constants[i])
+ registers[j] = ConstClass(constants[i])
i -= 1
copy_constants._annspecialcase_ = 'specialize:arg(3)'
# ------------------------------
# Decoding of the JitCode
+ def prepare_list_of_boxes(self, outvalue, startindex, position, argcode):
+ assert argcode in 'IRF'
+ code = self.bytecode
+ length = ord(code[position])
+ position += 1
+ for i in range(length):
+ index = ord(code[position+i])
+ if argcode == 'I': reg = self.registers_i[index]
+ elif argcode == 'R': reg = self.registers_r[index]
+ elif argcode == 'F': reg = self.registers_f[index]
+ outvalue[startindex+i] = reg
+ prepare_list_of_boxes._annspecialcase_ = 'specialize:arg(4)'
+
def load_int(self):
pc = self.pc
result = ord(self.bytecode[pc])
@@ -188,7 +201,7 @@
@arguments("box")
def opimpl_any_return(self, box):
- return self.metainterp.finishframe(box)
+ self.metainterp.finishframe(box)
opimpl_int_return = opimpl_any_return
opimpl_ref_return = opimpl_any_return
@@ -196,7 +209,7 @@
@arguments()
def opimpl_void_return(self):
- return self.metainterp.finishframe(None)
+ self.metainterp.finishframe(None)
@arguments("jumptarget")
def opimpl_goto(self, target):
@@ -592,9 +605,9 @@
def opimpl_call(self, callee, varargs):
return self.perform_call(callee, varargs)
- @arguments("descr", "varargs")
- def opimpl_residual_call(self, calldescr, varargs):
- return self.do_residual_call(varargs, descr=calldescr, exc=True)
+ @arguments("box", "descr", "boxes2")
+ def opimpl_residual_call_ir_i(self, funcbox, calldescr, argboxes):
+ return self.do_residual_call(funcbox, calldescr, argboxes, exc=True)
@arguments("descr", "varargs")
def opimpl_residual_call_loopinvariant(self, calldescr, varargs):
@@ -1008,9 +1021,9 @@
else:
return self.metainterp.assert_no_exception()
- def do_residual_call(self, argboxes, descr, exc):
+ def do_residual_call(self, funcbox, descr, argboxes, exc):
effectinfo = descr.get_extra_info()
- if effectinfo is None or effectinfo.forces_virtual_or_virtualizable:
+ if 0:# XXX effectinfo is None or effectinfo.forces_virtual_or_virtualizable:
# residual calls require attention to keep virtualizables in-sync
self.metainterp.vable_and_vrefs_before_residual_call()
# xxx do something about code duplication
@@ -1696,13 +1709,13 @@
count_i = count_r = count_f = 0
for box in original_boxes:
if box.type == history.INT:
- f.boxes_i[count_i] = box
+ f.registers_i[count_i] = box
count_i += 1
elif box.type == history.REF:
- f.boxes_r[count_r] = box
+ f.registers_r[count_r] = box
count_r += 1
elif box.type == history.FLOAT:
- f.boxes_f[count_f] = box
+ f.registers_f[count_f] = box
count_f += 1
else:
raise AssertionError(box.type)
@@ -2021,25 +2034,65 @@
from pypy.jit.metainterp.blackhole import signedord
#
def handler(self, position):
+ assert position >= 0
args = ()
next_argcode = 0
code = self.bytecode
position += 1
for argtype in argtypes:
- if argtype == "box":
+ if argtype == "box": # a box, of whatever type
argcode = argcodes[next_argcode]
next_argcode = next_argcode + 1
if argcode == 'i':
- value = self.boxes_i[ord(code[position])]
+ value = self.registers_i[ord(code[position])]
elif argcode == 'c':
value = ConstInt(signedord(code[position]))
elif argcode == 'r':
- value = self.boxes_r[ord(code[position])]
+ value = self.registers_r[ord(code[position])]
elif argcode == 'f':
- value = self.boxes_f[ord(code[position])]
+ value = self.registers_f[ord(code[position])]
else:
raise AssertionError("bad argcode")
position += 1
+ elif argtype == "descr":
+ assert argcodes[next_argcode] == 'd'
+ next_argcode = next_argcode + 1
+ index = ord(code[position]) | (ord(code[position+1])<<8)
+ value = self.metainterp.staticdata.opcode_descrs[index]
+ position += 2
+ elif argtype == "boxes": # a list of boxes of some type
+ length = ord(code[position])
+ value = [None] * length
+ self.prepare_list_of_boxes(value, 0, position,
+ argcodes[next_argcode])
+ next_argcode = next_argcode + 1
+ position += 1 + length
+ elif argtype == "boxes2": # two lists of boxes merged into one
+ length1 = ord(code[position])
+ position2 = position + 1 + length1
+ length2 = ord(code[position2])
+ value = [None] * (length1 + length2)
+ self.prepare_list_of_boxes(value, 0, position,
+ argcodes[next_argcode])
+ self.prepare_list_of_boxes(value, length1, position2,
+ argcodes[next_argcode + 1])
+ next_argcode = next_argcode + 2
+ position = position2 + 1 + length2
+ elif argtype == "boxes3": # three lists of boxes merged into one
+ length1 = ord(code[position])
+ position2 = position + 1 + length1
+ length2 = ord(code[position2])
+ position3 = position2 + 1 + length2
+ length3 = ord(code[position3])
+ value = [None] * (length1 + length2 + length3)
+ self.prepare_list_of_boxes(value, 0, position,
+ argcodes[next_argcode])
+ self.prepare_list_of_boxes(value, length1, position2,
+ argcodes[next_argcode + 1])
+ self.prepare_list_of_boxes(value, length1 + length2, position3,
+ argcodes[next_argcode + 2])
+ next_argcode = next_argcode + 3
+ position = position3 + 1 + length3
else:
raise AssertionError("bad argtype: %r" % (argtype,))
args += (value,)
@@ -2058,13 +2111,13 @@
target_index = ord(code[position])
if result_argcode == 'i':
assert resultbox.type == history.INT
- self.boxes_i[target_index] = resultbox
+ self.registers_i[target_index] = resultbox
elif result_argcode == 'r':
assert resultbox.type == history.REF
- self.boxes_r[target_index] = resultbox
+ self.registers_r[target_index] = resultbox
elif result_argcode == 'f':
assert resultbox.type == history.FLOAT
- self.boxes_f[target_index] = resultbox
+ self.registers_f[target_index] = resultbox
else:
raise AssertionError("bad result argcode")
#
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/resoperation.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/resoperation.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/resoperation.py Thu Apr 29 16:08:20 2010
@@ -177,10 +177,10 @@
'FLOAT_GT/2b',
'FLOAT_GE/2b',
#
+ 'INT_IS_ZERO/1b',
'INT_IS_TRUE/1b',
'INT_NEG/1',
'INT_INVERT/1',
- 'BOOL_NOT/1b',
#
'SAME_AS/1', # gets a Const or a Box, turns it into another Box
#
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_basic.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_basic.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_basic.py Thu Apr 29 16:08:20 2010
@@ -43,7 +43,7 @@
else:
raise TypeError(T)
blackholeinterp.run(mainjitcode, 0)
- return blackholeinterp.result_i
+ return blackholeinterp.get_result_i()
def _run_with_pyjitpl(cw, mainjitcode, args, testself):
from pypy.jit.metainterp import simple_optimize
@@ -174,7 +174,7 @@
class OOJitMixin(JitMixin):
type_system = 'ootype'
- CPUClass = runner.OOtypeCPU
+ #CPUClass = runner.OOtypeCPU
def setup_class(cls):
py.test.skip("ootype tests skipped for now")
@@ -538,6 +538,39 @@
res = self.interp_operations(f, [15])
assert res == -1
+ def test_int_add_ovf(self):
+ def f(x, y):
+ try:
+ return ovfcheck(x + y)
+ except OverflowError:
+ return -42
+ res = self.interp_operations(f, [-100, 2])
+ assert res == -98
+ res = self.interp_operations(f, [1, sys.maxint])
+ assert res == -42
+
+ def test_int_sub_ovf(self):
+ def f(x, y):
+ try:
+ return ovfcheck(x - y)
+ except OverflowError:
+ return -42
+ res = self.interp_operations(f, [-100, 2])
+ assert res == -102
+ res = self.interp_operations(f, [1, -sys.maxint])
+ assert res == -42
+
+ def test_int_mul_ovf(self):
+ def f(x, y):
+ try:
+ return ovfcheck(x * y)
+ except OverflowError:
+ return -42
+ res = self.interp_operations(f, [-100, 2])
+ assert res == -200
+ res = self.interp_operations(f, [-3, sys.maxint//2])
+ assert res == -42
+
def test_mod_ovf(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'x', 'y'])
def f(n, x, y):
Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_blackhole.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_blackhole.py (original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/test/test_blackhole.py Thu Apr 29 16:08:20 2010
@@ -37,7 +37,7 @@
blackholeinterp.setarg_i(0, 40)
blackholeinterp.setarg_i(1, 2)
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 42
+ assert blackholeinterp.get_result_i() == 42
def test_simple_const():
jitcode = JitCode("test")
@@ -48,7 +48,7 @@
'int_return/i': 1})
blackholeinterp.setarg_i(1, 6)
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 42
+ assert blackholeinterp.get_result_i() == 42
def test_simple_bigconst():
jitcode = JitCode("test")
@@ -59,7 +59,7 @@
'int_return/i': 1})
blackholeinterp.setarg_i(1, 10000)
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 42
+ assert blackholeinterp.get_result_i() == 42
def test_simple_loop():
jitcode = JitCode("test")
@@ -77,7 +77,7 @@
blackholeinterp.setarg_i(0x16, 6) # %i0
blackholeinterp.setarg_i(0x17, 100) # %i1
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 100+6+5+4+3
+ assert blackholeinterp.get_result_i() == 100+6+5+4+3
def test_simple_exception():
jitcode = JitCode("test")
@@ -95,11 +95,11 @@
#
blackholeinterp.setarg_i(0x9, 100)
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 200
+ assert blackholeinterp.get_result_i() == 200
#
blackholeinterp.setarg_i(0x9, -100)
blackholeinterp.run(jitcode, 0)
- assert blackholeinterp.result_i == 42
+ assert blackholeinterp.get_result_i() == 42
# ____________________________________________________________
More information about the Pypy-commit
mailing list