Use custom tuple allocation function.

Author: fangerer

graalpython/com.oracle.graal.python.cext/include/tupleobject.h

@@ -30,7 +30,7 @@ returned item's reference count.
 typedef struct {
     PyObject_VAR_HEAD
     // Truffle change: PyObject *ob_item[1] doesn't work for us in Sulong
-    PyObject *ob_item[];
+    PyObject **ob_item;
 
     /* ob_item contains space for 'ob_size' elements.
      * Items must normally not be NULL, except during construction when

graalpython/com.oracle.graal.python.cext/src/capi.c

@@ -85,10 +85,14 @@ void initialize_type_structure(PyTypeObject* structure, PyTypeObject* ptype, pol
 
     unsigned long original_flags = structure->tp_flags;
     Py_ssize_t basicsize = structure->tp_basicsize;
+    allocfunc alloc = structure->tp_alloc;
     PyTypeObject* type_handle = truffle_assign_managed(structure, ptype);
     // write flags as specified in the dummy to the PythonClass object
     type_handle->tp_flags = original_flags | Py_TPFLAGS_READY;
     type_handle->tp_basicsize = basicsize;
+    if (alloc) {
+    	type_handle->tp_alloc = alloc;
+    }
 }
 
 static void initialize_builtin_type(PyTypeObject* structure, const char* typname, polyglot_typeid tid) {

graalpython/com.oracle.graal.python.cext/src/capi.h

@@ -263,7 +263,7 @@ void* wrap_unsupported(void *fun, ...);
            wrap_direct :                                                                 \
            wrap_unsupported))))))))
 
-#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__) {\
+#define PY_TRUFFLE_TYPE_WITH_ALLOC(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__, __ALLOC__) {\
     PyVarObject_HEAD_INIT((__SUPER_TYPE__), 0)\
     __TYPE_NAME__,                              /* tp_name */\
     (__SIZE__),                                 /* tp_basicsize */\
@@ -300,12 +300,14 @@ void* wrap_unsupported(void *fun, ...);
     0,                                          /* tp_descr_set */\
     0,                                          /* tp_dictoffset */\
     0,                                          /* tp_init */\
-    0,                                          /* tp_alloc */\
+    (__ALLOC__),                                /* tp_alloc */\
     0,                                          /* tp_new */\
     0,                                          /* tp_free */\
     0,                                          /* tp_is_gc */\
 }
 
+#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__) PY_TRUFFLE_TYPE_WITH_ALLOC(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__, 0)
+
 /** to be used from Java code only; returns a type's basic size */
 #define BASICSIZE_GETTER(__typename__)extern Py_ssize_t get_ ## __typename__ ## _basicsize() { \
 	return sizeof(__typename__); \

graalpython/com.oracle.graal.python.cext/src/structseq.c

@@ -77,7 +77,7 @@ int PyStructSequence_InitType2(PyTypeObject *type, PyStructSequence_Desc *desc)
     type->tp_members = NULL;
     type->tp_new = newType->tp_new;
     type->tp_base = &PyTuple_Type;
-    type->tp_alloc = PyType_GenericAlloc;
+    type->tp_alloc = newType->tp_alloc;
 
     // now copy specific fields
     type->tp_name = newType->tp_name;

graalpython/com.oracle.graal.python.cext/src/tupleobject.c

@@ -40,7 +40,11 @@
  */
 #include "capi.h"
 
-PyTypeObject PyTuple_Type = PY_TRUFFLE_TYPE("tuple", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, sizeof(PyTupleObject) - sizeof(PyObject *));
+/* prototype */
+PyObject* PyTruffle_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems);
+
+/* tuple type */
+PyTypeObject PyTuple_Type = PY_TRUFFLE_TYPE_WITH_ALLOC("tuple", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TUPLE_SUBCLASS, sizeof(PyTupleObject) - sizeof(PyObject *), PyTruffle_Tuple_Alloc);
 
 /* Tuples */
 UPCALL_ID(PyTuple_New);
@@ -106,6 +110,7 @@ PyObject * tuple_subtype_new(PyTypeObject *type, PyObject *iterable) {
     if (newobj == NULL) {
         return NULL;
     }
+    newobj->ob_item = (PyObject **) ((char *)newobj + offsetof(PyTupleObject, ob_item) + sizeof(PyObject **));
     newobj = polyglot_from_PyTupleObject(newobj);
     for (i = 0; i < n; i++) {
         item = PyTuple_GetItem(tmp, i);
@@ -124,3 +129,24 @@ int PyTruffle_Tuple_SetItem(PyObject* tuple, Py_ssize_t position, PyObject* item
     PyTuple_SET_ITEM(tuple, position, item);
     return 0;
 }
+
+PyObject* PyTruffle_Tuple_Alloc(PyTypeObject* cls, Py_ssize_t nitems) {
+	/*
+	 * TODO(fa): For 'PyVarObjects' (i.e. 'nitems > 0') we increase the size by 'sizeof(void *)'
+	 * because this additional pointer can then be used as pointer to the element array.
+	 * CPython usually embeds the array in the struct but Sulong doesn't currently support that.
+	 * So we allocate space for the additional array pointer.
+	 * Also consider any 'PyVarObject' (in particular 'PyTupleObject') if this is fixed.
+	 */
+	Py_ssize_t size = cls->tp_basicsize + cls->tp_itemsize * nitems + sizeof(PyObject **);
+    PyObject* newObj = (PyObject*)PyObject_Malloc(size);
+    if(cls->tp_dictoffset) {
+    	*((PyObject **) ((char *)newObj + cls->tp_dictoffset)) = NULL;
+    }
+    Py_TYPE(newObj) = cls;
+    if (nitems > 0) {
+        ((PyVarObject*)newObj)->ob_size = nitems;
+    }
+    return newObj;
+}
+

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/DynamicObjectNativeWrapper.java

@@ -51,7 +51,6 @@
 import static com.oracle.graal.python.builtins.objects.cext.NativeMemberNames.TP_SUBCLASSES;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__BASICSIZE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__DICTOFFSET__;
-import static com.oracle.graal.python.nodes.SpecialAttributeNames.__DICT__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__ITEMSIZE__;
 import static com.oracle.graal.python.nodes.SpecialAttributeNames.__WEAKLISTOFFSET__;
 import static com.oracle.graal.python.nodes.SpecialMethodNames.RICHCMP;
@@ -79,6 +78,7 @@
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.IsPointerNode;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.PCallCapiFunction;
 import com.oracle.graal.python.builtins.objects.cext.CExtNodes.SetSpecialSingletonPtrNode;
+import com.oracle.graal.python.builtins.objects.cext.CExtNodes.ToJavaNode;
 import com.oracle.graal.python.builtins.objects.cext.DynamicObjectNativeWrapperFactory.ReadTypeNativeMemberNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.UnicodeObjectNodes.UnicodeAsWideCharNode;
 import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage;
@@ -894,6 +894,19 @@ long doTpBasicsize(PythonAbstractClass object, @SuppressWarnings("unused") Strin
             return basicsize;
         }
 
+        @Specialization(guards = "eq(TP_ALLOC, key)")
+        Object doTpAlloc(PythonAbstractClass object, @SuppressWarnings("unused") String key, Object allocFunc,
+                        @Cached WriteAttributeToObjectNode writeAttrNode,
+                        @Cached IsBuiltinClassProfile profile,
+                        @Cached CExtNodes.AsPythonObjectNode asPythonObjectNode) {
+            if (profile.profileClass(object, PythonBuiltinClassType.PythonClass)) {
+                writeAttrNode.execute(object, TypeBuiltins.TYPE_ALLOC, asPythonObjectNode.execute(allocFunc));
+            } else {
+                writeAttrNode.execute(object, SpecialMethodNames.__ALLOC__, asPythonObjectNode.execute(allocFunc));
+            }
+            return allocFunc;
+        }
+
         @Specialization(guards = "eq(TP_SUBCLASSES, key)")
         @TruffleBoundary
         Object doTpSubclasses(PythonClass object, @SuppressWarnings("unused") String key, DynamicObjectNativeWrapper.PythonObjectNativeWrapper value) {