[pypy-svn] r68091 - in pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport: . test

arigo at codespeak.net arigo at codespeak.net
Thu Oct 1 11:58:32 CEST 2009


Author: arigo
Date: Thu Oct  1 11:58:31 2009
New Revision: 68091

Modified:
   pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/descr.py
   pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/test/test_descr.py
Log:
Implement floats in descr.py properly.


Modified: pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/descr.py
==============================================================================
--- pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/descr.py	(original)
+++ pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/descr.py	Thu Oct  1 11:58:31 2009
@@ -1,8 +1,7 @@
 from pypy.rpython.lltypesystem import lltype
 from pypy.jit.backend.llsupport import symbolic
-from pypy.jit.metainterp.history import AbstractDescr, getkind, BoxInt, BoxPtr,\
-     BoxFloat
-from pypy.jit.metainterp.history import BasicFailDescr
+from pypy.jit.metainterp.history import AbstractDescr, getkind, BoxInt, BoxPtr
+from pypy.jit.metainterp.history import BasicFailDescr, BoxFloat
 from pypy.jit.metainterp.resoperation import ResOperation, rop
 
 # The point of the class organization in this file is to make instances
@@ -71,6 +70,9 @@
     def is_pointer_field(self):
         return False        # unless overridden by GcPtrFieldDescr
 
+    def is_float_field(self):
+        return False        # unless overridden by FloatFieldDescr
+
     def repr_of_descr(self):
         return '<%s %s>' % (self._clsname, self.offset)
 
@@ -87,7 +89,8 @@
 
 def getFieldDescrClass(TYPE):
     return getDescrClass(TYPE, BaseFieldDescr, GcPtrFieldDescr,
-                         NonGcPtrFieldDescr, 'Field', 'get_field_size')
+                         NonGcPtrFieldDescr, 'Field', 'get_field_size',
+                         'is_float_field')
 
 def get_field_descr(gccache, STRUCT, fieldname):
     cache = gccache._cache_field
@@ -126,6 +129,9 @@
     def is_array_of_pointers(self):
         return False        # unless overridden by GcPtrArrayDescr
 
+    def is_array_of_floats(self):
+        return False        # unless overridden by FloatArrayDescr
+
     def repr_of_descr(self):
         return '<%s>' % self._clsname
 
@@ -142,7 +148,8 @@
 
 def getArrayDescrClass(ARRAY):
     return getDescrClass(ARRAY.OF, BaseArrayDescr, GcPtrArrayDescr,
-                         NonGcPtrArrayDescr, 'Array', 'get_item_size')
+                         NonGcPtrArrayDescr, 'Array', 'get_item_size',
+                         'is_array_of_floats')
 
 def get_array_descr(gccache, ARRAY):
     cache = gccache._cache_array
@@ -175,15 +182,18 @@
     def instantiate_arg_classes(self):
         result = []
         for c in self.arg_classes:
-            if c == 'i': box = BoxInt()
+            if   c == 'i': box = BoxInt()
             elif c == 'f': box = BoxFloat()
-            else:        box = BoxPtr()
+            else:          box = BoxPtr()
             result.append(box)
         return result
 
     def returns_a_pointer(self):
         return False         # unless overridden by GcPtrCallDescr
 
+    def returns_a_float(self):
+        return False         # unless overridden by FloatCallDescr
+
     def get_result_size(self, translate_support_code):
         raise NotImplementedError
 
@@ -191,14 +201,13 @@
         if self.executable_token is not None:
             return self.executable_token
         args = [BoxInt()] + self.instantiate_arg_classes()
-        res_size = self.get_result_size(cpu.translate_support_code)
-        if res_size == 0:
+        if self.get_result_size(cpu.translate_support_code) == 0:
             result = None
             result_list = []
         else:
             if self.returns_a_pointer():
                 result = BoxPtr()
-            elif res_size == 8:
+            elif self.returns_a_float():
                 result = BoxFloat()
             else:
                 result = BoxInt()
@@ -237,7 +246,8 @@
     if RESULT is lltype.Void:
         return VoidCallDescr
     return getDescrClass(RESULT, BaseCallDescr, GcPtrCallDescr,
-                         NonGcPtrCallDescr, 'Call', 'get_result_size')
+                         NonGcPtrCallDescr, 'Call', 'get_result_size',
+                         'returns_a_float')
 
 def get_call_descr(gccache, ARGS, RESULT):
     arg_classes = []
@@ -263,7 +273,7 @@
 # ____________________________________________________________
 
 def getDescrClass(TYPE, BaseDescr, GcPtrDescr, NonGcPtrDescr,
-                  nameprefix, methodname, _cache={}):
+                  nameprefix, methodname, floatcheckname, _cache={}):
     if isinstance(TYPE, lltype.Ptr):
         if TYPE.TO._gckind == 'gc':
             return GcPtrDescr
@@ -281,5 +291,10 @@
             return symbolic.get_size(TYPE, translate_support_code)
         setattr(Descr, methodname, method)
         #
+        if TYPE is lltype.Float:
+            def is_float(self):
+                return True
+            setattr(Descr, floatcheckname, is_float)
+        #
         _cache[nameprefix, TYPE] = Descr
         return Descr

Modified: pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/test/test_descr.py
==============================================================================
--- pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/test/test_descr.py	(original)
+++ pypy/branch/floats-via-sse2/pypy/jit/backend/llsupport/test/test_descr.py	Thu Oct  1 11:58:31 2009
@@ -26,12 +26,16 @@
     T = lltype.GcStruct('T')
     S = lltype.GcStruct('S', ('x', lltype.Char),
                              ('y', lltype.Ptr(T)),
-                             ('z', lltype.Ptr(U)))
+                             ('z', lltype.Ptr(U)),
+                             ('f', lltype.Float))
     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)
     #
     c0 = GcCache(False)
     c1 = GcCache(True)
@@ -42,25 +46,35 @@
         descr_x = get_field_descr(c2, S, 'x')
         descr_y = get_field_descr(c2, S, 'y')
         descr_z = get_field_descr(c2, S, 'z')
+        descr_f = get_field_descr(c2, S, 'f')
         assert descr_x.__class__ is cls
         assert descr_y.__class__ is GcPtrFieldDescr
         assert descr_z.__class__ is NonGcPtrFieldDescr
+        assert descr_f.__class__ is clsf
         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)
         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_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 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_x.is_float_field()
+        assert not descr_y.is_float_field()
+        assert not descr_z.is_float_field()
+        assert     descr_f.is_float_field()
 
 
 def test_get_array_descr():
@@ -69,71 +83,102 @@
     A1 = lltype.GcArray(lltype.Char)
     A2 = lltype.GcArray(lltype.Ptr(T))
     A3 = lltype.GcArray(lltype.Ptr(U))
+    A4 = lltype.GcArray(lltype.Float)
     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))
     #
     c0 = GcCache(False)
     descr1 = get_array_descr(c0, A1)
     descr2 = get_array_descr(c0, A2)
     descr3 = get_array_descr(c0, A3)
+    descr4 = get_array_descr(c0, A4)
     assert descr1.__class__ is cls
     assert descr2.__class__ is GcPtrArrayDescr
     assert descr3.__class__ is NonGcPtrArrayDescr
+    assert descr4.__class__ is clsf
     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 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()
     #
     WORD = rffi.sizeof(lltype.Signed)
     assert descr1.get_base_size(False) == WORD
     assert descr2.get_base_size(False) == WORD
     assert descr3.get_base_size(False) == WORD
+    assert descr4.get_base_size(False) == WORD
     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 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 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(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(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)
 
 
-def test_get_call_descr():
+def test_get_call_descr_not_translated():
     c0 = GcCache(False)
     descr1 = get_call_descr(c0, [lltype.Char, lltype.Signed], lltype.Char)
     assert descr1.get_result_size(False) == rffi.sizeof(lltype.Char)
     assert not descr1.returns_a_pointer()
+    assert not descr1.returns_a_float()
     assert descr1.arg_classes == "ii"
     #
     T = lltype.GcStruct('T')
     descr2 = get_call_descr(c0, [lltype.Ptr(T)], lltype.Ptr(T))
     assert descr2.get_result_size(False) == rffi.sizeof(lltype.Ptr(T))
     assert descr2.returns_a_pointer()
+    assert not descr2.returns_a_float()
     assert descr2.arg_classes == "r"
     #
     U = lltype.GcStruct('U', ('x', lltype.Signed))
     assert descr2 == get_call_descr(c0, [lltype.Ptr(U)], lltype.Ptr(U))
     #
+    descr4 = get_call_descr(c0, [lltype.Float, lltype.Float], lltype.Float)
+    assert descr4.get_result_size(False) == rffi.sizeof(lltype.Float)
+    assert not descr4.returns_a_pointer()
+    assert descr4.returns_a_float()
+    assert descr4.arg_classes == "ff"
+
+def test_get_call_descr_translated():
     c1 = GcCache(True)
+    T = lltype.GcStruct('T')
+    U = lltype.GcStruct('U', ('x', lltype.Signed))
     descr3 = get_call_descr(c1, [lltype.Ptr(T)], lltype.Ptr(U))
     assert isinstance(descr3.get_result_size(True), Symbolic)
     assert descr3.returns_a_pointer()
+    assert not descr3.returns_a_float()
     assert descr3.arg_classes == "r"
     #
-    c1 = GcCache(True)
     descr4 = get_call_descr(c1, [lltype.Float, lltype.Float], lltype.Float)
-    assert descr4.get_result_size(False) == rffi.sizeof(lltype.Float)
+    assert isinstance(descr4.get_result_size(True), Symbolic)
+    assert not descr4.returns_a_pointer()
+    assert descr4.returns_a_float()
+    assert descr4.arg_classes == "ff"
 
 def test_repr_of_descr():
     c0 = GcCache(False)
@@ -165,3 +210,6 @@
     #
     descr4i = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Char)
     assert 'CharCallDescr' in descr4i.repr_of_descr()
+    #
+    descr4f = get_call_descr(c0, [lltype.Char, lltype.Ptr(S)], lltype.Float)
+    assert 'FloatCallDescr' in descr4f.repr_of_descr()



More information about the Pypy-commit mailing list