Author: Armin Rigo <ar...@tunes.org>
Branch:
Changeset: r81977:7d1a37bf041c
Date: 2016-01-27 19:02 +0100
http://bitbucket.org/pypy/pypy/changeset/7d1a37bf041c/
Log: hg merge cpyext-bootstrap
simplify the bootstrap procedure, which was a bit manual and
slightly buggy (e.g. untranslated, it made two versions of the same
PyTypeObjects; and translated, the type objects ends up with
Py_TPFLAGS_HEAPTYPE, even though they should not be).
also fixes a potential memory corruption for initializing boolean
objects.
diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py
--- a/pypy/module/cpyext/api.py
+++ b/pypy/module/cpyext/api.py
@@ -442,8 +442,8 @@
TYPES = {}
GLOBALS = { # this needs to include all prebuilt pto, otherwise segfaults occur
'_Py_NoneStruct#': ('PyObject*', 'space.w_None'),
- '_Py_TrueStruct#': ('PyObject*', 'space.w_True'),
- '_Py_ZeroStruct#': ('PyObject*', 'space.w_False'),
+ '_Py_TrueStruct#': ('PyIntObject*', 'space.w_True'),
+ '_Py_ZeroStruct#': ('PyIntObject*', 'space.w_False'),
'_Py_NotImplementedStruct#': ('PyObject*', 'space.w_NotImplemented'),
'_Py_EllipsisObject#': ('PyObject*', 'space.w_Ellipsis'),
'PyDateTimeAPI': ('PyDateTime_CAPI*', 'None'),
@@ -506,7 +506,9 @@
def get_structtype_for_ctype(ctype):
from pypy.module.cpyext.typeobjectdefs import PyTypeObjectPtr
from pypy.module.cpyext.cdatetime import PyDateTime_CAPI
+ from pypy.module.cpyext.intobject import PyIntObject
return {"PyObject*": PyObject, "PyTypeObject*": PyTypeObjectPtr,
+ "PyIntObject*": PyIntObject,
"PyDateTime_CAPI*": lltype.Ptr(PyDateTime_CAPI)}[ctype]
PyTypeObject = lltype.ForwardReference()
@@ -828,6 +830,7 @@
space.fromcache(State).install_dll(eci)
# populate static data
+ builder = StaticObjectBuilder(space)
for name, (typ, expr) in GLOBALS.iteritems():
from pypy.module import cpyext
w_obj = eval(expr)
@@ -852,7 +855,7 @@
assert False, "Unknown static pointer: %s %s" % (typ, name)
ptr.value = ctypes.cast(ll2ctypes.lltype2ctypes(value),
ctypes.c_void_p).value
- elif typ in ('PyObject*', 'PyTypeObject*'):
+ elif typ in ('PyObject*', 'PyTypeObject*', 'PyIntObject*'):
if name.startswith('PyPyExc_') or
name.startswith('cpyexttestExc_'):
# we already have the pointer
in_dll = ll2ctypes.get_ctypes_type(PyObject).in_dll(bridge,
name)
@@ -861,17 +864,10 @@
# we have a structure, get its address
in_dll = ll2ctypes.get_ctypes_type(PyObject.TO).in_dll(bridge,
name)
py_obj = ll2ctypes.ctypes2lltype(PyObject,
ctypes.pointer(in_dll))
- from pypy.module.cpyext.pyobject import (
- track_reference, get_typedescr)
- w_type = space.type(w_obj)
- typedescr = get_typedescr(w_type.instancetypedef)
- py_obj.c_ob_refcnt = 1
- py_obj.c_ob_type = rffi.cast(PyTypeObjectPtr,
- make_ref(space, w_type))
- typedescr.attach(space, py_obj, w_obj)
- track_reference(space, py_obj, w_obj)
+ builder.prepare(py_obj, w_obj)
else:
assert False, "Unknown static object: %s %s" % (typ, name)
+ builder.attach_all()
pypyAPI = ctypes.POINTER(ctypes.c_void_p).in_dll(bridge, 'pypyAPI')
@@ -888,6 +884,36 @@
setup_init_functions(eci, translating=False)
return modulename.new(ext='')
+
+class StaticObjectBuilder:
+ def __init__(self, space):
+ self.space = space
+ self.to_attach = []
+
+ def prepare(self, py_obj, w_obj):
+ from pypy.module.cpyext.pyobject import track_reference
+ py_obj.c_ob_refcnt = 1
+ track_reference(self.space, py_obj, w_obj)
+ self.to_attach.append((py_obj, w_obj))
+
+ def attach_all(self):
+ from pypy.module.cpyext.pyobject import get_typedescr, make_ref
+ from pypy.module.cpyext.typeobject import finish_type_1, finish_type_2
+ space = self.space
+ space._cpyext_type_init = []
+ for py_obj, w_obj in self.to_attach:
+ w_type = space.type(w_obj)
+ typedescr = get_typedescr(w_type.instancetypedef)
+ py_obj.c_ob_type = rffi.cast(PyTypeObjectPtr,
+ make_ref(space, w_type))
+ typedescr.attach(space, py_obj, w_obj)
+ cpyext_type_init = space._cpyext_type_init
+ del space._cpyext_type_init
+ for pto, w_type in cpyext_type_init:
+ finish_type_1(space, pto)
+ finish_type_2(space, pto, w_type)
+
+
def mangle_name(prefix, name):
if name.startswith('Py'):
return prefix + name[2:]
@@ -1082,14 +1108,33 @@
run_bootstrap_functions(space)
setup_va_functions(eci)
+ from pypy.module import cpyext # for eval() below
+
+ # Set up the types. Needs a special case, because of the
+ # immediate cycle involving 'c_ob_type', and because we don't
+ # want these types to be Py_TPFLAGS_HEAPTYPE.
+ static_types = {}
+ for name, (typ, expr) in GLOBALS.items():
+ if typ == 'PyTypeObject*':
+ pto = lltype.malloc(PyTypeObject, immortal=True,
+ zero=True, flavor='raw')
+ pto.c_ob_refcnt = 1
+ pto.c_tp_basicsize = -1
+ static_types[name] = pto
+ builder = StaticObjectBuilder(space)
+ for name, pto in static_types.items():
+ pto.c_ob_type = static_types['PyType_Type#']
+ w_type = eval(GLOBALS[name][1])
+ builder.prepare(rffi.cast(PyObject, pto), w_type)
+ builder.attach_all()
+
# populate static data
for name, (typ, expr) in GLOBALS.iteritems():
name = name.replace("#", "")
if name.startswith('PyExc_'):
name = '_' + name
- from pypy.module import cpyext
w_obj = eval(expr)
- if typ in ('PyObject*', 'PyTypeObject*'):
+ if typ in ('PyObject*', 'PyTypeObject*', 'PyIntObject*'):
struct_ptr = make_ref(space, w_obj)
elif typ == 'PyDateTime_CAPI*':
continue
diff --git a/pypy/module/cpyext/test/test_typeobject.py
b/pypy/module/cpyext/test/test_typeobject.py
--- a/pypy/module/cpyext/test/test_typeobject.py
+++ b/pypy/module/cpyext/test/test_typeobject.py
@@ -374,6 +374,11 @@
module = self.import_extension('foo', [
("test_type", "METH_O",
'''
+ /* "args->ob_type" is a strange way to get at 'type',
+ which should have a different tp_getattro/tp_setattro
+ than its tp_base, which is 'object'.
+ */
+
if (!args->ob_type->tp_setattro)
{
PyErr_SetString(PyExc_ValueError, "missing tp_setattro");
@@ -382,8 +387,12 @@
if (args->ob_type->tp_setattro ==
args->ob_type->tp_base->tp_setattro)
{
- PyErr_SetString(PyExc_ValueError, "recursive
tp_setattro");
- return NULL;
+ /* Note that unlike CPython, in PyPy 'type.tp_setattro'
+ is the same function as 'object.tp_setattro'. This
+ test used to check that it was not, but that was an
+ artifact of the bootstrap logic only---in the final
+ C sources I checked and they are indeed the same.
+ So we ignore this problem here. */
}
if (!args->ob_type->tp_getattro)
{
diff --git a/pypy/module/cpyext/typeobject.py b/pypy/module/cpyext/typeobject.py
--- a/pypy/module/cpyext/typeobject.py
+++ b/pypy/module/cpyext/typeobject.py
@@ -146,7 +146,7 @@
assert len(slot_names) == 2
struct = getattr(pto, slot_names[0])
if not struct:
- assert not space.config.translating
+ #assert not space.config.translating
assert not pto.c_tp_flags & Py_TPFLAGS_HEAPTYPE
if slot_names[0] == 'c_tp_as_number':
STRUCT_TYPE = PyNumberMethods
@@ -310,55 +310,6 @@
realize=type_realize,
dealloc=type_dealloc)
- # some types are difficult to create because of cycles.
- # - object.ob_type = type
- # - type.ob_type = type
- # - tuple.ob_type = type
- # - type.tp_base = object
- # - tuple.tp_base = object
- # - type.tp_bases is a tuple
- # - object.tp_bases is a tuple
- # - tuple.tp_bases is a tuple
-
- # insert null placeholders to please create_ref()
- track_reference(space, lltype.nullptr(PyObject.TO), space.w_type)
- track_reference(space, lltype.nullptr(PyObject.TO), space.w_object)
- track_reference(space, lltype.nullptr(PyObject.TO), space.w_tuple)
- track_reference(space, lltype.nullptr(PyObject.TO), space.w_str)
-
- # create the objects
- py_type = create_ref(space, space.w_type)
- py_object = create_ref(space, space.w_object)
- py_tuple = create_ref(space, space.w_tuple)
- py_str = create_ref(space, space.w_str)
- # XXX py_str is not initialized here correctly, because we are
- # not tracking it, it gets an empty c_ob_type from py_basestring
-
- # form cycles
- pto_type = rffi.cast(PyTypeObjectPtr, py_type)
- py_type.c_ob_type = pto_type
- py_object.c_ob_type = pto_type
- py_tuple.c_ob_type = pto_type
-
- pto_object = rffi.cast(PyTypeObjectPtr, py_object)
- pto_type.c_tp_base = pto_object
- pto_tuple = rffi.cast(PyTypeObjectPtr, py_tuple)
- pto_tuple.c_tp_base = pto_object
-
- pto_type.c_tp_bases.c_ob_type = pto_tuple
- pto_object.c_tp_bases.c_ob_type = pto_tuple
- pto_tuple.c_tp_bases.c_ob_type = pto_tuple
-
- for typ in (py_type, py_object, py_tuple, py_str):
- heaptype = rffi.cast(PyHeapTypeObject, typ)
- heaptype.c_ht_name.c_ob_type = pto_type
-
- # Restore the mapping
- track_reference(space, py_type, space.w_type, replace=True)
- track_reference(space, py_object, space.w_object, replace=True)
- track_reference(space, py_tuple, space.w_tuple, replace=True)
- track_reference(space, py_str, space.w_str, replace=True)
-
@cpython_api([PyObject], lltype.Void, external=False)
def subtype_dealloc(space, obj):
@@ -476,6 +427,8 @@
pto.c_tp_as_sequence = heaptype.c_as_sequence
pto.c_tp_as_mapping = heaptype.c_as_mapping
pto.c_tp_as_buffer = heaptype.c_as_buffer
+ pto.c_tp_basicsize = -1 # hopefully this makes malloc bail out
+ pto.c_tp_itemsize = 0
return rffi.cast(PyObject, heaptype)
@@ -511,8 +464,6 @@
pto.c_tp_name = PyString_AsString(space, heaptype.c_ht_name)
else:
pto.c_tp_name = rffi.str2charp(w_type.name)
- pto.c_tp_basicsize = -1 # hopefully this makes malloc bail out
- pto.c_tp_itemsize = 0
# uninitialized fields:
# c_tp_print, c_tp_getattr, c_tp_setattr
# XXX implement
@@ -520,8 +471,11 @@
w_base = best_base(space, w_type.bases_w)
pto.c_tp_base = rffi.cast(PyTypeObjectPtr, make_ref(space, w_base))
- finish_type_1(space, pto)
- finish_type_2(space, pto, w_type)
+ if hasattr(space, '_cpyext_type_init'):
+ space._cpyext_type_init.append((pto, w_type))
+ else:
+ finish_type_1(space, pto)
+ finish_type_2(space, pto, w_type)
pto.c_tp_basicsize = rffi.sizeof(typedescr.basestruct)
if pto.c_tp_base:
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
