[pypy-commit] pypy op_malloc_gc: Start to reorganize dsecr.py to kill the obscure (and now half pointless)
arigo
noreply at buildbot.pypy.org
Sat Dec 17 18:52:32 CET 2011
Author: Armin Rigo <arigo at tunes.org>
Branch: op_malloc_gc
Changeset: r50630:bab5597339cc
Date: 2011-12-17 18:46 +0100
http://bitbucket.org/pypy/pypy/changeset/bab5597339cc/
Log: Start to reorganize dsecr.py to kill the obscure (and now half
pointless) inheritance.
diff --git a/pypy/jit/backend/llsupport/descr.py b/pypy/jit/backend/llsupport/descr.py
--- a/pypy/jit/backend/llsupport/descr.py
+++ b/pypy/jit/backend/llsupport/descr.py
@@ -6,11 +6,6 @@
from pypy.jit.metainterp import history
from pypy.jit.codewriter import heaptracker, longlong
-# The point of the class organization in this file is to make instances
-# as compact as possible. This is done by not storing the field size or
-# the 'is_pointer_field' flag in the instance itself but in the class
-# (in methods actually) using a few classes instead of just one.
-
class GcCache(object):
def __init__(self, translate_support_code, rtyper=None):
@@ -79,229 +74,108 @@
# ____________________________________________________________
# FieldDescrs
-class BaseFieldDescr(AbstractDescr):
+FLAG_POINTER = 'P'
+FLAG_FLOAT = 'F'
+FLAG_UNSIGNED = 'U'
+FLAG_SIGNED = 'S'
+FLAG_STRUCT = 'X'
+
+class FieldDescr(AbstractDescr):
+ name = ''
offset = 0 # help translation
- name = ''
- _clsname = ''
+ field_size = 0
+ flag = '\x00'
- def __init__(self, name, offset):
+ def __init__(self, name, offset, field_size, flag):
self.name = name
self.offset = offset
+ self.field_size = field_size
+ self.flag = flag
def sort_key(self):
return self.offset
- def get_field_size(self, translate_support_code):
- raise NotImplementedError
+ def repr_of_descr(self):
+ return '<Field%s %s %s>' % (self.flag, self.name, self.offset)
- _is_pointer_field = False # unless overridden by GcPtrFieldDescr
- _is_float_field = False # unless overridden by FloatFieldDescr
- _is_field_signed = False # unless overridden by XxxFieldDescr
-
- def is_pointer_field(self):
- return self._is_pointer_field
-
- def is_float_field(self):
- return self._is_float_field
-
- def is_field_signed(self):
- return self._is_field_signed
-
- def repr_of_descr(self):
- return '<%s %s %s>' % (self._clsname, self.name, self.offset)
-
-class DynamicFieldDescr(BaseFieldDescr):
- def __init__(self, offset, fieldsize, is_pointer, is_float, is_signed):
- self.offset = offset
- self._fieldsize = fieldsize
- self._is_pointer_field = is_pointer
- self._is_float_field = is_float
- self._is_field_signed = is_signed
-
- def get_field_size(self, translate_support_code):
- return self._fieldsize
-
-class NonGcPtrFieldDescr(BaseFieldDescr):
- _clsname = 'NonGcPtrFieldDescr'
- def get_field_size(self, translate_support_code):
- return symbolic.get_size_of_ptr(translate_support_code)
-
-class GcPtrFieldDescr(NonGcPtrFieldDescr):
- _clsname = 'GcPtrFieldDescr'
- _is_pointer_field = True
-
-def getFieldDescrClass(TYPE):
- return getDescrClass(TYPE, BaseFieldDescr, GcPtrFieldDescr,
- NonGcPtrFieldDescr, 'Field', 'get_field_size',
- '_is_float_field', '_is_field_signed')
def get_field_descr(gccache, STRUCT, fieldname):
cache = gccache._cache_field
try:
return cache[STRUCT][fieldname]
except KeyError:
- offset, _ = symbolic.get_field_token(STRUCT, fieldname,
- gccache.translate_support_code)
+ offset, size = symbolic.get_field_token(STRUCT, fieldname,
+ gccache.translate_support_code)
FIELDTYPE = getattr(STRUCT, fieldname)
+ flag = get_type_flag(FIELDTYPE)
name = '%s.%s' % (STRUCT._name, fieldname)
- fielddescr = getFieldDescrClass(FIELDTYPE)(name, offset)
+ fielddescr = FieldDescr(name, offset, size, flag)
cachedict = cache.setdefault(STRUCT, {})
cachedict[fieldname] = fielddescr
return fielddescr
+def get_type_flag(TYPE):
+ if isinstance(TYPE, lltype.Ptr):
+ if TYPE.TO._gckind == 'gc':
+ return FLAG_POINTER
+ else:
+ return FLAG_UNSIGNED
+ if isinstance(TYPE, lltype.Struct):
+ return FLAG_STRUCT
+ if TYPE is lltype.Float or is_longlong(TYPE):
+ return FLAG_FLOAT
+ if (TYPE is not lltype.Bool and isinstance(TYPE, lltype.Number) and
+ rffi.cast(TYPE, -1) == -1):
+ return FLAG_SIGNED
+ return FLAG_UNSIGNED
+
def get_field_arraylen_descr(gccache, ARRAY_OR_STRUCT):
cache = gccache._cache_arraylen
- if isinstance(ARRAY_OR_STRUCT, lltype.GcArray):
- # assume that they all have the length at the same offset
- key = 'array'
- else:
- # assume that it is STR or UNICODE
- assert isinstance(ARRAY_OR_STRUCT.chars, lltype.Array)
- key = ARRAY_OR_STRUCT
try:
- return cache[key]
+ return cache[ARRAY_OR_STRUCT]
except KeyError:
tsc = gccache.translate_support_code
(_, _, ofs) = symbolic.get_array_token(ARRAY_OR_STRUCT, tsc)
- if key == 'array' and not tsc:
- (_, _, baseofs) = symbolic.get_array_token(_A, tsc)
- assert baseofs == ofs, ("arrays %r and %r don't have the length "
- "field at the same offset!" %
- (ARRAY_OR_STRUCT, _A))
- SignedFieldDescr = getFieldDescrClass(lltype.Signed)
- result = SignedFieldDescr("len", ofs)
- cache[key] = result
+ size = symbolic.get_size(lltype.Signed, tsc)
+ result = FieldDescr("len", ofs, size, get_type_flag(lltype.Signed))
+ cache[ARRAY_OR_STRUCT] = result
return result
# ____________________________________________________________
# ArrayDescrs
-_A = lltype.GcArray(lltype.Signed) # a random gcarray
-_AF = lltype.GcArray(lltype.Float) # an array of C doubles
+class ArrayDescr(AbstractDescr):
+ tid = 0
+ basesize = 0 # workaround for the annotator
+ itemsize = 0
+ lendescr = None
+ flag = '\x00'
-class BaseArrayDescr(AbstractDescr):
- _clsname = ''
- tid = llop.combine_ushort(lltype.Signed, 0, 0)
-
- def get_base_size(self, translate_support_code):
- basesize, _, _ = symbolic.get_array_token(_A, translate_support_code)
- return basesize
-
- def get_ofs_length(self, translate_support_code):
- _, _, ofslength = symbolic.get_array_token(_A, translate_support_code)
- return ofslength
-
- def get_item_size(self, translate_support_code):
- raise NotImplementedError
-
- _is_array_of_pointers = False # unless overridden by GcPtrArrayDescr
- _is_array_of_floats = False # unless overridden by FloatArrayDescr
- _is_array_of_structs = False # unless overridden by StructArrayDescr
- _is_item_signed = False # unless overridden by XxxArrayDescr
-
- def is_array_of_pointers(self):
- return self._is_array_of_pointers
-
- def is_array_of_floats(self):
- return self._is_array_of_floats
-
- def is_array_of_structs(self):
- return self._is_array_of_structs
-
- def is_item_signed(self):
- return self._is_item_signed
+ def __init__(self, basesize, itemsize, lendescr, flag):
+ self.basesize = basesize
+ self.itemsize = itemsize
+ self.lendescr = lendescr # or None, if no length
+ self.flag = flag
def repr_of_descr(self):
- return '<%s>' % self._clsname
+ return '<Array%s %s>' % (self.flag, self.itemsize)
-class NonGcPtrArrayDescr(BaseArrayDescr):
- _clsname = 'NonGcPtrArrayDescr'
- def get_item_size(self, translate_support_code):
- return symbolic.get_size_of_ptr(translate_support_code)
-
-class GcPtrArrayDescr(NonGcPtrArrayDescr):
- _clsname = 'GcPtrArrayDescr'
- _is_array_of_pointers = True
-
-class FloatArrayDescr(BaseArrayDescr):
- _clsname = 'FloatArrayDescr'
- _is_array_of_floats = True
- def get_base_size(self, translate_support_code):
- basesize, _, _ = symbolic.get_array_token(_AF, translate_support_code)
- return basesize
- def get_item_size(self, translate_support_code):
- return symbolic.get_size(lltype.Float, translate_support_code)
-
-class StructArrayDescr(BaseArrayDescr):
- _clsname = 'StructArrayDescr'
- _is_array_of_structs = True
-
-class BaseArrayNoLengthDescr(BaseArrayDescr):
- def get_base_size(self, translate_support_code):
- return 0
-
- def get_ofs_length(self, translate_support_code):
- return -1
-
-class DynamicArrayNoLengthDescr(BaseArrayNoLengthDescr):
- def __init__(self, itemsize):
- self.itemsize = itemsize
-
- def get_item_size(self, translate_support_code):
- return self.itemsize
-
-class NonGcPtrArrayNoLengthDescr(BaseArrayNoLengthDescr):
- _clsname = 'NonGcPtrArrayNoLengthDescr'
- def get_item_size(self, translate_support_code):
- return symbolic.get_size_of_ptr(translate_support_code)
-
-class GcPtrArrayNoLengthDescr(NonGcPtrArrayNoLengthDescr):
- _clsname = 'GcPtrArrayNoLengthDescr'
- _is_array_of_pointers = True
-
-def getArrayDescrClass(ARRAY):
- if ARRAY.OF is lltype.Float:
- return FloatArrayDescr
- elif isinstance(ARRAY.OF, lltype.Struct):
- class Descr(StructArrayDescr):
- _clsname = '%sArrayDescr' % ARRAY.OF._name
- def get_item_size(self, translate_support_code):
- return symbolic.get_size(ARRAY.OF, translate_support_code)
- Descr.__name__ = Descr._clsname
- return Descr
- return getDescrClass(ARRAY.OF, BaseArrayDescr, GcPtrArrayDescr,
- NonGcPtrArrayDescr, 'Array', 'get_item_size',
- '_is_array_of_floats', '_is_item_signed')
-
-def getArrayNoLengthDescrClass(ARRAY):
- return getDescrClass(ARRAY.OF, BaseArrayNoLengthDescr, GcPtrArrayNoLengthDescr,
- NonGcPtrArrayNoLengthDescr, 'ArrayNoLength', 'get_item_size',
- '_is_array_of_floats', '_is_item_signed')
-
def get_array_descr(gccache, ARRAY):
cache = gccache._cache_array
try:
return cache[ARRAY]
except KeyError:
- # we only support Arrays that are either GcArrays, or raw no-length
- # non-gc Arrays.
+ assert isinstance(ARRAY, lltype.Array)
if ARRAY._hints.get('nolength', False):
- assert not isinstance(ARRAY, lltype.GcArray)
- arraydescr = getArrayNoLengthDescrClass(ARRAY)()
+ lendescr = None
else:
- assert isinstance(ARRAY, lltype.GcArray)
- arraydescr = getArrayDescrClass(ARRAY)()
- arraydescr.field_arraylen_descr = get_field_arraylen_descr(
- gccache, ARRAY)
- # verify basic assumption that all arrays' basesize and ofslength
- # are equal
- basesize, itemsize, ofslength = symbolic.get_array_token(ARRAY, False)
- assert basesize == arraydescr.get_base_size(False)
- assert itemsize == arraydescr.get_item_size(False)
- if not ARRAY._hints.get('nolength', False):
- assert ofslength == arraydescr.get_ofs_length(False)
+ lendescr = get_field_arraylen_descr(gccache, ARRAY)
+ tsc = gccache.translate_support_code
+ basesize, itemsize, _ = symbolic.get_array_token(ARRAY, tsc)
+ flag = get_type_flag(ARRAY.OF)
+ arraydescr = ArrayDescr(basesize, itemsize, lendescr, flag)
if isinstance(ARRAY, lltype.GcArray):
gccache.init_array_descr(ARRAY, arraydescr)
cache[ARRAY] = arraydescr
@@ -311,34 +185,29 @@
# InteriorFieldDescr
class InteriorFieldDescr(AbstractDescr):
- arraydescr = BaseArrayDescr() # workaround for the annotator
- fielddescr = BaseFieldDescr('', 0)
+ arraydescr = ArrayDescr(0, 0, None, '\x00') # workaround for the annotator
+ fielddescr = FieldDescr('', 0, 0, '\x00')
def __init__(self, arraydescr, fielddescr):
+ assert arraydescr.flag == FLAG_STRUCT
self.arraydescr = arraydescr
self.fielddescr = fielddescr
- def is_pointer_field(self):
- return self.fielddescr.is_pointer_field()
-
- def is_float_field(self):
- return self.fielddescr.is_float_field()
-
def sort_key(self):
return self.fielddescr.sort_key()
def repr_of_descr(self):
return '<InteriorFieldDescr %s>' % self.fielddescr.repr_of_descr()
-def get_interiorfield_descr(gc_ll_descr, ARRAY, FIELDTP, name):
+def get_interiorfield_descr(gc_ll_descr, ARRAY, name):
cache = gc_ll_descr._cache_interiorfield
try:
- return cache[(ARRAY, FIELDTP, name)]
+ return cache[(ARRAY, name)]
except KeyError:
arraydescr = get_array_descr(gc_ll_descr, ARRAY)
- fielddescr = get_field_descr(gc_ll_descr, FIELDTP, name)
+ fielddescr = get_field_descr(gc_ll_descr, ARRAY.OF, name)
descr = InteriorFieldDescr(arraydescr, fielddescr)
- cache[(ARRAY, FIELDTP, name)] = descr
+ cache[(ARRAY, name)] = descr
return descr
# ____________________________________________________________
@@ -473,21 +342,11 @@
class BaseIntCallDescr(BaseCallDescr):
- # Base class of the various subclasses of descrs corresponding to
- # calls having a return kind of 'int' (including non-gc pointers).
- # The inheritance hierarchy is a bit different than with other Descr
- # classes because of the 'call_stub' attribute, which is of type
- #
- # lambda func, args_i, args_r, args_f --> int/ref/float/void
- #
- # The purpose of BaseIntCallDescr is to be the parent of all classes
- # in which 'call_stub' has a return kind of 'int'.
+ # Calls having a return kind of 'int' (including non-gc pointers).
_return_type = history.INT
call_stub = staticmethod(lambda func, args_i, args_r, args_f: 0)
- _is_result_signed = False # can be overridden in XxxCallDescr
- def is_result_signed(self):
- return self._is_result_signed
+#...
class DynamicIntCallDescr(BaseIntCallDescr):
"""
diff --git a/pypy/jit/backend/llsupport/gc.py b/pypy/jit/backend/llsupport/gc.py
--- a/pypy/jit/backend/llsupport/gc.py
+++ b/pypy/jit/backend/llsupport/gc.py
@@ -120,6 +120,7 @@
gcrootmap = None
write_barrier_descr = None
fielddescr_tid = None
+ has_tid = False
str_type_id = 0
unicode_type_id = 0
@@ -166,9 +167,12 @@
def __init__(self, gcdescr, translator, rtyper):
GcLLDescription.__init__(self, gcdescr, translator, rtyper)
# grab a pointer to the Boehm 'malloc' function
- malloc_fn_ptr = self.configure_boehm_once()
- self.malloc_fn_ptr = malloc_fn_ptr
- #
+ self.malloc_fn_ptr = self.configure_boehm_once()
+ self._make_functions()
+
+ def _make_functions(self):
+ malloc_fn_ptr = self.malloc_fn_ptr
+
def malloc_fixedsize(size):
res = malloc_fn_ptr(size)
if not res:
@@ -177,6 +181,37 @@
self.generate_function('malloc_fixedsize', malloc_fixedsize,
[lltype.Signed])
+ def malloc_array(basesize, itemsize, num_elem):
+ xxx
+ try:
+ totalsize = ovfcheck(basesize + ovfcheck(itemsize * num_elem))
+ except OverflowError:
+ raise MemoryError
+ res = malloc_fn_ptr(totalsize)
+ if not res:
+ raise MemoryError
+ arrayptr = rffi.cast(rffi.CArrayPtr(lltype.Signed), res)
+ arrayptr[ofs_length/WORD] = num_elem
+ return res
+ self.generate_function('malloc_array', malloc_array,
+ [lltype.Signed] * 3)
+
+ def malloc_str(length):
+ return llop1.do_malloc_varsize_clear(
+ llmemory.GCREF,
+ str_type_id, length, str_basesize, str_itemsize,
+ str_ofs_length)
+ self.generate_function('malloc_str', malloc_str,
+ [lltype.Signed])
+
+ def malloc_unicode(length):
+ return llop1.do_malloc_varsize_clear(
+ llmemory.GCREF,
+ unicode_type_id, length, unicode_basesize, unicode_itemsize,
+ unicode_ofs_length)
+ self.generate_function('malloc_unicode', malloc_unicode,
+ [lltype.Signed])
+
def _gc_malloc(self, size, tid):
# Boehm: 'tid' is ignored
return self.malloc_fixedsize(size)
@@ -607,6 +642,7 @@
class GcLLDescr_framework(GcLLDescription):
DEBUG = False # forced to True by x86/test/test_zrpy_gc.py
+ has_tid = True
def __init__(self, gcdescr, translator, rtyper, llop1=llop,
really_not_translated=False):
diff --git a/pypy/jit/backend/llsupport/rewrite.py b/pypy/jit/backend/llsupport/rewrite.py
--- a/pypy/jit/backend/llsupport/rewrite.py
+++ b/pypy/jit/backend/llsupport/rewrite.py
@@ -85,7 +85,7 @@
self.handle_new_array(descr.tid,
descr.get_base_size(self.tsc),
descr.get_item_size(self.tsc),
- descr.field_arraylen_descr,
+ descr.get_field_arraylen_descr(),
op)
elif opnum == rop.NEWSTR:
self.handle_new_array(self.gc_ll_descr.str_type_id,
@@ -162,10 +162,17 @@
def gen_malloc_array(self, itemsize, tid, v_num_elem, v_result):
"""Generate a CALL_MALLOC_GC(malloc_array_fn, ...)."""
- self._gen_call_malloc_gc([self.gc_ll_descr.c_malloc_array_fn,
- ConstInt(itemsize),
- ConstInt(tid),
- v_num_elem], v_result)
+ if self.gc_ll_descr.has_tid:
+ args = [self.gc_ll_descr.c_malloc_array_fn,
+ ConstInt(itemsize),
+ ConstInt(tid),
+ v_num_elem]
+ else:
+ args = [self.gc_ll_descr.c_malloc_array_fn,
+ ConstInt(basesize),
+ ConstInt(itemsize),
+ v_num_elem]
+ self._gen_call_malloc_gc(args, v_result)
def gen_malloc_str(self, v_num_elem, v_result):
"""Generate a CALL_MALLOC_GC(malloc_str_fn, ...)."""
diff --git a/pypy/jit/backend/llsupport/test/test_descr.py b/pypy/jit/backend/llsupport/test/test_descr.py
--- a/pypy/jit/backend/llsupport/test/test_descr.py
+++ b/pypy/jit/backend/llsupport/test/test_descr.py
@@ -53,18 +53,6 @@
('z', lltype.Ptr(U)),
('f', lltype.Float),
('s', lltype.SingleFloat))
- assert getFieldDescrClass(lltype.Ptr(T)) is GcPtrFieldDescr
- assert getFieldDescrClass(lltype.Ptr(U)) is NonGcPtrFieldDescr
- cls = getFieldDescrClass(lltype.Char)
- assert cls != getFieldDescrClass(lltype.Signed)
- assert cls == getFieldDescrClass(lltype.Char)
- clsf = getFieldDescrClass(lltype.Float)
- assert clsf != cls
- assert clsf == getFieldDescrClass(lltype.Float)
- clss = getFieldDescrClass(lltype.SingleFloat)
- assert clss not in (cls, clsf)
- assert clss == getFieldDescrClass(lltype.SingleFloat)
- assert clss == getFieldDescrClass(rffi.UINT) # for now
#
c0 = GcCache(False)
c1 = GcCache(True)
@@ -77,11 +65,7 @@
descr_z = get_field_descr(c2, S, 'z')
descr_f = get_field_descr(c2, S, 'f')
descr_s = get_field_descr(c2, S, 's')
- assert descr_x.__class__ is cls
- assert descr_y.__class__ is GcPtrFieldDescr
- assert descr_z.__class__ is NonGcPtrFieldDescr
- assert descr_f.__class__ is clsf
- assert descr_s.__class__ is clss
+ assert isinstance(descr_x, FieldDescr)
assert descr_x.name == 'S.x'
assert descr_y.name == 'S.y'
assert descr_z.name == 'S.z'
@@ -90,33 +74,27 @@
if not tsc:
assert descr_x.offset < descr_y.offset < descr_z.offset
assert descr_x.sort_key() < descr_y.sort_key() < descr_z.sort_key()
- assert descr_x.get_field_size(False) == rffi.sizeof(lltype.Char)
- assert descr_y.get_field_size(False) == rffi.sizeof(lltype.Ptr(T))
- assert descr_z.get_field_size(False) == rffi.sizeof(lltype.Ptr(U))
- assert descr_f.get_field_size(False) == rffi.sizeof(lltype.Float)
- assert descr_s.get_field_size(False) == rffi.sizeof(
- lltype.SingleFloat)
+ assert descr_x.field_size == rffi.sizeof(lltype.Char)
+ assert descr_y.field_size == rffi.sizeof(lltype.Ptr(T))
+ assert descr_z.field_size == rffi.sizeof(lltype.Ptr(U))
+ assert descr_f.field_size == rffi.sizeof(lltype.Float)
+ assert descr_s.field_size == rffi.sizeof(lltype.SingleFloat)
else:
assert isinstance(descr_x.offset, Symbolic)
assert isinstance(descr_y.offset, Symbolic)
assert isinstance(descr_z.offset, Symbolic)
assert isinstance(descr_f.offset, Symbolic)
assert isinstance(descr_s.offset, Symbolic)
- assert isinstance(descr_x.get_field_size(True), Symbolic)
- assert isinstance(descr_y.get_field_size(True), Symbolic)
- assert isinstance(descr_z.get_field_size(True), Symbolic)
- assert isinstance(descr_f.get_field_size(True), Symbolic)
- assert isinstance(descr_s.get_field_size(True), Symbolic)
- assert not descr_x.is_pointer_field()
- assert descr_y.is_pointer_field()
- assert not descr_z.is_pointer_field()
- assert not descr_f.is_pointer_field()
- assert not descr_s.is_pointer_field()
- assert not descr_x.is_float_field()
- assert not descr_y.is_float_field()
- assert not descr_z.is_float_field()
- assert descr_f.is_float_field()
- assert not descr_s.is_float_field()
+ assert isinstance(descr_x.field_size, Symbolic)
+ assert isinstance(descr_y.field_size, Symbolic)
+ assert isinstance(descr_z.field_size, Symbolic)
+ assert isinstance(descr_f.field_size, Symbolic)
+ assert isinstance(descr_s.field_size, Symbolic)
+ assert descr_x.flag == FLAG_UNSIGNED
+ assert descr_y.flag == FLAG_POINTER
+ assert descr_z.flag == FLAG_UNSIGNED
+ assert descr_f.flag == FLAG_FLOAT
+ assert descr_s.flag == FLAG_UNSIGNED
def test_get_field_descr_sign():
@@ -128,7 +106,8 @@
for tsc in [False, True]:
c2 = GcCache(tsc)
descr_x = get_field_descr(c2, S, 'x')
- assert descr_x.is_field_signed() == signed
+ assert descr_x.flag == {False: FLAG_UNSIGNED,
+ True: FLAG_SIGNED }[signed]
def test_get_field_descr_longlong():
if sys.maxint > 2147483647:
@@ -136,9 +115,8 @@
c0 = GcCache(False)
S = lltype.GcStruct('S', ('y', lltype.UnsignedLongLong))
descr = get_field_descr(c0, S, 'y')
- assert not descr.is_pointer_field()
- assert descr.is_float_field()
- assert descr.get_field_size(False) == 8
+ assert descr.flag == FLAG_FLOAT
+ assert descr.field_size == 8
def test_get_array_descr():
@@ -149,19 +127,8 @@
A3 = lltype.GcArray(lltype.Ptr(U))
A4 = lltype.GcArray(lltype.Float)
A5 = lltype.GcArray(lltype.Struct('x', ('v', lltype.Signed),
- ('k', lltype.Signed)))
+ ('k', lltype.Signed)))
A6 = lltype.GcArray(lltype.SingleFloat)
- assert getArrayDescrClass(A2) is GcPtrArrayDescr
- assert getArrayDescrClass(A3) is NonGcPtrArrayDescr
- cls = getArrayDescrClass(A1)
- assert cls != getArrayDescrClass(lltype.GcArray(lltype.Signed))
- assert cls == getArrayDescrClass(lltype.GcArray(lltype.Char))
- clsf = getArrayDescrClass(A4)
- assert clsf != cls
- assert clsf == getArrayDescrClass(lltype.GcArray(lltype.Float))
- clss = getArrayDescrClass(A6)
- assert clss not in (clsf, cls)
- assert clss == getArrayDescrClass(lltype.GcArray(rffi.UINT))
#
c0 = GcCache(False)
descr1 = get_array_descr(c0, A1)
@@ -170,82 +137,61 @@
descr4 = get_array_descr(c0, A4)
descr5 = get_array_descr(c0, A5)
descr6 = get_array_descr(c0, A6)
- assert descr1.__class__ is cls
- assert descr2.__class__ is GcPtrArrayDescr
- assert descr3.__class__ is NonGcPtrArrayDescr
- assert descr4.__class__ is clsf
- assert descr6.__class__ is clss
+ assert isinstance(descr1, ArrayDescr)
assert descr1 == get_array_descr(c0, lltype.GcArray(lltype.Char))
- assert not descr1.is_array_of_pointers()
- assert descr2.is_array_of_pointers()
- assert not descr3.is_array_of_pointers()
- assert not descr4.is_array_of_pointers()
- assert not descr5.is_array_of_pointers()
- assert not descr1.is_array_of_floats()
- assert not descr2.is_array_of_floats()
- assert not descr3.is_array_of_floats()
- assert descr4.is_array_of_floats()
- assert not descr5.is_array_of_floats()
+ assert descr1.flag == FLAG_UNSIGNED
+ assert descr2.flag == FLAG_POINTER
+ assert descr3.flag == FLAG_UNSIGNED
+ assert descr4.flag == FLAG_FLOAT
+ assert descr5.flag == FLAG_STRUCT
+ assert descr6.flag == FLAG_UNSIGNED
#
def get_alignment(code):
# Retrieve default alignment for the compiler/platform
return struct.calcsize('l' + code) - struct.calcsize(code)
- assert descr1.get_base_size(False) == get_alignment('c')
- assert descr2.get_base_size(False) == get_alignment('p')
- assert descr3.get_base_size(False) == get_alignment('p')
- assert descr4.get_base_size(False) == get_alignment('d')
- assert descr5.get_base_size(False) == get_alignment('f')
- assert descr1.get_ofs_length(False) == 0
- assert descr2.get_ofs_length(False) == 0
- assert descr3.get_ofs_length(False) == 0
- assert descr4.get_ofs_length(False) == 0
- assert descr5.get_ofs_length(False) == 0
- assert descr1.get_item_size(False) == rffi.sizeof(lltype.Char)
- assert descr2.get_item_size(False) == rffi.sizeof(lltype.Ptr(T))
- assert descr3.get_item_size(False) == rffi.sizeof(lltype.Ptr(U))
- assert descr4.get_item_size(False) == rffi.sizeof(lltype.Float)
- assert descr5.get_item_size(False) == rffi.sizeof(lltype.Signed) * 2
- assert descr6.get_item_size(False) == rffi.sizeof(lltype.SingleFloat)
+ assert descr1.basesize == get_alignment('c')
+ assert descr2.basesize == get_alignment('p')
+ assert descr3.basesize == get_alignment('p')
+ assert descr4.basesize == get_alignment('d')
+ assert descr5.basesize == get_alignment('f')
+ assert descr1.lendescr.offset == 0
+ assert descr2.lendescr.offset == 0
+ assert descr3.lendescr.offset == 0
+ assert descr4.lendescr.offset == 0
+ assert descr5.lendescr.offset == 0
+ assert descr1.itemsize == rffi.sizeof(lltype.Char)
+ assert descr2.itemsize == rffi.sizeof(lltype.Ptr(T))
+ assert descr3.itemsize == rffi.sizeof(lltype.Ptr(U))
+ assert descr4.itemsize == rffi.sizeof(lltype.Float)
+ assert descr5.itemsize == rffi.sizeof(lltype.Signed) * 2
+ assert descr6.itemsize == rffi.sizeof(lltype.SingleFloat)
#
- assert isinstance(descr1.get_base_size(True), Symbolic)
- assert isinstance(descr2.get_base_size(True), Symbolic)
- assert isinstance(descr3.get_base_size(True), Symbolic)
- assert isinstance(descr4.get_base_size(True), Symbolic)
- assert isinstance(descr5.get_base_size(True), Symbolic)
- assert isinstance(descr1.get_ofs_length(True), Symbolic)
- assert isinstance(descr2.get_ofs_length(True), Symbolic)
- assert isinstance(descr3.get_ofs_length(True), Symbolic)
- assert isinstance(descr4.get_ofs_length(True), Symbolic)
- assert isinstance(descr5.get_ofs_length(True), Symbolic)
- assert isinstance(descr1.get_item_size(True), Symbolic)
- assert isinstance(descr2.get_item_size(True), Symbolic)
- assert isinstance(descr3.get_item_size(True), Symbolic)
- assert isinstance(descr4.get_item_size(True), Symbolic)
- assert isinstance(descr5.get_item_size(True), Symbolic)
CA = rffi.CArray(lltype.Signed)
descr = get_array_descr(c0, CA)
- assert not descr.is_array_of_floats()
- assert descr.get_base_size(False) == 0
- assert descr.get_ofs_length(False) == -1
+ assert descr.flag == FLAG_SIGNED
+ assert descr.basesize == 0
+ assert descr.lendescr is None
CA = rffi.CArray(lltype.Ptr(lltype.GcStruct('S')))
descr = get_array_descr(c0, CA)
- assert descr.is_array_of_pointers()
- assert descr.get_base_size(False) == 0
- assert descr.get_ofs_length(False) == -1
+ assert descr.flag == FLAG_POINTER
+ assert descr.basesize == 0
+ assert descr.lendescr is None
CA = rffi.CArray(lltype.Ptr(lltype.Struct('S')))
descr = get_array_descr(c0, CA)
- assert descr.get_base_size(False) == 0
- assert descr.get_ofs_length(False) == -1
+ assert descr.flag == FLAG_UNSIGNED
+ assert descr.basesize == 0
+ assert descr.lendescr is None
CA = rffi.CArray(lltype.Float)
descr = get_array_descr(c0, CA)
- assert descr.is_array_of_floats()
- assert descr.get_base_size(False) == 0
- assert descr.get_ofs_length(False) == -1
+ assert descr.flag == FLAG_FLOAT
+ assert descr.basesize == 0
+ assert descr.lendescr is None
CA = rffi.CArray(rffi.FLOAT)
descr = get_array_descr(c0, CA)
- assert not descr.is_array_of_floats()
- assert descr.get_base_size(False) == 0
- assert descr.get_ofs_length(False) == -1
+ assert descr.flag == FLAG_UNSIGNED
+ assert descr.basesize == 0
+ assert descr.itemsize == rffi.sizeof(lltype.SingleFloat)
+ assert descr.lendescr is None
def test_get_array_descr_sign():
@@ -257,13 +203,15 @@
for tsc in [False, True]:
c2 = GcCache(tsc)
arraydescr = get_array_descr(c2, A)
- assert arraydescr.is_item_signed() == signed
+ assert arraydescr.flag == {False: FLAG_UNSIGNED,
+ True: FLAG_SIGNED }[signed]
#
RA = rffi.CArray(RESTYPE)
for tsc in [False, True]:
c2 = GcCache(tsc)
arraydescr = get_array_descr(c2, RA)
- assert arraydescr.is_item_signed() == signed
+ assert arraydescr.flag == {False: FLAG_UNSIGNED,
+ True: FLAG_SIGNED }[signed]
def test_get_call_descr_not_translated():
@@ -369,17 +317,18 @@
#
descr2 = get_field_descr(c0, S, 'y')
o, _ = symbolic.get_field_token(S, 'y', False)
- assert descr2.repr_of_descr() == '<GcPtrFieldDescr S.y %d>' % o
+ assert descr2.repr_of_descr() == '<FieldP S.y %d>' % o
#
descr2i = get_field_descr(c0, S, 'x')
o, _ = symbolic.get_field_token(S, 'x', False)
- assert descr2i.repr_of_descr() == '<CharFieldDescr S.x %d>' % o
+ assert descr2i.repr_of_descr() == '<FieldU S.x %d>' % o
#
descr3 = get_array_descr(c0, lltype.GcArray(lltype.Ptr(S)))
- assert descr3.repr_of_descr() == '<GcPtrArrayDescr>'
+ o = symbolic.get_size(lltype.Ptr(S), False)
+ assert descr3.repr_of_descr() == '<ArrayP %d>' % o
#
descr3i = get_array_descr(c0, lltype.GcArray(lltype.Char))
- assert descr3i.repr_of_descr() == '<CharArrayDescr>'
+ assert descr3i.repr_of_descr() == '<ArrayU 1>'
#
descr4 = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Ptr(S))
assert 'GcPtrCallDescr' in descr4.repr_of_descr()
@@ -453,7 +402,7 @@
c0 = GcCache(True)
A1 = lltype.GcArray(lltype.Signed)
fielddescr = get_field_arraylen_descr(c0, A1)
- assert isinstance(fielddescr, BaseFieldDescr)
+ assert isinstance(fielddescr, FieldDescr)
ofs = fielddescr.offset
assert repr(ofs) == '< ArrayLengthOffset <GcArray of Signed > >'
#
diff --git a/pypy/jit/backend/llsupport/test/test_rewrite.py b/pypy/jit/backend/llsupport/test/test_rewrite.py
--- a/pypy/jit/backend/llsupport/test/test_rewrite.py
+++ b/pypy/jit/backend/llsupport/test/test_rewrite.py
@@ -127,7 +127,7 @@
jump()
""", """
[i1]
- p0 = call_malloc_gc(ConstClass(malloc_varsize), \
+ p0 = call_malloc_gc(ConstClass(malloc_array), \
%(adescr.get_base_size(False))d, \
i1, \
%(adescr.get_item_size(False))d)
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -142,59 +142,6 @@
def repr_of_descr(self):
return '%r' % (self,)
- def get_arg_types(self):
- """ Implement in call descr.
- Must return a string of INT, REF and FLOAT ('i', 'r', 'f').
- """
- raise NotImplementedError
-
- def get_return_type(self):
- """ Implement in call descr.
- Must return INT, REF, FLOAT, or 'v' for void.
- On 32-bit (hack) it can also be 'L' for longlongs.
- Additionally it can be 'S' for singlefloats.
- """
- raise NotImplementedError
-
- def get_extra_info(self):
- """ Implement in call descr
- """
- raise NotImplementedError
-
- def is_array_of_pointers(self):
- """ Implement for array descr
- """
- raise NotImplementedError
-
- def is_array_of_floats(self):
- """ Implement for array descr
- """
- raise NotImplementedError
-
- def is_array_of_structs(self):
- """ Implement for array descr
- """
- raise NotImplementedError
-
- def is_pointer_field(self):
- """ Implement for field descr
- """
- raise NotImplementedError
-
- def is_float_field(self):
- """ Implement for field descr
- """
- raise NotImplementedError
-
- def as_vtable_size_descr(self):
- """ Implement for size descr representing objects with vtables.
- Returns self. (it's an annotation hack)
- """
- raise NotImplementedError
-
- def count_fields_if_immutable(self):
- return -1
-
def _clone_if_mutable(self):
return self
def clone_if_mutable(self):
More information about the pypy-commit
mailing list