import sys from pypy.interpreter.error import OperationError, oefmt from pypy.interpreter.baseobjspace import W_Root, SpaceCache from rpython.rtyper.lltypesystem import rffi, lltype from rpython.rtyper.extregistry import ExtRegistryEntry from pypy.module.cpyext.api import ( cpython_api, bootstrap_function, PyObject, PyObjectP, ADDR, CANNOT_FAIL, Py_TPFLAGS_HEAPTYPE, PyTypeObjectPtr, is_PyObject, PyVarObject, Py_ssize_t, init_function, cts) from pypy.module.cpyext.state import State from pypy.objspace.std.typeobject import W_TypeObject from pypy.objspace.std.noneobject import W_NoneObject from pypy.objspace.std.boolobject import W_BoolObject from pypy.objspace.std.objectobject import W_ObjectObject from rpython.rlib.objectmodel import specialize, we_are_translated from rpython.rlib.objectmodel import keepalive_until_here from rpython.rtyper.annlowlevel import llhelper, cast_instance_to_base_ptr from rpython.rlib import rawrefcount, jit from rpython.rlib.debug import ll_assert, fatalerror, check_annotation #________________________________________________________ # type description class W_BaseCPyObject(W_ObjectObject): """ A subclass of W_ObjectObject that has one field for directly storing the link from the w_obj to the cpy ref. This is only used for C-defined types. """ def check_true(s_arg, bookeeper): assert s_arg.const is True def w_root_as_pyobj(w_obj, space): # make sure that translation crashes if we see this while translating # without cpyext check_annotation(space.config.objspace.usemodules.cpyext, check_true) # default implementation of _cpyext_as_pyobj return rawrefcount.from_obj(PyObject, w_obj) def w_root_attach_pyobj(w_obj, space, py_obj): check_annotation(space.config.objspace.usemodules.cpyext, check_true) assert space.config.objspace.usemodules.cpyext # default implementation of _cpyext_attach_pyobj rawrefcount.create_link_pypy(w_obj, py_obj) def add_direct_pyobj_storage(cls): """ Add the necessary methods to a class to store a reference to the py_obj on its instances directly. """ cls._cpy_ref = lltype.nullptr(PyObject.TO) def _cpyext_as_pyobj(self, space): return self._cpy_ref cls._cpyext_as_pyobj = _cpyext_as_pyobj def _cpyext_attach_pyobj(self, space, py_obj): self._cpy_ref = py_obj rawrefcount.create_link_pypy(self, py_obj) cls._cpyext_attach_pyobj = _cpyext_attach_pyobj add_direct_pyobj_storage(W_BaseCPyObject) add_direct_pyobj_storage(W_TypeObject) add_direct_pyobj_storage(W_NoneObject) add_direct_pyobj_storage(W_BoolObject) class BaseCpyTypedescr(object): basestruct = PyObject.TO W_BaseObject = W_ObjectObject def get_dealloc(self, space): state = space.fromcache(State) return state.C._PyPy_subtype_dealloc # CCC port to C def allocate(self, space, w_type, itemcount=0, immortal=False, itemsize=-1): # typically called from PyType_GenericAlloc via typedescr.allocate # this returns a PyObject with ob_refcnt == 1. pytype = as_pyobj(space, w_type) pytype = rffi.cast(PyTypeObjectPtr, pytype) assert pytype # Don't increase refcount for non-heaptypes flags = rffi.cast(lltype.Signed, pytype.c_tp_flags) if flags & Py_TPFLAGS_HEAPTYPE: incref(space, pytype) size = pytype.c_tp_basicsize if itemsize < 0: itemsize = pytype.c_tp_itemsize if itemsize: size += itemcount * itemsize assert size >= rffi.sizeof(PyObject.TO) buf = lltype.malloc(rffi.VOIDP.TO, size, flavor='raw', zero=True, add_memory_pressure=True, immortal=immortal) pyobj = rffi.cast(PyObject, buf) if itemsize or space.issubtype_w(w_type, space.w_list): pyvarobj = rffi.cast(PyVarObject, pyobj) pyvarobj.c_ob_size = itemcount pyobj.c_ob_refcnt = 1 #pyobj.c_ob_pypy_link should get assigned very quickly pyobj.c_ob_type = pytype return pyobj def attach(self, space, pyobj, w_obj, w_userdata=None): pass def realize(self, space, obj): w_type = from_ref(space, rffi.cast(PyObject, obj.c_ob_type)) assert isinstance(w_type, W_TypeObject) try: if w_type.flag_cpytype: w_obj = space.allocate_instance(W_BaseCPyObject, w_type) else: w_obj = space.allocate_instance(self.W_BaseObject, w_type) except OperationError as e: if e.match(space, space.w_TypeError): raise oefmt(space.w_SystemError, "cpyext: don't know how to make a '%N' object " "from a PyObject", w_type) raise track_reference(space, obj, w_obj) return w_obj typedescr_cache = {} def make_typedescr(typedef, **kw): """NOT_RPYTHON basestruct: The basic structure to allocate alloc : allocate and basic initialization of a raw PyObject attach : Function called to tie a raw structure to a pypy object realize : Function called to create a pypy object from a raw struct dealloc : a @slot_function(), similar to PyObject_dealloc """ tp_basestruct = kw.pop('basestruct', PyObject.TO) tp_alloc = kw.pop('alloc', None) tp_attach = kw.pop('attach', None) tp_realize = kw.pop('realize', None) tp_dealloc = kw.pop('dealloc', None) assert not kw, "Extra arguments to make_typedescr" null_dealloc = lltype.nullptr(lltype.FuncType([PyObject], lltype.Void)) assert not isinstance(tp_basestruct, lltype.Ptr), "should pass .TO" class CpyTypedescr(BaseCpyTypedescr): basestruct = tp_basestruct if tp_alloc: def allocate(self, space, w_type, itemcount=0, immortal=False, itemsize=-1): return tp_alloc(self, space, w_type, itemcount) if hasattr(tp_dealloc, 'api_func'): def get_dealloc(self, space): return tp_dealloc.api_func.get_llhelper(space) elif tp_dealloc: def get_dealloc(self, space): return tp_dealloc if tp_attach: def attach(self, space, pyobj, w_obj, w_userdata=None): tp_attach(space, pyobj, w_obj, w_userdata) if tp_realize: def realize(self, space, ref): return tp_realize(space, ref) if typedef: CpyTypedescr.__name__ = "CpyTypedescr_%s" % (typedef.name,) typedescr_cache[typedef] = CpyTypedescr() @bootstrap_function def init_pyobject(space): # typedescr for the 'object' type state = space.fromcache(State) make_typedescr(space.w_object.layout.typedef, dealloc=state.C._PyPy_object_dealloc) # almost all types, which should better inherit from object. make_typedescr(None) @specialize.memo() def _get_typedescr_1(typedef): try: return typedescr_cache[typedef] except KeyError: if typedef.bases: return _get_typedescr_1(typedef.bases[0]) return typedescr_cache[None] def get_typedescr(typedef): if typedef is None: return typedescr_cache[None] else: return _get_typedescr_1(typedef) #________________________________________________________ # refcounted object support class InvalidPointerException(Exception): pass @jit.dont_look_inside def create_ref(space, w_obj, w_userdata=None, immortal=False): """ Allocates a PyObject, and fills its fields with info from the given interpreter object. """ w_type = space.type(w_obj) pytype = rffi.cast(PyTypeObjectPtr, as_pyobj(space, w_type)) typedescr = get_typedescr(w_obj.typedef) if space.is_w(w_type, space.w_text): # These PyUnicodeObjects will always take the compact form # since they come from uint8-encoded strings, so we must # override the default tp_itemsize (see also unicode_alloc) # Maybe this snippet should use the ptype.tp_alloc to allocate the py_obj? itemsize = 1 elif space.is_w(w_type, space.w_type): # Subclasses of "type" (which has space for PyMemberDef) do not # need space for tp_member like heap types do itemsize = 0 else: itemsize = pytype.c_tp_itemsize if itemsize != 0 or space.issubtype_w(w_type, space.w_list): # PyBytesObject, compact PyUnicodeObject and subclasses try: # Can cause infinite recursion if w_obj.__len__ is a c function # so the call will try to convert w_obj to a pyobj via create_ref from pypy.objspace.std.listobject import W_ListObject if isinstance(w_obj, W_ListObject): itemcount = w_obj.length() else: itemcount = space.len_w(w_obj) except OperationError as e: if e.match(space, space.w_TypeError): # issue 4013: is this correct? itemcount = 0 # raise oefmt(space.w_SystemError, # "cpyext: Failure to allocate '%N' (with a non-zero " # "tp_itemsize) when len(obj) cannot be calculated", # w_type) else: raise else: itemcount = 0 py_obj = typedescr.allocate(space, w_type, itemcount=itemcount, immortal=immortal) track_reference(space, py_obj, w_obj) # # py_obj.c_ob_refcnt should be exactly REFCNT_FROM_PYPY + 1 here, # and we want only REFCNT_FROM_PYPY, i.e. only count as attached # to the W_Root but not with any reference from the py_obj side. assert py_obj.c_ob_refcnt > rawrefcount.REFCNT_FROM_PYPY py_obj.c_ob_refcnt -= 1 # typedescr.attach(space, py_obj, w_obj, w_userdata) # This is probably not the best place for this stanza, but we need the # w_obj so it cannot be done in allocate() # It should probably also be in track_reference if pytype.c_tp_dictoffset: dictoffset = pytype.c_tp_dictoffset try: w_dict = space.getattr(w_obj, space.newtext("__dict__")) except OperationError as e: dictref = make_ref(space, space.w_None) else: dictref = make_ref(space, w_dict) if dictoffset < 0: dictoffset += pytype.c_tp_basicsize loc = rffi.ptradd(cts.cast("char *", py_obj), dictoffset) dictloc = cts.cast("PyObject **", loc) dictloc[0] = dictref return py_obj def track_reference(space, py_obj, w_obj): """ Ties together a PyObject and an interpreter object. The PyObject's refcnt is increased by REFCNT_FROM_PYPY. The reference in 'py_obj' is not stolen! Remember to decref() it if you need to. """ # XXX looks like a PyObject_GC_TRACK assert py_obj.c_ob_refcnt < rawrefcount.REFCNT_FROM_PYPY py_obj.c_ob_refcnt += rawrefcount.REFCNT_FROM_PYPY w_obj._cpyext_attach_pyobj(space, py_obj) w_marker_deallocating = W_Root() @jit.dont_look_inside def from_ref(space, ref): """ Finds the interpreter object corresponding to the given reference. If the object is not yet realized (see bytesobject.py), creates it. """ assert is_pyobj(ref) if not ref: return None w_obj = rawrefcount.to_obj(W_Root, rffi.cast(PyObject, ref)) if w_obj is not None: if w_obj is not w_marker_deallocating: return w_obj type_name = rffi.charp2str(cts.cast('char*', ref.c_ob_type.c_tp_name)) fatalerror( "*** Invalid usage of a dying CPython object ***\n" "\n" "cpyext, the emulation layer, detected that while it is calling\n" "an object's tp_dealloc, the C code calls back a function that\n" "tries to recreate the PyPy version of the object. Usually it\n" "means that tp_dealloc calls some general PyXxx() API. It is\n" "a dangerous and potentially buggy thing to do: even in CPython\n" "the PyXxx() function could, in theory, cause a reference to the\n" "object to be taken and stored somewhere, for an amount of time\n" "exceeding tp_dealloc itself. Afterwards, the object will be\n" "freed, making that reference point to garbage.\n" ">>> PyPy could contain some workaround to still work if\n" "you are lucky, but it is not done so far; better fix the bug in\n" "the CPython extension.\n" ">>> This object is of type '%s'" % (type_name,)) # This reference is not yet a real interpreter object. # Realize it. ref_type = rffi.cast(PyObject, ref.c_ob_type) if ref_type == ref: # recursion! raise InvalidPointerException(str(ref)) w_type = from_ref(space, ref_type) assert isinstance(w_type, W_TypeObject) return get_typedescr(w_type.layout.typedef).realize(space, ref) @jit.dont_look_inside def as_pyobj(space, w_obj, w_userdata=None, immortal=False): """ Returns a 'PyObject *' representing the given interpreter object. This doesn't give a new reference, but the returned 'PyObject *' is valid at least as long as 'w_obj' is. **To be safe, you should use keepalive_until_here(w_obj) some time later.** In case of doubt, use the safer make_ref(). """ assert not is_pyobj(w_obj) if w_obj is not None: py_obj = w_obj._cpyext_as_pyobj(space) if not py_obj: py_obj = create_ref(space, w_obj, w_userdata, immortal=immortal) # # Try to crash here, instead of randomly, if we don't keep w_obj alive ll_assert(py_obj.c_ob_refcnt >= rawrefcount.REFCNT_FROM_PYPY, "Bug in cpyext: The W_Root object was garbage-collected " "while being converted to PyObject.") return py_obj else: return lltype.nullptr(PyObject.TO) as_pyobj._always_inline_ = 'try' def pyobj_has_w_obj(pyobj): w_obj = rawrefcount.to_obj(W_Root, pyobj) return w_obj is not None and w_obj is not w_marker_deallocating def w_obj_has_pyobj(w_obj): return bool(rawrefcount.from_obj(PyObject, w_obj)) def is_pyobj(x): if x is None or isinstance(x, W_Root): return False elif is_PyObject(lltype.typeOf(x)): return True else: raise TypeError(repr(type(x))) class Entry(ExtRegistryEntry): _about_ = is_pyobj def compute_result_annotation(self, s_x): from rpython.rtyper.llannotation import SomePtr return self.bookkeeper.immutablevalue(isinstance(s_x, SomePtr)) def specialize_call(self, hop): hop.exception_cannot_occur() return hop.inputconst(lltype.Bool, hop.s_result.const) def get_pyobj_and_incref(space, w_obj, w_userdata=None, immortal=False): pyobj = as_pyobj(space, w_obj, w_userdata, immortal=immortal) if pyobj: # != NULL assert pyobj.c_ob_refcnt >= rawrefcount.REFCNT_FROM_PYPY pyobj.c_ob_refcnt += 1 keepalive_until_here(w_obj) return pyobj def hack_for_result_often_existing_obj(space, w_obj): # Equivalent to get_pyobj_and_incref() and not to make_ref(): # it builds a PyObject from a W_Root, but ensures that the result # gets attached to the original W_Root. This is needed to work around # some obscure abuses: https://github.com/numpy/numpy/issues/9850 return get_pyobj_and_incref(space, w_obj) def make_ref(space, w_obj, w_userdata=None, immortal=False): """Turn the W_Root into a corresponding PyObject. You should decref the returned PyObject later. Note that it is often the case, but not guaranteed, that make_ref() returns always the same PyObject for the same W_Root; for example, integers. """ assert not is_pyobj(w_obj) if False and w_obj is not None and space.type(w_obj) is space.w_int: # XXX: adapt for pypy3 state = space.fromcache(State) intval = space.int_w(w_obj) return state.ccall("PyLong_FromLong", intval) return get_pyobj_and_incref(space, w_obj, w_userdata, immortal=False) @specialize.ll() def get_w_obj_and_decref(space, pyobj): """Decrement the reference counter of the PyObject and return the corresponding W_Root object (so the reference count after the decref is at least REFCNT_FROM_PYPY and cannot be zero). """ assert is_pyobj(pyobj) pyobj = rffi.cast(PyObject, pyobj) w_obj = from_ref(space, pyobj) if pyobj: pyobj.c_ob_refcnt -= 1 assert pyobj.c_ob_refcnt >= rawrefcount.REFCNT_FROM_PYPY keepalive_until_here(w_obj) return w_obj @specialize.ll() def incref(space, pyobj): assert is_pyobj(pyobj) pyobj = rffi.cast(PyObject, pyobj) assert pyobj.c_ob_refcnt >= 1 pyobj.c_ob_refcnt += 1 @specialize.ll() def decref(space, pyobj): from pypy.module.cpyext.api import generic_cpy_call assert is_pyobj(pyobj) pyobj = rffi.cast(PyObject, pyobj) if pyobj: assert pyobj.c_ob_refcnt > 0 assert (pyobj.c_ob_pypy_link == 0 or pyobj.c_ob_refcnt > rawrefcount.REFCNT_FROM_PYPY) pyobj.c_ob_refcnt -= 1 if pyobj.c_ob_refcnt == 0: state = space.fromcache(State) generic_cpy_call(space, state.C._Py_Dealloc, pyobj) #else: # w_obj = rawrefcount.to_obj(W_Root, ref) # if w_obj is not None: # assert pyobj.c_ob_refcnt >= rawrefcount.REFCNT_FROM_PYPY @init_function def write_w_marker_deallocating(space): if we_are_translated(): llptr = cast_instance_to_base_ptr(w_marker_deallocating) state = space.fromcache(State) state.C.set_marker(llptr) @cpython_api([rffi.VOIDP], lltype.Signed, error=CANNOT_FAIL) def _Py_HashPointer(space, ptr): return rffi.cast(lltype.Signed, ptr) @cpython_api([PyObject], lltype.Void) def Py_IncRef(space, obj): # used only ifdef PYPY_DEBUG_REFCOUNT if obj: incref(space, obj) @cpython_api([PyObject], lltype.Void) def Py_DecRef(space, obj): # used only ifdef PYPY_DEBUG_REFCOUNT decref(space, obj)