Enable allocation of objects if class inherits from a native class.

fangerer · fangerer · commit f151a66c09a1 · 2018-06-08T15:53:05.000+02:00
diff --git a/graalpython/com.oracle.graal.python.cext/src/boolobject.c b/graalpython/com.oracle.graal.python.cext/src/boolobject.c
@@ -40,7 +40,7 @@
 
 #include <stdarg.h>
 
-PyTypeObject PyBool_Type = PY_TRUFFLE_TYPE("bool", &PyType_Type, Py_TPFLAGS_DEFAULT);
+PyTypeObject PyBool_Type = PY_TRUFFLE_TYPE("bool", &PyType_Type, Py_TPFLAGS_DEFAULT, sizeof(struct _longobject));
 
 // taken from CPython "Python/Objects/boolobject.c"
 PyObject *PyBool_FromLong(long ok) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c b/graalpython/com.oracle.graal.python.cext/src/bytearrayobject.c
@@ -38,5 +38,5 @@
  */
 #include "capi.h"
 
-PyTypeObject PyByteArray_Type = PY_TRUFFLE_TYPE("bytearray", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE);
+PyTypeObject PyByteArray_Type = PY_TRUFFLE_TYPE("bytearray", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, sizeof(PyByteArrayObject));
 char _PyByteArray_empty_string[] = "";
diff --git a/graalpython/com.oracle.graal.python.cext/src/bytesobject.c b/graalpython/com.oracle.graal.python.cext/src/bytesobject.c
@@ -39,8 +39,12 @@
 #include "capi.h"
 
 #include <stdarg.h>
+#include <stddef.h>
 
-PyTypeObject PyBytes_Type = PY_TRUFFLE_TYPE("bytes", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_BYTES_SUBCLASS);
+// taken from CPython "Objects/bytesobject.c"
+#define PyBytesObject_SIZE (offsetof(PyBytesObject, ob_sval) + 1)
+
+PyTypeObject PyBytes_Type = PY_TRUFFLE_TYPE("bytes", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_BYTES_SUBCLASS, PyBytesObject_SIZE);
 
 PyObject* PyBytes_FromStringAndSize(const char* str, Py_ssize_t sz) {
     setlocale(LC_ALL, NULL);
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.c b/graalpython/com.oracle.graal.python.cext/src/capi.c
@@ -48,9 +48,11 @@ static void initialize_type_structure(PyTypeObject* structure, const char* typna
     truffle_invoke(PY_TRUFFLE_CEXT, "PyTruffle_Set_Ptr", ptype, nativePointer);
 
     unsigned long original_flags = structure->tp_flags;
+    Py_ssize_t basicsize = structure->tp_basicsize;
     PyTypeObject* type_handle = truffle_assign_managed(structure, polyglot_as__typeobject(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;
 }
 
 static void initialize_globals() {
@@ -170,7 +172,7 @@ static inline PyObject* PyTruffle_Explicit_Cast(PyObject* cobj, unsigned long fl
 
 
 __attribute__((always_inline))
-static inline PyObject* _explicit_cast(PyObject* cobj) {
+inline PyObject* explicit_cast(PyObject* cobj) {
     if(polyglot_is_value(cobj)) {
         unsigned long flags = polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "PyTruffle_GetTpFlags", cobj));
         return PyTruffle_Explicit_Cast(cobj, flags);
@@ -179,7 +181,7 @@ static inline PyObject* _explicit_cast(PyObject* cobj) {
 }
 
 PyObject* to_sulong(void *o) {
-    return _explicit_cast(truffle_invoke(PY_TRUFFLE_CEXT, "to_sulong", o));
+    return explicit_cast(truffle_invoke(PY_TRUFFLE_CEXT, "to_sulong", o));
 }
 
 void* get_ob_type(PyObject* obj) {
@@ -443,7 +445,7 @@ typedef PyObject* (*f20)(PyObject*, PyObject*, PyObject*, PyObject*, PyObject*,
 
 #define _PICK_FUN_CAST(DUMMY, _0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, NAME, ...) NAME
 #define _CALL_ARITY(FUN, ...) ( (_PICK_FUN_CAST(NULL, ##__VA_ARGS__, f20, f19, f18, f17, f16, f15, f14, f13, f12, f11, f10, f9, f8, f7, f6, f5, f4, f3, f2, f1, f0))(FUN))(__VA_ARGS__)
-#define ARG(__n) _explicit_cast((PyObject*)polyglot_get_arg((__n)))
+#define ARG(__n) explicit_cast((PyObject*)polyglot_get_arg((__n)))
 
 PyObject *wrap_direct(PyCFunction fun, ...) {
 	PyObject *res = NULL;
@@ -496,23 +498,23 @@ PyObject *wrap_direct(PyCFunction fun, ...) {
 }
 
 PyObject *wrap_varargs(PyCFunction fun, PyObject *module, PyObject *varargs) {
-	return fun(_explicit_cast(module), _explicit_cast(varargs));
+	return fun(explicit_cast(module), explicit_cast(varargs));
 }
 
 PyObject *wrap_keywords(PyCFunctionWithKeywords fun, PyObject *module, PyObject *varargs, PyObject *kwargs) {
-	return fun(_explicit_cast(module), _explicit_cast(varargs), _explicit_cast(kwargs));
+	return fun(explicit_cast(module), explicit_cast(varargs), explicit_cast(kwargs));
 }
 
 PyObject *wrap_noargs(PyCFunction fun, PyObject *module, PyObject *pnone) {
-	return fun(_explicit_cast(module), _explicit_cast(pnone));
+	return fun(explicit_cast(module), explicit_cast(pnone));
 }
 
 PyObject *wrap_fastcall(_PyCFunctionFast fun, PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) {
 	Py_ssize_t i;
     for (i=0; i < nargs; i++) {
-    	args[i] = _explicit_cast(args[i]);
+    	args[i] = explicit_cast(args[i]);
     }
-	return fun(_explicit_cast(self), args, nargs, _explicit_cast(kwnames));
+	return fun(explicit_cast(self), args, nargs, explicit_cast(kwnames));
 }
 
 PyObject *wrap_unsupported(void *fun, ...) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/capi.h b/graalpython/com.oracle.graal.python.cext/src/capi.h
@@ -83,6 +83,7 @@ POLYGLOT_DECLARE_TYPE(PySetObject);
 extern void* to_java(PyObject* obj);
 extern void* to_java_type(PyTypeObject* cls);
 extern PyObject* to_sulong(void *o);
+extern PyObject* explicit_cast(PyObject* cobj);
 #define as_char_pointer(obj) polyglot_invoke(PY_TRUFFLE_CEXT, "to_char_pointer", to_java(obj))
 #define as_long(obj) ((long)polyglot_as_i64(polyglot_invoke(PY_TRUFFLE_CEXT, "to_long", to_java(obj))))
 #define as_int(obj) ((int)as_long(obj))
@@ -146,10 +147,10 @@ PyObject *wrap_unsupported(void *fun, ...);
           wrap_unsupported)))))))
 
 
-#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__) {\
+#define PY_TRUFFLE_TYPE(__TYPE_NAME__, __SUPER_TYPE__, __FLAGS__, __SIZE__) {\
     PyVarObject_HEAD_INIT((__SUPER_TYPE__), 0)\
     __TYPE_NAME__,                              /* tp_name */\
-    0,                                          /* tp_basicsize */\
+    (__SIZE__),                                 /* tp_basicsize */\
     0,                                          /* tp_itemsize */\
     0,                                          /* tp_dealloc */\
     0,                                          /* tp_print */\
diff --git a/graalpython/com.oracle.graal.python.cext/src/capsule.c b/graalpython/com.oracle.graal.python.cext/src/capsule.c
@@ -38,7 +38,7 @@
  */
 #include "capi.h"
 
-PyTypeObject PyCapsule_Type = PY_TRUFFLE_TYPE("PyCapsule", &PyType_Type, 0);
+PyTypeObject PyCapsule_Type = PY_TRUFFLE_TYPE("PyCapsule", &PyType_Type, 0, sizeof(PyCapsule));
 
 PyObject* PyCapsule_New(void *pointer, const char *name, PyCapsule_Destructor destructor) {
     return (PyObject *)polyglot_as_PyCapsule(to_sulong(polyglot_invoke(PY_TRUFFLE_CEXT, "PyCapsule", name ? polyglot_from_string(name, "ascii") : to_java(Py_None), pointer, destructor)));
diff --git a/graalpython/com.oracle.graal.python.cext/src/complexobject.c b/graalpython/com.oracle.graal.python.cext/src/complexobject.c
@@ -38,4 +38,4 @@
  */
 #include "capi.h"
 
-PyTypeObject PyComplex_Type = PY_TRUFFLE_TYPE("complex", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC);
+PyTypeObject PyComplex_Type = PY_TRUFFLE_TYPE("complex", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PyComplexObject));
diff --git a/graalpython/com.oracle.graal.python.cext/src/descrobject.c b/graalpython/com.oracle.graal.python.cext/src/descrobject.c
@@ -38,7 +38,13 @@
  */
 #include "capi.h"
 
-PyTypeObject PyDictProxy_Type = PY_TRUFFLE_TYPE("mappingproxy", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC);
+// taken from CPython "Objects/descrobject.c"
+typedef struct {
+    PyObject_HEAD
+    PyObject *mapping;
+} mappingproxyobject;
+
+PyTypeObject PyDictProxy_Type = PY_TRUFFLE_TYPE("mappingproxy", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(mappingproxyobject));
 
 /* Dicts */
 PyObject* PyDictProxy_New(PyObject *mapping) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/dictobject.c b/graalpython/com.oracle.graal.python.cext/src/dictobject.c
@@ -40,7 +40,7 @@
 
 /* Dicts */
 
-PyTypeObject PyDict_Type = PY_TRUFFLE_TYPE("dict", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DICT_SUBCLASS);
+PyTypeObject PyDict_Type = PY_TRUFFLE_TYPE("dict", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DICT_SUBCLASS, sizeof(PyDictObject));
 
 PyObject* PyDict_New(void) {
     return to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "PyDict_New"));
diff --git a/graalpython/com.oracle.graal.python.cext/src/floatobject.c b/graalpython/com.oracle.graal.python.cext/src/floatobject.c
@@ -39,7 +39,7 @@
 #include "capi.h"
 
 
-PyTypeObject PyFloat_Type = PY_TRUFFLE_TYPE("float", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE);
+PyTypeObject PyFloat_Type = PY_TRUFFLE_TYPE("float", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, sizeof(PyFloatObject));
 
 double PyFloat_AsDouble(PyObject *op) {
     if (op == NULL) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/functionobject.c b/graalpython/com.oracle.graal.python.cext/src/functionobject.c
@@ -40,4 +40,4 @@
 
 typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
 
-PyTypeObject PyCFunction_Type = PY_TRUFFLE_TYPE("builtin_function_or_method", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC);
+PyTypeObject PyCFunction_Type = PY_TRUFFLE_TYPE("builtin_function_or_method", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PyCFunctionObject));
diff --git a/graalpython/com.oracle.graal.python.cext/src/listobject.c b/graalpython/com.oracle.graal.python.cext/src/listobject.c
@@ -38,8 +38,7 @@
  */
 #include "capi.h"
 
-
-PyTypeObject PyList_Type = PY_TRUFFLE_TYPE("list", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LIST_SUBCLASS);
+PyTypeObject PyList_Type = PY_TRUFFLE_TYPE("list", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LIST_SUBCLASS, sizeof(PyListObject));
 
 PyObject* PyList_New(Py_ssize_t size) {
     PyObject* result = truffle_invoke(PY_TRUFFLE_CEXT, "PyList_New", size);
diff --git a/graalpython/com.oracle.graal.python.cext/src/longobject.c b/graalpython/com.oracle.graal.python.cext/src/longobject.c
@@ -39,8 +39,9 @@
 #include "capi.h"
 
 #include <stdbool.h>
+#include <stddef.h>
 
-PyTypeObject PyLong_Type = PY_TRUFFLE_TYPE("int", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS);
+PyTypeObject PyLong_Type = PY_TRUFFLE_TYPE("int", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_LONG_SUBCLASS, offsetof(PyLongObject, ob_digit));
 
 long PyLong_AsLong(PyObject *obj) {
     return truffle_invoke_l(PY_TRUFFLE_CEXT, "PyLong_AsPrimitive", to_java(obj), true, sizeof(long), truffle_read_string("long"));
diff --git a/graalpython/com.oracle.graal.python.cext/src/memoryobject.c b/graalpython/com.oracle.graal.python.cext/src/memoryobject.c
@@ -38,4 +38,12 @@
  */
 #include "capi.h"
 
-PyTypeObject PyMemoryView_Type = PY_TRUFFLE_TYPE("memoryview", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC);
+PyTypeObject PyMemoryView_Type = PY_TRUFFLE_TYPE("memoryview", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, offsetof(PyMemoryViewObject, ob_array));
+
+PyObject* PyMemoryView_FromObject(PyObject *v) {
+
+	// TODO implement
+
+    PyErr_Format(PyExc_TypeError, "memoryview: a bytes-like object is required, not '%.200s'", Py_TYPE(v)->tp_name);
+    return NULL;
+}
diff --git a/graalpython/com.oracle.graal.python.cext/src/moduleobject.c b/graalpython/com.oracle.graal.python.cext/src/moduleobject.c
@@ -38,7 +38,7 @@
  */
 #include "capi.h"
 
-PyTypeObject PyModule_Type = PY_TRUFFLE_TYPE("module", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE);
+PyTypeObject PyModule_Type = PY_TRUFFLE_TYPE("module", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, sizeof(PyModuleObject));
 
 /* Modules */
 int PyModule_AddFunctions(PyObject* mod, PyMethodDef* methods) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/object.c b/graalpython/com.oracle.graal.python.cext/src/object.c
@@ -122,14 +122,14 @@ static PyNumberMethods none_as_number = {
     0,                          /* nb_index */
 };
 
-PyTypeObject _PyNone_Type = PY_TRUFFLE_TYPE("NoneType", &PyType_Type, Py_TPFLAGS_DEFAULT);
+PyTypeObject _PyNone_Type = PY_TRUFFLE_TYPE("NoneType", &PyType_Type, Py_TPFLAGS_DEFAULT, 0);
 
 PyObject _Py_NoneStruct = {
   _PyObject_EXTRA_INIT
   1, &_PyNone_Type
 };
 
-PyTypeObject _PyNotImplemented_Type = PY_TRUFFLE_TYPE("NotImplementedType", &PyType_Type, Py_TPFLAGS_DEFAULT);
+PyTypeObject _PyNotImplemented_Type = PY_TRUFFLE_TYPE("NotImplementedType", &PyType_Type, Py_TPFLAGS_DEFAULT, 0);
 
 PyObject _Py_NotImplementedStruct = {
     _PyObject_EXTRA_INIT
@@ -171,18 +171,39 @@ static int add_subclass(PyTypeObject *base, PyTypeObject *type) {
 	return 0;
 }
 
+/* Special C landing functions that convert some arguments to primitives. */
+
+static PyObject* wrap_allocfunc(allocfunc f, PyTypeObject* klass, PyObject* n) {
+	return f(explicit_cast(klass), PyLong_AsSsize_t(n));
+}
+
+static PyObject* wrap_getattrfunc(getattrfunc f, PyObject* obj, PyObject* unicode) {
+	// we really need to provide 'char *' since this often runs non-Sulong code
+	return f(explicit_cast(obj), as_char_pointer(unicode));
+}
+
+static PyObject* wrap_setattrfunc(setattrfunc f, PyObject* obj, PyObject* unicode, PyObject* value) {
+	// we really need to provide 'char *' since this often runs non-Sulong code
+	return f(explicit_cast(obj), as_char_pointer(unicode), explicit_cast(value));
+}
+
+static PyObject* wrap_richcmpfunc(richcmpfunc f, PyObject* a, PyObject* b, PyObject* n) {
+	return f(explicit_cast(a), explicit_cast(b), (int)PyLong_AsLong(n));
+}
+
 int PyType_Ready(PyTypeObject* cls) {
 #define ADD_IF_MISSING(attr, def) if (!(attr)) { attr = def; }
-#define ADD_METHOD(m) ADD_METHOD_OR_SLOT(m.ml_name, m.ml_meth, m.ml_flags, m.ml_doc)
-#define ADD_SLOT(name, meth, flags) ADD_METHOD_OR_SLOT(name, meth, flags, name)
-#define ADD_METHOD_OR_SLOT(name, meth, flags, doc)                                          \
+#define ADD_METHOD(m) ADD_METHOD_OR_SLOT(m.ml_name, get_method_flags_cwrapper(m.ml_flags), m.ml_meth, m.ml_flags, m.ml_doc)
+#define ADD_SLOT(name, meth, flags) ADD_METHOD_OR_SLOT(name, get_method_flags_cwrapper(flags), meth, flags, name)
+#define ADD_SLOT_CONV(name, clanding, meth, flags) ADD_METHOD_OR_SLOT(name, clanding, meth, flags, name)
+#define ADD_METHOD_OR_SLOT(name, clanding, meth, flags, doc)                                \
     if (meth) {                                                                             \
         truffle_invoke(PY_TRUFFLE_CEXT,                                                     \
                        "AddFunction",                                                       \
                        javacls,                                                             \
                        truffle_read_string(name),                                           \
                        truffle_address_to_function(meth),                                   \
-                       truffle_address_to_function(get_method_flags_cwrapper(flags)),       \
+                       truffle_address_to_function(clanding),                               \
                        get_method_flags_wrapper(flags),                                     \
                        truffle_read_string(doc),                                            \
                        (flags) > 0 && ((flags) & METH_CLASS) != 0,                          \
@@ -317,22 +338,25 @@ int PyType_Ready(PyTypeObject* cls) {
     // https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_getattr
     // tp_getattr and tp_setattr are deprecated, and should be the same as
     // tp_getattro and tp_setattro
-    ADD_SLOT("__getattr__", cls->tp_getattr, -2);
-    ADD_SLOT("__setattr__", cls->tp_setattr, -3);
+
+    // NOTE: The slots may be called from managed code, i.e., we need to wrap the functions
+    // and convert arguments that should be C primitives.
+    ADD_SLOT_CONV("__getattr__", wrap_getattrfunc, cls->tp_getattr, -2);
+    ADD_SLOT_CONV("__setattr__", wrap_setattrfunc, cls->tp_setattr, -3);
     ADD_SLOT("__repr__", cls->tp_repr, -1);
     ADD_SLOT("__hash__", cls->tp_hash, -1);
     ADD_SLOT("__call__", cls->tp_call, METH_KEYWORDS | METH_VARARGS);
     ADD_SLOT("__str__", cls->tp_str, -1);
     ADD_SLOT("__getattr__", cls->tp_getattro, -2);
     ADD_SLOT("__setattr__", cls->tp_getattro, -3);
     ADD_SLOT("__clear__", cls->tp_clear, -1);
-    ADD_SLOT("__compare__", cls->tp_richcompare, -3);
+    ADD_SLOT_CONV("__compare__", wrap_richcmpfunc, cls->tp_richcompare, -3);
     ADD_SLOT("__iter__", cls->tp_iter, -1);
     ADD_SLOT("__next__", cls->tp_iternext, -1);
     ADD_SLOT("__get__", cls->tp_descr_get, -3);
     ADD_SLOT("__set__", cls->tp_descr_set, -3);
     ADD_SLOT("__init__", cls->tp_init, METH_KEYWORDS | METH_VARARGS);
-    ADD_SLOT("__alloc__", cls->tp_alloc, -2);
+    ADD_SLOT_CONV("__alloc__", wrap_allocfunc, cls->tp_alloc, -2);
     ADD_SLOT("__new__", cls->tp_new, METH_KEYWORDS | METH_VARARGS);
     ADD_SLOT("__free__", cls->tp_free, -1);
     ADD_SLOT("__del__", cls->tp_del, -1);
diff --git a/graalpython/com.oracle.graal.python.cext/src/setobject.c b/graalpython/com.oracle.graal.python.cext/src/setobject.c
@@ -38,8 +38,8 @@
  */
 #include "capi.h"
 
-PyTypeObject PySet_Type = PY_TRUFFLE_TYPE("set", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC);
-PyTypeObject PyFrozenSet_Type = PY_TRUFFLE_TYPE("frozenset", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC);
+PyTypeObject PySet_Type = PY_TRUFFLE_TYPE("set", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, sizeof(PySetObject));
+PyTypeObject PyFrozenSet_Type = PY_TRUFFLE_TYPE("frozenset", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, sizeof(PySetObject));
 
 PyObject * PySet_New(PyObject *iterable) {
 	void* result = polyglot_invoke(PY_TRUFFLE_CEXT, "PySet_New", to_java(iterable));
diff --git a/graalpython/com.oracle.graal.python.cext/src/sliceobject.c b/graalpython/com.oracle.graal.python.cext/src/sliceobject.c
@@ -38,8 +38,8 @@
  */
 #include "capi.h"
 
-PyTypeObject PyEllipsis_Type = PY_TRUFFLE_TYPE("ellipsis", &PyType_Type, Py_TPFLAGS_DEFAULT);
-PyTypeObject PySlice_Type = PY_TRUFFLE_TYPE("slice", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC);
+PyTypeObject PyEllipsis_Type = PY_TRUFFLE_TYPE("ellipsis", &PyType_Type, Py_TPFLAGS_DEFAULT, 0);
+PyTypeObject PySlice_Type = PY_TRUFFLE_TYPE("slice", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, sizeof(PySliceObject));
 
 PyObject _Py_EllipsisObject = {
     _PyObject_EXTRA_INIT
diff --git a/graalpython/com.oracle.graal.python.cext/src/tupleobject.c b/graalpython/com.oracle.graal.python.cext/src/tupleobject.c
@@ -38,7 +38,7 @@
  */
 #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);
+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 *));
 
 /* Tuples */
 PyObject* PyTuple_New(Py_ssize_t size) {
diff --git a/graalpython/com.oracle.graal.python.cext/src/typeobject.c b/graalpython/com.oracle.graal.python.cext/src/typeobject.c
@@ -38,10 +38,17 @@
  */
 #include "capi.h"
 
+// taken from CPython "Objects/typeobject.c"
+typedef struct {
+    PyObject_HEAD
+    PyTypeObject *type;
+    PyObject *obj;
+    PyTypeObject *obj_type;
+} superobject;
 
-PyTypeObject PyType_Type = PY_TRUFFLE_TYPE("type", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS);
-PyTypeObject PyBaseObject_Type = PY_TRUFFLE_TYPE("object", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE);
-PyTypeObject PySuper_Type = PY_TRUFFLE_TYPE("super", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE);
+PyTypeObject PyType_Type = PY_TRUFFLE_TYPE("type", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS, sizeof(PyTypeObject));
+PyTypeObject PyBaseObject_Type = PY_TRUFFLE_TYPE("object", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, sizeof(PyObject));
+PyTypeObject PySuper_Type = PY_TRUFFLE_TYPE("super", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, sizeof(superobject));
 
 int PyType_IsSubtype(PyTypeObject* a, PyTypeObject* b) {
     return polyglot_as_i32(polyglot_invoke(PY_TRUFFLE_CEXT, "PyType_IsSubtype", to_java((PyObject*)a), to_java((PyObject*)b)));
diff --git a/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c b/graalpython/com.oracle.graal.python.cext/src/unicodeobject.c
@@ -38,7 +38,7 @@
  */
 #include "capi.h"
 
-PyTypeObject PyUnicode_Type = PY_TRUFFLE_TYPE("str", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_UNICODE_SUBCLASS);
+PyTypeObject PyUnicode_Type = PY_TRUFFLE_TYPE("str", &PyType_Type, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_UNICODE_SUBCLASS, sizeof(PyUnicodeObject));
 
 void* PyTruffle_Unicode_FromString(const char* o) {
     return truffle_invoke(PY_TRUFFLE_CEXT, "PyUnicode_FromString", polyglot_from_string(o, "utf-8"));
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java
@@ -47,10 +47,13 @@ public abstract class NativeMemberNames {
     public static final String TP_FLAGS = "tp_flags";
     public static final String TP_NAME = "tp_name";
     public static final String TP_BASE = "tp_base";
+    public static final String TP_BASICSIZE = "tp_basicsize";
+    public static final String TP_ALLOC = "tp_alloc";
     public static final String TP_AS_NUMBER = "tp_as_number";
     public static final String TP_HASH = "tp_hash";
     public static final String TP_RICHCOMPARE = "tp_richcompare";
     public static final String TP_SUBCLASSES = "tp_subclasses";
+    public static final String TP_AS_BUFFER = "tp_as_buffer";
     public static final String _BASE = "_base";
     public static final String OB_ITEM = "ob_item";
     public static final String MA_USED = "ma_used";
@@ -74,10 +77,13 @@ public static boolean isValid(String key) {
             case TP_FLAGS:
             case TP_NAME:
             case TP_BASE:
+            case TP_BASICSIZE:
+            case TP_ALLOC:
             case TP_AS_NUMBER:
             case TP_HASH:
             case TP_RICHCOMPARE:
             case TP_SUBCLASSES:
+            case TP_AS_BUFFER:
             case _BASE:
             case OB_ITEM:
             case MA_USED:
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/type/TypeBuiltins.java
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PGuards.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/PGuards.java
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialAttributeNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialAttributeNames.java
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialMethodNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialMethodNames.java
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/interop/PythonMessageResolution.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/interop/PythonMessageResolution.java
