Author: Armin Rigo <[email protected]>
Branch: cleanup-llgraph-backend
Changeset: r58155:1379a0ac0c19
Date: 2012-10-17 11:26 +0200
http://bitbucket.org/pypy/pypy/changeset/1379a0ac0c19/
Log: work in progress, notably changing the argument order of bh_*() to
always pass the descr last.
diff --git a/pypy/jit/backend/llgraph/runner.py
b/pypy/jit/backend/llgraph/runner.py
--- a/pypy/jit/backend/llgraph/runner.py
+++ b/pypy/jit/backend/llgraph/runner.py
@@ -5,6 +5,7 @@
from pypy.jit.backend.llgraph import support
from pypy.jit.metainterp.history import Const, getkind, AbstractDescr, VOID
from pypy.jit.metainterp.resoperation import rop
+from pypy.jit.codewriter import heaptracker
from pypy.rpython.llinterp import LLInterpreter
from pypy.rpython.lltypesystem import lltype, llmemory, rclass, rstr
@@ -22,9 +23,9 @@
self.descr = descr
class ExecutionFinished(Exception):
- def __init__(self, descr, arg):
+ def __init__(self, descr, args):
self.descr = descr
- self.arg = arg
+ self.args = args
class Jump(Exception):
def __init__(self, descr, args):
@@ -36,6 +37,12 @@
self.RESULT = RESULT
self.ARGS = ARGS
+class SizeDescr(AbstractDescr):
+ def __init__(self, S):
+ self.S = S
+ def as_vtable_size_descr(self):
+ return self
+
class FieldDescr(AbstractDescr):
def __init__(self, S, fieldname):
self.S = S
@@ -88,7 +95,7 @@
frame.execute(loop.operations)
assert False
except ExecutionFinished, e:
- self.latest_values = [e.arg]
+ self.latest_values = e.args
return e.descr
except GuardFailed, e:
self.latest_values = e.failargs
@@ -119,6 +126,15 @@
self.descrs[key] = descr
return descr
+ def sizeof(self, S):
+ key = ('size', S)
+ try:
+ return self.descrs[key]
+ except KeyError:
+ descr = SizeDescr(S)
+ self.descrs[key] = descr
+ return descr
+
def fielddescrof(self, S, fieldname):
key = ('field', S, fieldname)
try:
@@ -185,36 +201,109 @@
res = func(*args)
return support.cast_result(RESULT, res)
- def _do_call(self, func, calldescr, args_i, args_r, args_f):
+ def _do_call(self, func, args_i, args_r, args_f, calldescr):
TP = llmemory.cast_int_to_adr(func).ptr._obj._TYPE
args = support.cast_call_args(TP.ARGS, args_i, args_r, args_f)
return self.call(func, calldescr, args)
bh_call_i = _do_call
+ bh_call_r = _do_call
+ bh_call_f = _do_call
+ bh_call_v = _do_call
- def do_getinteriorfield_gc(self, a, index, descr):
+ def bh_getfield_gc(self, p, descr):
+ p = lltype.cast_opaque_ptr(lltype.Ptr(descr.S), p)
+ return support.cast_result(descr.FIELD, getattr(p, descr.fieldname))
+
+ bh_getfield_gc_i = bh_getfield_gc
+ bh_getfield_gc_r = bh_getfield_gc
+ bh_getfield_gc_f = bh_getfield_gc
+
+ def bh_setfield_gc(self, p, newvalue, descr):
+ p = lltype.cast_opaque_ptr(lltype.Ptr(descr.S), p)
+ setattr(p, descr.fieldname, support.cast_arg(descr.FIELD, newvalue))
+
+ bh_setfield_gc_i = bh_setfield_gc
+ bh_setfield_gc_r = bh_setfield_gc
+ bh_setfield_gc_f = bh_setfield_gc
+
+ def bh_arraylen_gc(self, a, descr):
+ array = a._obj.container
+ return array.getlength()
+
+ def bh_setarrayitem_gc(self, a, index, item, descr):
+ array = a._obj.container
+ array.setitem(index, support.cast_arg(descr.A.OF, item))
+
+ def bh_getarrayitem_gc(self, a, index, descr):
+ array = a._obj.container
+ return support.cast_result(descr.A.OF, array.getitem(index))
+
+ def bh_strlen(self, s):
+ return s._obj.container.chars.getlength()
+
+ def bh_strgetitem(self, s, item):
+ return ord(s._obj.container.chars.getitem(item))
+
+ def bh_strsetitem(self, s, item, v):
+ s._obj.container.chars.setitem(item, chr(v))
+
+ def bh_copystrcontent(self, src, dst, srcstart, dststart, length):
+ src = lltype.cast_opaque_ptr(lltype.Ptr(rstr.STR), src)
+ dst = lltype.cast_opaque_ptr(lltype.Ptr(rstr.STR), dst)
+ assert 0 <= srcstart <= srcstart + length <= len(src.chars)
+ assert 0 <= dststart <= dststart + length <= len(dst.chars)
+ rstr.copy_string_contents(src, dst, srcstart, dststart, length)
+
+ def bh_copyunicodecontent(self, src, dst, srcstart, dststart, length):
+ src = lltype.cast_opaque_ptr(lltype.Ptr(rstr.UNICODE), src)
+ dst = lltype.cast_opaque_ptr(lltype.Ptr(rstr.UNICODE), dst)
+ assert 0 <= srcstart <= srcstart + length <= len(src.chars)
+ assert 0 <= dststart <= dststart + length <= len(dst.chars)
+ rstr.copy_unicode_contents(src, dst, srcstart, dststart, length)
+
+ def bh_getinteriorfield_gc(self, a, index, descr):
array = a._obj.container
return support.cast_result(descr.FIELD,
getattr(array.getitem(index), descr.fieldname))
- bh_getinteriorfield_gc_f = do_getinteriorfield_gc
- bh_getinteriorfield_gc_i = do_getinteriorfield_gc
- bh_getinteriorfield_gc_r = do_getinteriorfield_gc
+ bh_getinteriorfield_gc_f = bh_getinteriorfield_gc
+ bh_getinteriorfield_gc_i = bh_getinteriorfield_gc
+ bh_getinteriorfield_gc_r = bh_getinteriorfield_gc
- def do_setinteriorfield_gc(self, a, index, item, descr):
+ def bh_setinteriorfield_gc(self, a, index, item, descr):
array = a._obj.container
setattr(array.getitem(index), descr.fieldname,
support.cast_arg(descr.FIELD, item))
- bh_setinteriorfield_gc_f = do_setinteriorfield_gc
- bh_setinteriorfield_gc_r = do_setinteriorfield_gc
- bh_setinteriorfield_gc_i = do_setinteriorfield_gc
+ bh_setinteriorfield_gc_f = bh_setinteriorfield_gc
+ bh_setinteriorfield_gc_r = bh_setinteriorfield_gc
+ bh_setinteriorfield_gc_i = bh_setinteriorfield_gc
- def do_newunicode(self, length):
+ def bh_newunicode(self, length):
return lltype.cast_opaque_ptr(llmemory.GCREF,
lltype.malloc(rstr.UNICODE, length))
- bh_newunicode = do_newunicode
+ def bh_unicodelen(self, string):
+ return string._obj.container.chars.getlength()
+
+ def bh_unicodegetitem(self, string, index):
+ return ord(string._obj.container.chars.getitem(index))
+
+ def bh_unicodesetitem(self, string, index, newvalue):
+ string._obj.container.chars.setitem(index, unichr(newvalue))
+
+ def bh_new(self, sizedescr):
+ return lltype.cast_opaque_ptr(llmemory.GCREF,
+ lltype.malloc(sizedescr.S))
+
+ def bh_new_with_vtable(self, descr, vtable):
+ result = lltype.malloc(descr.S)
+ result_as_objptr = lltype.cast_pointer(rclass.OBJECTPTR, result)
+ result_as_objptr.typeptr = support.cast_from_int(rclass.CLASSTYPE,
+ vtable)
+ return lltype.cast_opaque_ptr(llmemory.GCREF, result)
+
class LLFrame(object):
def __init__(self, cpu, argboxes, args):
@@ -283,8 +372,8 @@
def fail_guard(self, descr):
raise GuardFailed(self._getfailargs(), descr)
- def execute_finish(self, descr, arg=None):
- raise ExecutionFinished(descr, arg)
+ def execute_finish(self, descr, *args):
+ raise ExecutionFinished(descr, args)
def execute_label(self, descr, *args):
argboxes = self.current_op.getarglist()
@@ -370,48 +459,16 @@
call_args = support.cast_call_args_in_order(args[0], args[1:])
return self.cpu.call(args[0], descr, call_args)
- def execute_getfield_gc(self, descr, p):
- p = lltype.cast_opaque_ptr(lltype.Ptr(descr.S), p)
- return support.cast_result(descr.FIELD, getattr(p, descr.fieldname))
+ def execute_same_as(self, _, x):
+ return x
- def execute_setfield_gc(self, descr, p, newvalue):
- p = lltype.cast_opaque_ptr(lltype.Ptr(descr.S), p)
- setattr(p, descr.fieldname, support.cast_arg(descr.FIELD, newvalue))
+ def execute_debug_merge_point(self, descr, *args):
+ pass
- def execute_arraylen_gc(self, descr, a):
- array = a._obj.container
- return array.getlength()
+ def execute_new_with_vtable(self, _, vtable):
+ descr = heaptracker.vtable2descr(self.cpu, vtable)
+ return self.cpu.bh_new_with_vtable(descr, vtable)
- def execute_setarrayitem_gc(self, descr, a, index, item):
- array = a._obj.container
- array.setitem(index, support.cast_arg(descr.A.OF, item))
-
- def execute_getarrayitem_gc(self, descr, a, index):
- array = a._obj.container
- return support.cast_result(descr.A.OF, array.getitem(index))
-
- def execute_strlen(self, descr, s):
- return s._obj.container.chars.getlength()
-
- def execute_strgetitem(self, descr, s, item):
- return ord(s._obj.container.chars.getitem(item))
-
- def execute_strsetitem(self, descr, s, item, v):
- s._obj.container.chars.setitem(item, chr(v))
-
- def execute_copystrcontent(self, _, src, dst, srcstart, dststart, length):
- src = lltype.cast_opaque_ptr(lltype.Ptr(rstr.STR), src)
- dst = lltype.cast_opaque_ptr(lltype.Ptr(rstr.STR), dst)
- assert 0 <= srcstart <= srcstart + length <= len(src.chars)
- assert 0 <= dststart <= dststart + length <= len(dst.chars)
- rstr.copy_string_contents(src, dst, srcstart, dststart, length)
-
- def execute_copyunicodecontent(self, _, src, dst, srcstart, dststart,
length):
- src = lltype.cast_opaque_ptr(lltype.Ptr(rstr.UNICODE), src)
- dst = lltype.cast_opaque_ptr(lltype.Ptr(rstr.UNICODE), dst)
- assert 0 <= srcstart <= srcstart + length <= len(src.chars)
- assert 0 <= dststart <= dststart + length <= len(dst.chars)
- rstr.copy_unicode_contents(src, dst, srcstart, dststart, length)
def _setup():
def _make_impl_from_blackhole_interp(opname):
@@ -434,18 +491,21 @@
def _new_execute(opname):
def execute(self, descr, *args):
- new_args = args + (descr,)
- return getattr(self.cpu, 'do_' + opname)(*new_args)
+ if descr is not None:
+ new_args = args + (descr,)
+ else:
+ new_args = args
+ return getattr(self.cpu, 'bh_' + opname)(*new_args)
execute.func_name = 'execute_' + opname
return execute
for k, v in rop.__dict__.iteritems():
if not k.startswith("_"):
- func = _make_impl_from_blackhole_interp(k)
fname = 'execute_' + k.lower()
- if func is not None and not hasattr(LLFrame, fname):
+ if not hasattr(LLFrame, fname):
+ func = _make_impl_from_blackhole_interp(k)
+ if func is None:
+ func = _new_execute(k.lower())
setattr(LLFrame, fname, func)
- elif hasattr(LLGraphCPU, 'do_' + k.lower()):
- setattr(LLFrame, fname, _new_execute(k.lower()))
_setup()
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
@@ -440,7 +440,7 @@
# --- end of GC unsafe code ---
return fval
- def bh_setinteriorfield_gc_i(self, gcref, itemindex, descr, value):
+ def bh_setinteriorfield_gc_i(self, gcref, itemindex, value, descr):
assert isinstance(descr, InteriorFieldDescr)
arraydescr = descr.arraydescr
ofs, size, _ = self.unpack_arraydescr_size(arraydescr)
@@ -458,7 +458,7 @@
else:
raise NotImplementedError("size = %d" % fieldsize)
- def bh_setinteriorfield_gc_r(self, gcref, itemindex, descr, newvalue):
+ def bh_setinteriorfield_gc_r(self, gcref, itemindex, newvalue, descr):
assert isinstance(descr, InteriorFieldDescr)
arraydescr = descr.arraydescr
ofs, size, _ = self.unpack_arraydescr_size(arraydescr)
@@ -471,7 +471,7 @@
items[0] = self.cast_gcref_to_int(newvalue)
# --- end of GC unsafe code ---
- def bh_setinteriorfield_gc_f(self, gcref, itemindex, descr, newvalue):
+ def bh_setinteriorfield_gc_f(self, gcref, itemindex, newvalue, descr):
assert isinstance(descr, InteriorFieldDescr)
arraydescr = descr.arraydescr
ofs, size, _ = self.unpack_arraydescr_size(arraydescr)
@@ -588,7 +588,7 @@
bh_setfield_raw_r = _base_do_setfield_r
bh_setfield_raw_f = _base_do_setfield_f
- def bh_raw_store_i(self, addr, offset, descr, newvalue):
+ def bh_raw_store_i(self, addr, offset, newvalue, descr):
ofs, size, sign = self.unpack_arraydescr_size(descr)
items = addr + offset
for TYPE, _, itemsize in unroll_basic_sizes:
@@ -597,7 +597,7 @@
items[0] = rffi.cast(TYPE, newvalue)
break
- def bh_raw_store_f(self, addr, offset, descr, newvalue):
+ def bh_raw_store_f(self, addr, offset, newvalue, descr):
items = rffi.cast(rffi.CArrayPtr(longlong.FLOATSTORAGE), addr + offset)
items[0] = newvalue
diff --git a/pypy/jit/backend/model.py b/pypy/jit/backend/model.py
--- a/pypy/jit/backend/model.py
+++ b/pypy/jit/backend/model.py
@@ -233,11 +233,11 @@
# lltype specific operations
# --------------------------
- def bh_getarrayitem_gc_i(self, arraydescr, array, index):
+ def bh_getarrayitem_gc_i(self, array, index, arraydescr):
raise NotImplementedError
- def bh_getarrayitem_gc_r(self, arraydescr, array, index):
+ def bh_getarrayitem_gc_r(self, array, index, arraydescr):
raise NotImplementedError
- def bh_getarrayitem_gc_f(self, arraydescr, array, index):
+ def bh_getarrayitem_gc_f(self, array, index, arraydescr):
raise NotImplementedError
def bh_getfield_gc_i(self, struct, fielddescr):
@@ -256,49 +256,63 @@
def bh_new(self, sizedescr):
raise NotImplementedError
- def bh_new_with_vtable(self, sizedescr, vtable):
+ def bh_new_with_vtable(self, vtable, sizedescr):
raise NotImplementedError
- def bh_new_array(self, arraydescr, length):
+ def bh_new_array(self, length, arraydescr):
raise NotImplementedError
def bh_newstr(self, length):
raise NotImplementedError
def bh_newunicode(self, length):
raise NotImplementedError
- def bh_arraylen_gc(self, arraydescr, array):
+ def bh_arraylen_gc(self, array, arraydescr):
raise NotImplementedError
def bh_classof(self, struct):
raise NotImplementedError
- def bh_setarrayitem_gc_i(self, arraydescr, array, index, newvalue):
+ def bh_setarrayitem_gc_i(self, array, index, newvalue, arraydescr):
raise NotImplementedError
- def bh_setarrayitem_gc_r(self, arraydescr, array, index, newvalue):
+ def bh_setarrayitem_gc_r(self, array, index, newvalue, arraydescr):
raise NotImplementedError
- def bh_setarrayitem_gc_f(self, arraydescr, array, index, newvalue):
+ def bh_setarrayitem_gc_f(self, array, index, newvalue, arraydescr):
raise NotImplementedError
- def bh_setfield_gc_i(self, struct, fielddescr, newvalue):
+ def bh_setfield_gc_i(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_setfield_gc_r(self, struct, fielddescr, newvalue):
+ def bh_setfield_gc_r(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_setfield_gc_f(self, struct, fielddescr, newvalue):
+ def bh_setfield_gc_f(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_setfield_raw_i(self, struct, fielddescr, newvalue):
+ def bh_setfield_raw_i(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_setfield_raw_r(self, struct, fielddescr, newvalue):
+ def bh_setfield_raw_r(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_setfield_raw_f(self, struct, fielddescr, newvalue):
+ def bh_setfield_raw_f(self, struct, newvalue, fielddescr):
raise NotImplementedError
- def bh_call_i(self, func, calldescr, args_i, args_r, args_f):
+ def bh_getinteriorfield_gc_i(self, array, index, descr):
raise NotImplementedError
- def bh_call_r(self, func, calldescr, args_i, args_r, args_f):
+ def bh_getinteriorfield_gc_r(self, array, index, descr):
raise NotImplementedError
- def bh_call_f(self, func, calldescr, args_i, args_r, args_f):
+ def bh_getinteriorfield_gc_f(self, array, index, descr):
raise NotImplementedError
- def bh_call_v(self, func, calldescr, args_i, args_r, args_f):
+
+ def bh_setinteriorfield_gc_i(self, array, index, item, descr):
+ raise NotImplementedError
+ def bh_setinteriorfield_gc_r(self, array, index, item, descr):
+ raise NotImplementedError
+ def bh_setinteriorfield_gc_f(self, array, index, item, descr):
+ raise NotImplementedError
+
+ def bh_call_i(self, func, args_i, args_r, args_f, calldescr):
+ raise NotImplementedError
+ def bh_call_r(self, func, args_i, args_r, args_f, calldescr):
+ raise NotImplementedError
+ def bh_call_f(self, func, args_i, args_r, args_f, calldescr):
+ raise NotImplementedError
+ def bh_call_v(self, func, args_i, args_r, args_f, calldescr):
raise NotImplementedError
def bh_strlen(self, string):
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
@@ -511,7 +511,7 @@
calldescr = cpu.calldescrof(deref(FPTR), (lltype.Char,), lltype.Char,
EffectInfo.MOST_GENERAL)
x = cpu.bh_call_i(self.get_funcbox(cpu, func_ptr).value,
- calldescr, [ord('A')], None, None)
+ [ord('A')], None, None, calldescr)
assert x == ord('B')
if cpu.supports_floats:
def func(f, i):
@@ -525,8 +525,8 @@
calldescr = cpu.calldescrof(FTP, FTP.ARGS, FTP.RESULT,
EffectInfo.MOST_GENERAL)
x = cpu.bh_call_f(self.get_funcbox(cpu, func_ptr).value,
- calldescr,
- [42], None, [longlong.getfloatstorage(3.5)])
+ [42], None, [longlong.getfloatstorage(3.5)],
+ calldescr)
assert longlong.getrealfloat(x) == 3.5 - 42
def test_call(self):
@@ -1926,7 +1926,7 @@
assert s.parent.chr2 == chr(150)
r = self.cpu.bh_getfield_gc_i(r1.value, descrshort)
assert r == 1313
- self.cpu.bh_setfield_gc_i(r1.value, descrshort, 1333)
+ self.cpu.bh_setfield_gc_i(r1.value, 1333, descrshort)
r = self.cpu.bh_getfield_gc_i(r1.value, descrshort)
assert r == 1333
r = self.execute_operation(rop.GETFIELD_GC, [r1], 'int',
@@ -2681,7 +2681,7 @@
#assert x.getref(rclass.OBJECTPTR).typeptr == vtable2
#
arraydescr = cpu.arraydescrof(A)
- x = cpu.bh_new_array(arraydescr, 7)
+ x = cpu.bh_new_array(7, arraydescr)
array = lltype.cast_opaque_ptr(lltype.Ptr(A), x)
assert len(array) == 7
#
@@ -3129,7 +3129,7 @@
calldescr = self.cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
x = self.cpu.bh_call_i(self.get_funcbox(self.cpu, f).value,
- calldescr, [value], None, None)
+ [value], None, None, calldescr)
assert x == expected, (
"%r: got %r, expected %r" % (RESTYPE, x, expected))
@@ -3198,7 +3198,7 @@
calldescr = self.cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
x = self.cpu.bh_call_f(self.get_funcbox(self.cpu, f).value,
- calldescr, None, None, [value])
+ None, None, [value], calldescr)
assert x == expected
def test_longlong_result_of_call_compiled(self):
@@ -3257,7 +3257,7 @@
ivalue = longlong.singlefloat2int(value)
iexpected = longlong.singlefloat2int(expected)
x = self.cpu.bh_call_i(self.get_funcbox(self.cpu, f).value,
- calldescr, [ivalue], None, None)
+ [ivalue], None, None, calldescr)
assert x == iexpected
def test_singlefloat_result_of_call_compiled(self):
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -936,34 +936,34 @@
def bhimpl_recursive_call_i(self, jdindex, greens_i, greens_r, greens_f,
reds_i, reds_r, reds_f):
fnptr, calldescr = self.get_portal_runner(jdindex)
- return self.cpu.bh_call_i(fnptr, calldescr,
+ return self.cpu.bh_call_i(fnptr,
greens_i + reds_i,
greens_r + reds_r,
- greens_f + reds_f)
+ greens_f + reds_f, calldescr)
@arguments("self", "i", "I", "R", "F", "I", "R", "F", returns="r")
def bhimpl_recursive_call_r(self, jdindex, greens_i, greens_r, greens_f,
reds_i, reds_r, reds_f):
fnptr, calldescr = self.get_portal_runner(jdindex)
- return self.cpu.bh_call_r(fnptr, calldescr,
+ return self.cpu.bh_call_r(fnptr,
greens_i + reds_i,
greens_r + reds_r,
- greens_f + reds_f)
+ greens_f + reds_f, calldescr)
@arguments("self", "i", "I", "R", "F", "I", "R", "F", returns="f")
def bhimpl_recursive_call_f(self, jdindex, greens_i, greens_r, greens_f,
reds_i, reds_r, reds_f):
fnptr, calldescr = self.get_portal_runner(jdindex)
- return self.cpu.bh_call_f(fnptr, calldescr,
+ return self.cpu.bh_call_f(fnptr,
greens_i + reds_i,
greens_r + reds_r,
- greens_f + reds_f)
+ greens_f + reds_f, calldescr)
@arguments("self", "i", "I", "R", "F", "I", "R", "F")
def bhimpl_recursive_call_v(self, jdindex, greens_i, greens_r, greens_f,
reds_i, reds_r, reds_f):
fnptr, calldescr = self.get_portal_runner(jdindex)
- return self.cpu.bh_call_v(fnptr, calldescr,
+ return self.cpu.bh_call_v(fnptr,
greens_i + reds_i,
greens_r + reds_r,
- greens_f + reds_f)
+ greens_f + reds_f, calldescr)
# ----------
# virtual refs
@@ -982,7 +982,7 @@
@arguments("cpu", "r", "d", "i", returns="i")
def bhimpl_check_neg_index(cpu, array, arraydescr, index):
if index < 0:
- index += cpu.bh_arraylen_gc(arraydescr, array)
+ index += cpu.bh_arraylen_gc(array, arraydescr)
return index
@arguments("cpu", "r", "d", "i", returns="i")
@@ -995,138 +995,138 @@
def bhimpl_newlist(cpu, structdescr, lengthdescr, itemsdescr,
arraydescr, length):
result = cpu.bh_new(structdescr)
- cpu.bh_setfield_gc_i(result, lengthdescr, length)
- items = cpu.bh_new_array(arraydescr, length)
- cpu.bh_setfield_gc_r(result, itemsdescr, items)
+ cpu.bh_setfield_gc_i(result, length, lengthdescr)
+ items = cpu.bh_new_array(length, arraydescr)
+ cpu.bh_setfield_gc_r(result, items, itemsdescr)
return result
@arguments("cpu", "d", "d", "d", "d", "i", returns="r")
def bhimpl_newlist_hint(cpu, structdescr, lengthdescr, itemsdescr,
arraydescr, lengthhint):
result = cpu.bh_new(structdescr)
- cpu.bh_setfield_gc_i(result, lengthdescr, 0)
- items = cpu.bh_new_array(arraydescr, lengthhint)
- cpu.bh_setfield_gc_r(result, itemsdescr, items)
+ cpu.bh_setfield_gc_i(result, 0, lengthdescr)
+ items = cpu.bh_new_array(lengthhint, arraydescr)
+ cpu.bh_setfield_gc_r(result, items, itemsdescr)
return result
@arguments("cpu", "r", "d", "d", "i", returns="i")
def bhimpl_getlistitem_gc_i(cpu, lst, itemsdescr, arraydescr, index):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- return cpu.bh_getarrayitem_gc_i(arraydescr, items, index)
+ return cpu.bh_getarrayitem_gc_i(items, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", returns="r")
def bhimpl_getlistitem_gc_r(cpu, lst, itemsdescr, arraydescr, index):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- return cpu.bh_getarrayitem_gc_r(arraydescr, items, index)
+ return cpu.bh_getarrayitem_gc_r(items, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", returns="f")
def bhimpl_getlistitem_gc_f(cpu, lst, itemsdescr, arraydescr, index):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- return cpu.bh_getarrayitem_gc_f(arraydescr, items, index)
+ return cpu.bh_getarrayitem_gc_f(items, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", "i")
def bhimpl_setlistitem_gc_i(cpu, lst, itemsdescr, arraydescr, index, nval):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- cpu.bh_setarrayitem_gc_i(arraydescr, items, index, nval)
+ cpu.bh_setarrayitem_gc_i(items, index, nval, arraydescr)
@arguments("cpu", "r", "d", "d", "i", "r")
def bhimpl_setlistitem_gc_r(cpu, lst, itemsdescr, arraydescr, index, nval):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- cpu.bh_setarrayitem_gc_r(arraydescr, items, index, nval)
+ cpu.bh_setarrayitem_gc_r(items, index, nval, arraydescr)
@arguments("cpu", "r", "d", "d", "i", "f")
def bhimpl_setlistitem_gc_f(cpu, lst, itemsdescr, arraydescr, index, nval):
items = cpu.bh_getfield_gc_r(lst, itemsdescr)
- cpu.bh_setarrayitem_gc_f(arraydescr, items, index, nval)
+ cpu.bh_setarrayitem_gc_f(items, index, nval, arraydescr)
# ----------
# the following operations are directly implemented by the backend
@arguments("cpu", "i", "d", "R", returns="i")
def bhimpl_residual_call_r_i(cpu, func, calldescr, args_r):
- return cpu.bh_call_i(func, calldescr, None, args_r, None)
+ return cpu.bh_call_i(func, None, args_r, None, calldescr)
@arguments("cpu", "i", "d", "R", returns="r")
def bhimpl_residual_call_r_r(cpu, func, calldescr, args_r):
- return cpu.bh_call_r(func, calldescr, None, args_r, None)
+ return cpu.bh_call_r(func, None, args_r, None, calldescr)
@arguments("cpu", "i", "d", "R")
def bhimpl_residual_call_r_v(cpu, func, calldescr, args_r):
- return cpu.bh_call_v(func, calldescr, None, args_r, None)
+ return cpu.bh_call_v(func, None, args_r, None, calldescr)
@arguments("cpu", "i", "d", "I", "R", returns="i")
def bhimpl_residual_call_ir_i(cpu, func, calldescr, args_i, args_r):
- return cpu.bh_call_i(func, calldescr, args_i, args_r, None)
+ return cpu.bh_call_i(func, args_i, args_r, None, calldescr)
@arguments("cpu", "i", "d", "I", "R", returns="r")
def bhimpl_residual_call_ir_r(cpu, func, calldescr, args_i, args_r):
- return cpu.bh_call_r(func, calldescr, args_i, args_r, None)
+ return cpu.bh_call_r(func, args_i, args_r, None, calldescr)
@arguments("cpu", "i", "d", "I", "R")
def bhimpl_residual_call_ir_v(cpu, func, calldescr, args_i, args_r):
- return cpu.bh_call_v(func, calldescr, args_i, args_r, None)
+ return cpu.bh_call_v(func, args_i, args_r, None, calldescr)
@arguments("cpu", "i", "d", "I", "R", "F", returns="i")
def bhimpl_residual_call_irf_i(cpu, func, calldescr,args_i,args_r,args_f):
- return cpu.bh_call_i(func, calldescr, args_i, args_r, args_f)
+ return cpu.bh_call_i(func, args_i, args_r, args_f, calldescr)
@arguments("cpu", "i", "d", "I", "R", "F", returns="r")
def bhimpl_residual_call_irf_r(cpu, func, calldescr,args_i,args_r,args_f):
- return cpu.bh_call_r(func, calldescr, args_i, args_r, args_f)
+ return cpu.bh_call_r(func, args_i, args_r, args_f, calldescr)
@arguments("cpu", "i", "d", "I", "R", "F", returns="f")
def bhimpl_residual_call_irf_f(cpu, func, calldescr,args_i,args_r,args_f):
- return cpu.bh_call_f(func, calldescr, args_i, args_r, args_f)
+ return cpu.bh_call_f(func, args_i, args_r, args_f, calldescr)
@arguments("cpu", "i", "d", "I", "R", "F")
def bhimpl_residual_call_irf_v(cpu, func, calldescr,args_i,args_r,args_f):
- return cpu.bh_call_v(func, calldescr, args_i, args_r, args_f)
+ return cpu.bh_call_v(func, args_i, args_r, args_f, calldescr)
@arguments("cpu", "j", "R", returns="i")
def bhimpl_inline_call_r_i(cpu, jitcode, args_r):
- return cpu.bh_call_i(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- None, args_r, None)
+ return cpu.bh_call_i(jitcode.get_fnaddr_as_int(),
+ None, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "R", returns="r")
def bhimpl_inline_call_r_r(cpu, jitcode, args_r):
- return cpu.bh_call_r(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- None, args_r, None)
+ return cpu.bh_call_r(jitcode.get_fnaddr_as_int(),
+ None, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "R")
def bhimpl_inline_call_r_v(cpu, jitcode, args_r):
- return cpu.bh_call_v(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- None, args_r, None)
+ return cpu.bh_call_v(jitcode.get_fnaddr_as_int(),
+ None, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", returns="i")
def bhimpl_inline_call_ir_i(cpu, jitcode, args_i, args_r):
- return cpu.bh_call_i(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, None)
+ return cpu.bh_call_i(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", returns="r")
def bhimpl_inline_call_ir_r(cpu, jitcode, args_i, args_r):
- return cpu.bh_call_r(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, None)
+ return cpu.bh_call_r(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "I", "R")
def bhimpl_inline_call_ir_v(cpu, jitcode, args_i, args_r):
- return cpu.bh_call_v(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, None)
+ return cpu.bh_call_v(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, None, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", "F", returns="i")
def bhimpl_inline_call_irf_i(cpu, jitcode, args_i, args_r, args_f):
- return cpu.bh_call_i(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, args_f)
+ return cpu.bh_call_i(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, args_f, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", "F", returns="r")
def bhimpl_inline_call_irf_r(cpu, jitcode, args_i, args_r, args_f):
- return cpu.bh_call_r(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, args_f)
+ return cpu.bh_call_r(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, args_f, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", "F", returns="f")
def bhimpl_inline_call_irf_f(cpu, jitcode, args_i, args_r, args_f):
- return cpu.bh_call_f(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, args_f)
+ return cpu.bh_call_f(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, args_f, jitcode.calldescr)
@arguments("cpu", "j", "I", "R", "F")
def bhimpl_inline_call_irf_v(cpu, jitcode, args_i, args_r, args_f):
- return cpu.bh_call_v(jitcode.get_fnaddr_as_int(), jitcode.calldescr,
- args_i, args_r, args_f)
+ return cpu.bh_call_v(jitcode.get_fnaddr_as_int(),
+ args_i, args_r, args_f, jitcode.calldescr)
@arguments("cpu", "d", "i", returns="r")
def bhimpl_new_array(cpu, arraydescr, length):
- return cpu.bh_new_array(arraydescr, length)
+ return cpu.bh_new_array(length, arraydescr)
@arguments("cpu", "r", "d", "i", returns="i")
def bhimpl_getarrayitem_gc_i(cpu, array, arraydescr, index):
- return cpu.bh_getarrayitem_gc_i(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_i(array, index, arraydescr)
@arguments("cpu", "r", "d", "i", returns="r")
def bhimpl_getarrayitem_gc_r(cpu, array, arraydescr, index):
- return cpu.bh_getarrayitem_gc_r(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_r(array, index, arraydescr)
@arguments("cpu", "r", "d", "i", returns="f")
def bhimpl_getarrayitem_gc_f(cpu, array, arraydescr, index):
- return cpu.bh_getarrayitem_gc_f(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_f(array, index, arraydescr)
bhimpl_getarrayitem_gc_i_pure = bhimpl_getarrayitem_gc_i
bhimpl_getarrayitem_gc_r_pure = bhimpl_getarrayitem_gc_r
@@ -1134,67 +1134,67 @@
@arguments("cpu", "i", "d", "i", returns="i")
def bhimpl_getarrayitem_raw_i(cpu, array, arraydescr, index):
- return cpu.bh_getarrayitem_raw_i(arraydescr, array, index)
+ return cpu.bh_getarrayitem_raw_i(array, index, arraydescr)
@arguments("cpu", "i", "d", "i", returns="f")
def bhimpl_getarrayitem_raw_f(cpu, array, arraydescr, index):
- return cpu.bh_getarrayitem_raw_f(arraydescr, array, index)
+ return cpu.bh_getarrayitem_raw_f(array, index, arraydescr)
bhimpl_getarrayitem_raw_i_pure = bhimpl_getarrayitem_raw_i
bhimpl_getarrayitem_raw_f_pure = bhimpl_getarrayitem_raw_f
@arguments("cpu", "r", "d", "i", "i")
def bhimpl_setarrayitem_gc_i(cpu, array, arraydescr, index, newvalue):
- cpu.bh_setarrayitem_gc_i(arraydescr, array, index, newvalue)
+ cpu.bh_setarrayitem_gc_i(array, index, newvalue, arraydescr)
@arguments("cpu", "r", "d", "i", "r")
def bhimpl_setarrayitem_gc_r(cpu, array, arraydescr, index, newvalue):
- cpu.bh_setarrayitem_gc_r(arraydescr, array, index, newvalue)
+ cpu.bh_setarrayitem_gc_r(array, index, newvalue, arraydescr)
@arguments("cpu", "r", "d", "i", "f")
def bhimpl_setarrayitem_gc_f(cpu, array, arraydescr, index, newvalue):
- cpu.bh_setarrayitem_gc_f(arraydescr, array, index, newvalue)
+ cpu.bh_setarrayitem_gc_f(array, index, newvalue, arraydescr)
@arguments("cpu", "i", "d", "i", "i")
def bhimpl_setarrayitem_raw_i(cpu, array, arraydescr, index, newvalue):
- cpu.bh_setarrayitem_raw_i(arraydescr, array, index, newvalue)
+ cpu.bh_setarrayitem_raw_i(array, index, newvalue, arraydescr)
@arguments("cpu", "i", "d", "i", "f")
def bhimpl_setarrayitem_raw_f(cpu, array, arraydescr, index, newvalue):
- cpu.bh_setarrayitem_raw_f(arraydescr, array, index, newvalue)
+ cpu.bh_setarrayitem_raw_f(array, index, newvalue, arraydescr)
# note, there is no 'r' here, since it can't happen
@arguments("cpu", "r", "d", returns="i")
def bhimpl_arraylen_gc(cpu, array, arraydescr):
- return cpu.bh_arraylen_gc(arraydescr, array)
+ return cpu.bh_arraylen_gc(array, arraydescr)
@arguments("cpu", "r", "d", "d", "i", returns="i")
def bhimpl_getarrayitem_vable_i(cpu, vable, fielddescr, arraydescr, index):
array = cpu.bh_getfield_gc_r(vable, fielddescr)
- return cpu.bh_getarrayitem_gc_i(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_i(array, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", returns="r")
def bhimpl_getarrayitem_vable_r(cpu, vable, fielddescr, arraydescr, index):
array = cpu.bh_getfield_gc_r(vable, fielddescr)
- return cpu.bh_getarrayitem_gc_r(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_r(array, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", returns="f")
def bhimpl_getarrayitem_vable_f(cpu, vable, fielddescr, arraydescr, index):
array = cpu.bh_getfield_gc_r(vable, fielddescr)
- return cpu.bh_getarrayitem_gc_f(arraydescr, array, index)
+ return cpu.bh_getarrayitem_gc_f(array, index, arraydescr)
@arguments("cpu", "r", "d", "d", "i", "i")
def bhimpl_setarrayitem_vable_i(cpu, vable, fdescr, adescr, index, newval):
array = cpu.bh_getfield_gc_r(vable, fdescr)
- cpu.bh_setarrayitem_gc_i(adescr, array, index, newval)
+ cpu.bh_setarrayitem_gc_i(array, index, newval, adescr)
@arguments("cpu", "r", "d", "d", "i", "r")
def bhimpl_setarrayitem_vable_r(cpu, vable, fdescr, adescr, index, newval):
array = cpu.bh_getfield_gc_r(vable, fdescr)
- cpu.bh_setarrayitem_gc_r(adescr, array, index, newval)
+ cpu.bh_setarrayitem_gc_r(array, index, newval, adescr)
@arguments("cpu", "r", "d", "d", "i", "f")
def bhimpl_setarrayitem_vable_f(cpu, vable, fdescr, adescr, index, newval):
array = cpu.bh_getfield_gc_r(vable, fdescr)
- cpu.bh_setarrayitem_gc_f(adescr, array, index, newval)
+ cpu.bh_setarrayitem_gc_f(array, index, newval, adescr)
@arguments("cpu", "r", "d", "d", returns="i")
def bhimpl_arraylen_vable(cpu, vable, fdescr, adescr):
array = cpu.bh_getfield_gc_r(vable, fdescr)
- return cpu.bh_arraylen_gc(adescr, array)
+ return cpu.bh_arraylen_gc(array, adescr)
@arguments("cpu", "r", "i", "d", returns="i")
def bhimpl_getinteriorfield_gc_i(cpu, array, index, descr):
@@ -1254,13 +1254,13 @@
@arguments("cpu", "r", "d", "i")
def bhimpl_setfield_gc_i(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_gc_i(struct, fielddescr, newvalue)
+ cpu.bh_setfield_gc_i(struct, newvalue, fielddescr)
@arguments("cpu", "r", "d", "r")
def bhimpl_setfield_gc_r(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_gc_r(struct, fielddescr, newvalue)
+ cpu.bh_setfield_gc_r(struct, newvalue, fielddescr)
@arguments("cpu", "r", "d", "f")
def bhimpl_setfield_gc_f(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_gc_f(struct, fielddescr, newvalue)
+ cpu.bh_setfield_gc_f(struct, newvalue, fielddescr)
bhimpl_setfield_vable_i = bhimpl_setfield_gc_i
bhimpl_setfield_vable_r = bhimpl_setfield_gc_r
@@ -1268,20 +1268,20 @@
@arguments("cpu", "i", "d", "i")
def bhimpl_setfield_raw_i(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_raw_i(struct, fielddescr, newvalue)
+ cpu.bh_setfield_raw_i(struct, newvalue, fielddescr)
@arguments("cpu", "i", "d", "r")
def bhimpl_setfield_raw_r(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_raw_r(struct, fielddescr, newvalue)
+ cpu.bh_setfield_raw_r(struct, newvalue, fielddescr)
@arguments("cpu", "i", "d", "f")
def bhimpl_setfield_raw_f(cpu, struct, fielddescr, newvalue):
- cpu.bh_setfield_raw_f(struct, fielddescr, newvalue)
+ cpu.bh_setfield_raw_f(struct, newvalue, fielddescr)
@arguments("cpu", "i", "i", "d", "i")
def bhimpl_raw_store_i(cpu, addr, offset, arraydescr, newvalue):
- cpu.bh_raw_store_i(addr, offset, arraydescr, newvalue)
+ cpu.bh_raw_store_i(addr, offset, newvalue, arraydescr)
@arguments("cpu", "i", "i", "d", "f")
def bhimpl_raw_store_f(cpu, addr, offset, arraydescr, newvalue):
- cpu.bh_raw_store_f(addr, offset, arraydescr, newvalue)
+ cpu.bh_raw_store_f(addr, offset, newvalue, arraydescr)
@arguments("cpu", "i", "i", "d", returns="i")
def bhimpl_raw_load_i(cpu, addr, offset, arraydescr):
@@ -1306,7 +1306,7 @@
@arguments("cpu", "d", returns="r")
def bhimpl_new_with_vtable(cpu, descr):
vtable = heaptracker.descr2vtable(cpu, descr)
- return cpu.bh_new_with_vtable(descr, vtable)
+ return cpu.bh_new_with_vtable(vtable, descr)
@arguments("cpu", "r", returns="i")
def bhimpl_guard_class(cpu, struct):
_______________________________________________
pypy-commit mailing list
[email protected]
http://mail.python.org/mailman/listinfo/pypy-commit
