[<length> <virtual> <vref> <virtual> <vref>] for virtualrefs
[<pc> <jitcode> <numb> <numb> <numb>] the frames
[<pc> <jitcode> <numb> <numb>]
...
until the size of the resume section
# ----- optimization section
<more code> further sections according to bridgeopt.py
"""
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import objectmodel
NUMBERINGP = lltype.Ptr(lltype.GcForwardReference())
NUMBERING = lltype.GcStruct('Numbering', ('code', lltype.Array(rffi.UCHAR)))
NUMBERINGP.TO.become(NUMBERING)
NULL_NUMBER = lltype.nullptr(NUMBERING)
def append_numbering(lst, item):
item = rffi.cast(lltype.Signed, item)
item *= 2
if item < 0:
item = -1 - item
assert item >= 0
if item < 2**7:
lst.append(rffi.cast(rffi.UCHAR, item))
elif item < 2**14:
dict_w = {}
convert_method_defs(space, dict_w, methods, None, w_mod, modname)
for key, w_value in dict_w.items():
space.setattr(w_mod, space.newtext(key), w_value)
if doc:
space.setattr(w_mod, space.newtext("__doc__"), space.newtext(doc))
if module.c_m_size > 0:
py_mod.c_md_state = lltype.malloc(rffi.VOIDP.TO,
module.c_m_size,
flavor='raw',
zero=True)
return w_mod
createfunctype = lltype.Ptr(lltype.FuncType([PyObject, PyModuleDef], PyObject))
execfunctype = lltype.Ptr(lltype.FuncType([PyObject], rffi.INT_real))
def create_module_from_def_and_spec(space, moddef, w_spec, name):
moddef = rffi.cast(PyModuleDef, moddef)
if moddef.c_m_size < 0:
raise oefmt(
space.w_SystemError,
"module %s: m_size may not be negative for multi-phase "
"initialization", name)
createf = lltype.nullptr(rffi.VOIDP.TO)
has_execution_slots = False
cur_slot = rffi.cast(rffi.CArrayPtr(PyModuleDef_Slot), moddef.c_m_slots)
if cur_slot:
while True:
class TestRegallocGcIntegration(BaseTestRegalloc):
cpu = CPU(None, None)
cpu.gc_ll_descr = GcLLDescr_boehm(None, None, None)
cpu.setup_once()
S = lltype.GcForwardReference()
S.become(
lltype.GcStruct('S', ('field', lltype.Ptr(S)), ('int', lltype.Signed)))
fielddescr = cpu.fielddescrof(S, 'field')
struct_ptr = lltype.malloc(S)
struct_ref = lltype.cast_opaque_ptr(llmemory.GCREF, struct_ptr)
child_ptr = lltype.nullptr(S)
struct_ptr.field = child_ptr
intdescr = cpu.fielddescrof(S, 'int')
ptr0 = struct_ref
targettoken = TargetToken()
targettoken2 = TargetToken()
namespace = locals().copy()
def test_basic(self):
ops = '''
[p0]
p1 = getfield_gc_r(p0, descr=fielddescr)
finish(p1)
'''
self.interpret(ops, [self.struct_ptr])
assert not self.getptr(0, lltype.Ptr(self.S))
def test_guard(self):
ops = '''
[i0, p0, i1, p1]
p3 = getfield_gc_r(p0, descr=fielddescr)
guard_true(i0) [p0, i1, p1, p3]
'''
s1 = lltype.malloc(self.S)
s2 = lltype.malloc(self.S)
s1.field = s2
self.interpret(ops, [0, s1, 1, s2])
frame = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, self.deadframe)
# p0 and p3 should be in registers, p1 not so much
assert self.getptr(0, lltype.Ptr(self.S)) == s1
# the gcmap should contain three things, p0, p1 and p3
# p3 stays in a register
# while p0 and p1 are on the frame
b = getmap(frame)
nos = [len(b) - 1 - i.start() for i in re.finditer('1', b)]
nos.reverse()
if self.cpu.backend_name.startswith('x86'):
if self.cpu.IS_64_BIT:
assert nos == [0, 1, 31]
else:
assert nos == [0, 1, 25]
elif self.cpu.backend_name.startswith('arm'):
assert nos == [0, 1, 47]
elif self.cpu.backend_name.startswith('ppc64'):
assert nos == [0, 1, 33]
elif self.cpu.backend_name.startswith('zarch'):
assert nos == [0, 1, 29]
else:
raise Exception("write the data here")
assert frame.jf_frame[nos[0]]
assert frame.jf_frame[nos[1]]
assert frame.jf_frame[nos[2]]
def test_rewrite_constptr(self):
ops = '''
[]
p1 = getfield_gc_r(ConstPtr(struct_ref), descr=fielddescr)
finish(p1)
'''
self.interpret(ops, [])
assert not self.getptr(0, lltype.Ptr(self.S))
def test_bug_0(self):
ops = '''
[i0, i1, i2, i3, i4, i5, i6, i7, i8]
label(i0, i1, i2, i3, i4, i5, i6, i7, i8, descr=targettoken)
guard_value(i2, 1) [i2, i3, i4, i5, i6, i7, i0, i1, i8]
guard_class(i4, 138998336) [i4, i5, i6, i7, i0, i1, i8]
i11 = getfield_gc_i(i4, descr=intdescr)
guard_nonnull(i11) [i4, i5, i6, i7, i0, i1, i11, i8]
i13 = getfield_gc_i(i11, descr=intdescr)
guard_isnull(i13) [i4, i5, i6, i7, i0, i1, i11, i8]
i15 = getfield_gc_i(i4, descr=intdescr)
i17 = int_lt(i15, 0)
guard_false(i17) [i4, i5, i6, i7, i0, i1, i11, i15, i8]
i18 = getfield_gc_i(i11, descr=intdescr)
i19 = int_ge(i15, i18)
guard_false(i19) [i4, i5, i6, i7, i0, i1, i11, i15, i8]
i20 = int_lt(i15, 0)
guard_false(i20) [i4, i5, i6, i7, i0, i1, i11, i15, i8]
i21 = getfield_gc_i(i11, descr=intdescr)
i22 = getfield_gc_i(i11, descr=intdescr)
i23 = int_mul(i15, i22)
i24 = int_add(i21, i23)
i25 = getfield_gc_i(i4, descr=intdescr)
i27 = int_add(i25, 1)
setfield_gc(i4, i27, descr=intdescr)
i29 = getfield_raw_i(144839744, descr=intdescr)
i31 = int_and(i29, -2141192192)
i32 = int_is_true(i31)
guard_false(i32) [i4, i6, i7, i0, i1, i24]
i33 = getfield_gc_i(i0, descr=intdescr)
guard_value(i33, ConstPtr(ptr0)) [i4, i6, i7, i0, i1, i33, i24]
jump(i0, i1, 1, 17, i4, ConstPtr(ptr0), i6, i7, i24, descr=targettoken)
'''
self.interpret(ops, [0, 0, 0, 0, 0, 0, 0, 0, 0], run=False)
def _ll_1_weakref_deref(TP, obj):
return llop.weakref_deref(lltype.Ptr(TP), obj)
def compute_result_annotation(self, s_str):
from rpython.rtyper.lltypesystem.rstr import STR, UNICODE
if strtype is str:
return lltype_to_annotation(lltype.Ptr(STR))
else:
return lltype_to_annotation(lltype.Ptr(UNICODE))
(T_UINT, rffi.UINT, PyInt_AsUnsignedLong),
(T_ULONG, rffi.ULONG, PyInt_AsUnsignedLong),
(T_BYTE, rffi.SIGNEDCHAR, PyInt_AsLong),
(T_UBYTE, rffi.UCHAR, PyInt_AsUnsignedLong),
(T_BOOL, rffi.UCHAR, PyInt_AsLong),
(T_FLOAT, rffi.FLOAT, PyFloat_AsDouble),
(T_DOUBLE, rffi.DOUBLE, PyFloat_AsDouble),
(T_LONGLONG, rffi.LONGLONG, PyLong_AsLongLong),
(T_ULONGLONG, rffi.ULONGLONG, PyLong_AsUnsignedLongLong),
(T_PYSSIZET, rffi.SSIZE_T, PyLong_AsSsize_t),
])
_HEADER = 'pypy_structmember_decl.h'
@cpython_api([CONST_STRING, lltype.Ptr(PyMemberDef)], PyObject, header=_HEADER)
def PyMember_GetOne(space, obj, w_member):
addr = rffi.ptradd(obj, w_member.c_offset)
member_type = rffi.cast(lltype.Signed, w_member.c_type)
for converter in integer_converters:
typ, lltyp, _ = converter
if typ == member_type:
result = rffi.cast(rffi.CArrayPtr(lltyp), addr)
if lltyp is rffi.FLOAT:
w_result = space.newfloat(
lltype.cast_primitive(lltype.Float, result[0]))
elif typ == T_BOOL:
x = rffi.cast(lltype.Signed, result[0])
w_result = space.newbool(x != 0)
elif typ == T_DOUBLE:
w_result = space.newfloat(result[0])
class CInterface(object):
def __init__(self, namespace):
for k, v in namespace.iteritems():
setattr(self, k, v)
def _freeze_(self):
return True
# --- copy a few declarations from src/vmprof_stack.h ---
VMPROF_CODE_TAG = 1
VMPROFSTACK = lltype.ForwardReference()
PVMPROFSTACK = lltype.Ptr(VMPROFSTACK)
VMPROFSTACK.become(
rffi.CStruct("vmprof_stack_s", ('next', PVMPROFSTACK),
('value', lltype.Signed), ('kind', lltype.Signed)))
# ----------
vmprof_tl_stack = rthread.ThreadLocalField(PVMPROFSTACK, "vmprof_tl_stack")
do_use_eci = rffi.llexternal_use_eci(
ExternalCompilationInfo(includes=['vmprof_stack.h'], include_dirs=[SRC]))
def enter_code(unique_id):
do_use_eci()
s = lltype.malloc(VMPROFSTACK, flavor='raw')
s.c_next = vmprof_tl_stack.get_or_make_raw()
s.c_value = unique_id
("wReserved", WORD),
## should be a union. dwOemId is obsolete, anyway
("dwPageSize", DWORD),
("lpMinimumApplicationAddress", LPVOID),
("lpMaximumApplicationAddress", LPVOID),
("dwActiveProcessorMask", DWORD_PTR),
("dwNumberOfProcessors", DWORD),
("dwProcessorType", DWORD),
("dwAllocationGranularity", DWORD),
("wProcessorLevel", WORD),
("wProcessorRevision", WORD),
])
config = rffi_platform.configure(ComplexCConfig)
SYSTEM_INFO = config['SYSTEM_INFO']
SYSTEM_INFO_P = lltype.Ptr(SYSTEM_INFO)
GetSystemInfo, _ = winexternal('GetSystemInfo', [SYSTEM_INFO_P],
lltype.Void)
GetFileSize, _ = winexternal('GetFileSize', [HANDLE, LPDWORD],
DWORD,
save_err=rffi.RFFI_SAVE_LASTERROR)
GetCurrentProcess, _ = winexternal('GetCurrentProcess', [], HANDLE)
DuplicateHandle, _ = winexternal(
'DuplicateHandle',
[HANDLE, HANDLE, HANDLE, LPHANDLE, DWORD, BOOL, DWORD],
BOOL,
save_err=rffi.RFFI_SAVE_LASTERROR)
CreateFileMapping, _ = winexternal(
'CreateFileMappingA',
[HANDLE, rwin32.LPSECURITY_ATTRIBUTES, DWORD, DWORD, DWORD, LPCSTR],
__call__=interp2app(cwrapper_descr_call),
__get__=interp2app(cmethod_descr_get),
__name__=interp_attrproperty('method_name',
cls=W_PyCWrapperObject,
wrapfn="newtext_or_none"),
__doc__=interp_attrproperty('doc',
cls=W_PyCWrapperObject,
wrapfn="newtext_or_none"),
__objclass__=interp_attrproperty_w('w_objclass', cls=W_PyCWrapperObject),
__repr__=interp2app(W_PyCWrapperObject.descr_method_repr),
# XXX missing: __getattribute__
)
W_PyCWrapperObject.typedef.acceptable_as_base_class = False
@cpython_api([lltype.Ptr(PyMethodDef), PyObject, PyObject], PyObject)
def PyCFunction_NewEx(space, ml, w_self, w_name):
return W_PyCFunctionObject(space, ml, w_self, w_name)
@cts.decl("PyCFunction PyCFunction_GetFunction(PyObject *)")
def PyCFunction_GetFunction(space, w_obj):
try:
cfunction = space.interp_w(W_PyCFunctionObject, w_obj)
except OperationError as e:
if e.match(space, space.w_TypeError):
raise oefmt(space.w_SystemError,
"bad argument to internal function")
raise
return cfunction.ml.c_ml_meth
# ____________________________________________________________
class NullAddressError(Exception):
pass
class DanglingPointerError(Exception):
pass
NULL = fakeaddress(None)
Address = lltype.Primitive("Address", NULL)
# GCREF is similar to Address but it is GC-aware
GCREF = lltype.Ptr(lltype.GcOpaqueType('GCREF'))
# A placeholder for any type that is a GcArray of pointers.
# This can be used in the symbolic offsets above to access such arrays
# in a generic way.
GCARRAY_OF_PTR = lltype.GcArray(GCREF, hints={'placeholder': True})
gcarrayofptr_lengthoffset = ArrayLengthOffset(GCARRAY_OF_PTR)
gcarrayofptr_itemsoffset = ArrayItemsOffset(GCARRAY_OF_PTR)
gcarrayofptr_singleitemoffset = ItemOffset(GCARRAY_OF_PTR.OF)
def array_type_match(A1, A2):
return A1 == A2 or (A2 == GCARRAY_OF_PTR and isinstance(
A1, lltype.GcArray) and isinstance(A1.OF, lltype.Ptr)
and not A1._hints.get('nolength'))
def vmprof_execute_code(name,
get_code_fn,
result_class=None,
_hack_update_stack_untranslated=False):
"""Decorator to be used on the function that interprets a code object.
'name' must be a unique name.
'get_code_fn(*args)' is called to extract the code object from the
arguments given to the decorated function.
'result_class' is ignored (backward compatibility).
"""
if _hack_update_stack_untranslated:
from rpython.rtyper.annlowlevel import llhelper
enter_code = llhelper(
lltype.Ptr(lltype.FuncType([lltype.Signed], cintf.PVMPROFSTACK)),
cintf.enter_code)
leave_code = llhelper(
lltype.Ptr(lltype.FuncType([cintf.PVMPROFSTACK], lltype.Void)),
cintf.leave_code)
else:
enter_code = cintf.enter_code
leave_code = cintf.leave_code
def decorate(func):
try:
_get_vmprof()
except cintf.VMProfPlatformUnsupported:
return func
@jit.oopspec("rvmprof.jitted(unique_id)")
def decorated_jitted_function(unique_id, *args):
return func(*args)
def decorated_function(*args):
unique_id = get_code_fn(*args)._vmprof_unique_id
unique_id = rffi.cast(lltype.Signed, unique_id)
# ^^^ removes the "known non-negative" hint for annotation
#
# Signals can occur at the two places (1) and (2), that will
# have added a stack entry, but the function __vmprof_eval_vmprof
# is not entered. This behaviour will swallow one Python stack frame
#
# Current fix: vmprof will discard this sample. (happens
# very infrequently)
#
if not jit.we_are_jitted():
x = enter_code(unique_id)
# (1) signal here
try:
return func(*args)
finally:
# (2) signal here
leave_code(x)
else:
return decorated_jitted_function(unique_id, *args)
decorated_function.__name__ = func.__name__ + '_rvmprof'
decorated_function.c_name = '__vmprof_eval_vmprof'
return decorated_function
return decorate
import os
from rpython.rlib import entrypoint
from rpython.rtyper.lltypesystem import lltype, rffi
from rpython.translator.tool.cbuild import ExternalCompilationInfo
from pypy.interpreter.error import OperationError, oefmt
# ____________________________________________________________
EMBED_VERSION_MIN = 0xB011
EMBED_VERSION_MAX = 0xB0FF
STDERR = 2
INITSTRUCTPTR = lltype.Ptr(
lltype.Struct('CFFI_INIT', ('name', rffi.CCHARP), ('func', rffi.VOIDP),
('code', rffi.CCHARP)))
def load_embedded_cffi_module(space, version, init_struct):
from pypy.module._cffi_backend.cffi1_module import load_cffi1_module
declare_c_function() # translation-time hint only:
# declare _cffi_carefully_make_gil()
#
version = rffi.cast(lltype.Signed, version)
if not (EMBED_VERSION_MIN <= version <= EMBED_VERSION_MAX):
raise oefmt(space.w_ImportError,
"cffi embedded module has got unknown version tag %s",
hex(version))
#
if space.config.objspace.usemodules.thread:
from pypy.module.thread import os_thread
DWORD)
def GetModuleFileName(module):
size = MAX_PATH
buf = lltype.malloc(rffi.CCHARP.TO, size, flavor='raw')
try:
res = _GetModuleFileName(module, buf, size)
if not res:
return ''
else:
return ''.join([buf[i] for i in range(res)])
finally:
lltype.free(buf, flavor='raw')
_GetVersionEx = winexternal('GetVersionExA',
[lltype.Ptr(OSVERSIONINFOEX)],
DWORD,
save_err=rffi.RFFI_SAVE_LASTERROR)
@jit.dont_look_inside
def GetVersionEx():
info = lltype.malloc(OSVERSIONINFOEX, flavor='raw')
rffi.setintfield(info, 'c_dwOSVersionInfoSize',
rffi.sizeof(OSVERSIONINFOEX))
try:
if not _GetVersionEx(info):
raise lastSavedWindowsError()
return (rffi.cast(lltype.Signed, info.c_dwMajorVersion),
rffi.cast(lltype.Signed, info.c_dwMinorVersion),
rffi.cast(lltype.Signed, info.c_dwBuildNumber),
rffi.cast(lltype.Signed, info.c_dwPlatformId),
from pypy.module.cpyext.api import (cpython_api, CANNOT_FAIL, cpython_struct)
from pypy.module.cpyext.pyobject import PyObject, decref, make_ref
from pypy.interpreter.error import OperationError
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rthread
from rpython.rlib.objectmodel import we_are_translated
PyInterpreterStateStruct = lltype.ForwardReference()
PyInterpreterState = lltype.Ptr(PyInterpreterStateStruct)
cpython_struct("PyInterpreterState", [('next', PyInterpreterState)],
PyInterpreterStateStruct)
PyThreadState = lltype.Ptr(
cpython_struct("PyThreadState", [
('interp', PyInterpreterState),
('dict', PyObject),
]))
class NoThreads(Exception):
pass
@cpython_api([], PyThreadState, error=CANNOT_FAIL, gil="release")
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
support is enabled) and reset the thread state to NULL, returning the
previous thread state. If the lock has been created,
the current thread must have acquired it. (This function is available even
when thread support is disabled at compile time.)"""
state = space.fromcache(InterpreterState)
ec = space.getexecutioncontext()
asm_ifc = 'win64.asm'
eci = ExternalCompilationInfo(
includes=['ffi.h', 'windows.h'],
libraries=['kernel32'],
include_dirs=[libffidir, cdir],
separate_module_sources=separate_module_sources,
post_include_bits=post_include_bits,
separate_module_files=[
libffidir.join('ffi.c'),
libffidir.join('prep_cif.c'),
libffidir.join(asm_ifc),
libffidir.join('pypy_ffi.c'),
],
)
FFI_TYPE_P = lltype.Ptr(lltype.ForwardReference())
FFI_TYPE_PP = rffi.CArrayPtr(FFI_TYPE_P)
FFI_TYPE_NULL = lltype.nullptr(FFI_TYPE_P.TO)
class CConfig:
_compilation_info_ = eci
FFI_OK = rffi_platform.ConstantInteger('FFI_OK')
FFI_BAD_TYPEDEF = rffi_platform.ConstantInteger('FFI_BAD_TYPEDEF')
FFI_DEFAULT_ABI = rffi_platform.ConstantInteger('FFI_DEFAULT_ABI')
if _WIN32 and not _WIN64:
FFI_STDCALL = rffi_platform.ConstantInteger('FFI_STDCALL')
if _ARM:
FFI_SYSV = rffi_platform.ConstantInteger('FFI_SYSV')
def _setup_write_barrier(self):
self.WB_FUNCPTR = lltype.Ptr(
lltype.FuncType([llmemory.Address], lltype.Void))
self.write_barrier_descr = WriteBarrierDescr(self)
class LLtypeMixin(object):
def get_class_of_box(self, box):
base = box.getref_base()
return lltype.cast_opaque_ptr(rclass.OBJECTPTR, base).typeptr
node_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
node_vtable.name = rclass.alloc_array_name('node')
node_vtable_adr = llmemory.cast_ptr_to_adr(node_vtable)
node_vtable2 = lltype.malloc(OBJECT_VTABLE, immortal=True)
node_vtable2.name = rclass.alloc_array_name('node2')
node_vtable_adr2 = llmemory.cast_ptr_to_adr(node_vtable2)
node_vtable3 = lltype.malloc(OBJECT_VTABLE, immortal=True)
node_vtable3.name = rclass.alloc_array_name('node3')
node_vtable_adr3 = llmemory.cast_ptr_to_adr(node_vtable3)
cpu = runner.LLGraphCPU(None)
NODE = lltype.GcForwardReference()
S = lltype.GcForwardReference()
NODE.become(lltype.GcStruct('NODE', ('parent', OBJECT),
('value', lltype.Signed),
('floatval', lltype.Float),
('charval', lltype.Char),
('nexttuple', lltype.Ptr(S)),
('next', lltype.Ptr(NODE))))
S.become(lltype.GcStruct('TUPLE', ('a', lltype.Signed), ('abis', lltype.Signed),
('b', lltype.Ptr(NODE))))
NODE2 = lltype.GcStruct('NODE2', ('parent', NODE),
('other', lltype.Ptr(NODE)))
NODE3 = lltype.GcForwardReference()
NODE3.become(lltype.GcStruct('NODE3', ('parent', OBJECT),
('value', lltype.Signed),
('next', lltype.Ptr(NODE3)),
hints={'immutable': True}))
big_fields = [('big' + i, lltype.Signed) for i in string.ascii_lowercase]
BIG = lltype.GcForwardReference()
BIG.become(lltype.GcStruct('BIG', *big_fields, hints={'immutable': True}))
for field, _ in big_fields:
locals()[field + 'descr'] = cpu.fielddescrof(BIG, field)
node = lltype.malloc(NODE)
node.value = 5
node.next = node
node.parent.typeptr = node_vtable
nodeaddr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
#nodebox = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node))
node2 = lltype.malloc(NODE2)
node2.parent.parent.typeptr = node_vtable2
node2addr = lltype.cast_opaque_ptr(llmemory.GCREF, node2)
myptr = lltype.cast_opaque_ptr(llmemory.GCREF, node)
mynodeb = lltype.malloc(NODE)
myarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(lltype.GcArray(lltype.Signed), 13, zero=True))
mynodeb.parent.typeptr = node_vtable
myptrb = lltype.cast_opaque_ptr(llmemory.GCREF, mynodeb)
myptr2 = lltype.malloc(NODE2)
myptr2.parent.parent.typeptr = node_vtable2
myptr2 = lltype.cast_opaque_ptr(llmemory.GCREF, myptr2)
nullptr = lltype.nullptr(llmemory.GCREF.TO)
mynode3 = lltype.malloc(NODE3)
mynode3.parent.typeptr = node_vtable3
mynode3.value = 7
mynode3.next = mynode3
myptr3 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode3) # a NODE2
mynode4 = lltype.malloc(NODE3)
mynode4.parent.typeptr = node_vtable3
myptr4 = lltype.cast_opaque_ptr(llmemory.GCREF, mynode4) # a NODE3
nullptr = lltype.nullptr(llmemory.GCREF.TO)
#nodebox2 = InputArgRef(lltype.cast_opaque_ptr(llmemory.GCREF, node2))
nodesize = cpu.sizeof(NODE, node_vtable)
node_tid = nodesize.get_type_id()
nodesize2 = cpu.sizeof(NODE2, node_vtable2)
nodesize3 = cpu.sizeof(NODE3, node_vtable3)
valuedescr = cpu.fielddescrof(NODE, 'value')
floatdescr = cpu.fielddescrof(NODE, 'floatval')
chardescr = cpu.fielddescrof(NODE, 'charval')
nextdescr = cpu.fielddescrof(NODE, 'next')
nexttupledescr = cpu.fielddescrof(NODE, 'nexttuple')
otherdescr = cpu.fielddescrof(NODE2, 'other')
valuedescr3 = cpu.fielddescrof(NODE3, 'value')
nextdescr3 = cpu.fielddescrof(NODE3, 'next')
assert valuedescr3.is_always_pure()
assert nextdescr3.is_always_pure()
accessor = FieldListAccessor()
accessor.initialize(None, {'inst_field': IR_QUASIIMMUTABLE})
QUASI = lltype.GcStruct('QUASIIMMUT', ('inst_field', lltype.Signed),
('mutate_field', rclass.OBJECTPTR),
hints={'immutable_fields': accessor})
quasisize = cpu.sizeof(QUASI, None)
quasi = lltype.malloc(QUASI, immortal=True)
quasi.inst_field = -4247
quasifielddescr = cpu.fielddescrof(QUASI, 'inst_field')
quasiptr = lltype.cast_opaque_ptr(llmemory.GCREF, quasi)
quasiimmutdescr = QuasiImmutDescr(cpu, quasiptr, quasifielddescr,
cpu.fielddescrof(QUASI, 'mutate_field'))
NODEOBJ = lltype.GcStruct('NODEOBJ', ('parent', OBJECT),
('ref', lltype.Ptr(OBJECT)))
nodeobj = lltype.malloc(NODEOBJ)
nodeobjvalue = lltype.cast_opaque_ptr(llmemory.GCREF, nodeobj)
refdescr = cpu.fielddescrof(NODEOBJ, 'ref')
INTOBJ_NOIMMUT = lltype.GcStruct('INTOBJ_NOIMMUT', ('parent', OBJECT),
('intval', lltype.Signed))
INTOBJ_IMMUT = lltype.GcStruct('INTOBJ_IMMUT', ('parent', OBJECT),
('intval', lltype.Signed),
hints={'immutable': True})
intobj_noimmut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
intobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
noimmut_intval = cpu.fielddescrof(INTOBJ_NOIMMUT, 'intval')
immut_intval = cpu.fielddescrof(INTOBJ_IMMUT, 'intval')
immut = lltype.malloc(INTOBJ_IMMUT, zero=True)
immutaddr = lltype.cast_opaque_ptr(llmemory.GCREF, immut)
noimmut_descr = cpu.sizeof(INTOBJ_NOIMMUT, intobj_noimmut_vtable)
immut_descr = cpu.sizeof(INTOBJ_IMMUT, intobj_immut_vtable)
PTROBJ_IMMUT = lltype.GcStruct('PTROBJ_IMMUT', ('parent', OBJECT),
('ptrval', lltype.Ptr(OBJECT)),
hints={'immutable': True})
ptrobj_immut_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
ptrobj_immut_descr = cpu.sizeof(PTROBJ_IMMUT, ptrobj_immut_vtable)
immut_ptrval = cpu.fielddescrof(PTROBJ_IMMUT, 'ptrval')
arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed))
int32arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.INT))
int16arraydescr = cpu.arraydescrof(lltype.GcArray(rffi.SHORT))
float32arraydescr = cpu.arraydescrof(lltype.GcArray(lltype.SingleFloat))
arraydescr_tid = arraydescr.get_type_id()
array = lltype.malloc(lltype.GcArray(lltype.Signed), 15, zero=True)
arrayref = lltype.cast_opaque_ptr(llmemory.GCREF, array)
array2 = lltype.malloc(lltype.GcArray(lltype.Ptr(S)), 15, zero=True)
array2ref = lltype.cast_opaque_ptr(llmemory.GCREF, array2)
gcarraydescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF))
gcarraydescr_tid = gcarraydescr.get_type_id()
floatarraydescr = cpu.arraydescrof(lltype.GcArray(lltype.Float))
arrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Signed, hints={"immutable": True}))
immutarray = lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(arrayimmutdescr.A, 13, zero=True))
gcarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(llmemory.GCREF, hints={"immutable": True}))
floatarrayimmutdescr = cpu.arraydescrof(lltype.GcArray(lltype.Float, hints={"immutable": True}))
# a GcStruct not inheriting from OBJECT
tpl = lltype.malloc(S, zero=True)
tupleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, tpl)
nodefull2 = lltype.malloc(NODE, zero=True)
nodefull2addr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull2)
ssize = cpu.sizeof(S, None)
adescr = cpu.fielddescrof(S, 'a')
abisdescr = cpu.fielddescrof(S, 'abis')
bdescr = cpu.fielddescrof(S, 'b')
#sbox = BoxPtr(lltype.cast_opaque_ptr(llmemory.GCREF, lltype.malloc(S)))
arraydescr2 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(S)))
T = lltype.GcStruct('TUPLE',
('c', lltype.Signed),
('d', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))
W_ROOT = lltype.GcStruct('W_ROOT', ('parent', OBJECT),
('inst_w_seq', llmemory.GCREF), ('inst_index', lltype.Signed),
('inst_w_list', llmemory.GCREF), ('inst_length', lltype.Signed),
('inst_start', lltype.Signed), ('inst_step', lltype.Signed))
inst_w_seq = cpu.fielddescrof(W_ROOT, 'inst_w_seq')
inst_index = cpu.fielddescrof(W_ROOT, 'inst_index')
inst_length = cpu.fielddescrof(W_ROOT, 'inst_length')
inst_start = cpu.fielddescrof(W_ROOT, 'inst_start')
inst_step = cpu.fielddescrof(W_ROOT, 'inst_step')
inst_w_list = cpu.fielddescrof(W_ROOT, 'inst_w_list')
w_root_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
tsize = cpu.sizeof(T, None)
cdescr = cpu.fielddescrof(T, 'c')
ddescr = cpu.fielddescrof(T, 'd')
arraydescr3 = cpu.arraydescrof(lltype.GcArray(lltype.Ptr(NODE3)))
U = lltype.GcStruct('U',
('parent', OBJECT),
('one', lltype.Ptr(lltype.GcArray(lltype.Ptr(NODE)))))
u_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
u_vtable_adr = llmemory.cast_ptr_to_adr(u_vtable)
SIMPLE = lltype.GcStruct('simple',
('parent', OBJECT),
('value', lltype.Signed))
simplevalue = cpu.fielddescrof(SIMPLE, 'value')
simple_vtable = lltype.malloc(OBJECT_VTABLE, immortal=True)
simpledescr = cpu.sizeof(SIMPLE, simple_vtable)
simple = lltype.malloc(SIMPLE, zero=True)
simpleaddr = lltype.cast_opaque_ptr(llmemory.GCREF, simple)
#usize = cpu.sizeof(U, ...)
onedescr = cpu.fielddescrof(U, 'one')
FUNC = lltype.FuncType([lltype.Signed], lltype.Signed)
plaincalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo.MOST_GENERAL)
elidablecalldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([valuedescr], [], [],
[valuedescr], [], [],
EffectInfo.EF_ELIDABLE_CANNOT_RAISE))
elidable2calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([valuedescr], [], [],
[valuedescr], [], [],
EffectInfo.EF_ELIDABLE_OR_MEMORYERROR))
elidable3calldescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([valuedescr], [], [],
[valuedescr], [], [],
EffectInfo.EF_ELIDABLE_CAN_RAISE))
nonwritedescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], []))
writeadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [adescr], [], []))
writearraydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [adescr], [arraydescr],
[]))
writevalue3descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [valuedescr3], [], []))
readadescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([adescr], [], [], [], [], []))
mayforcevirtdescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([nextdescr], [], [], [], [], [],
EffectInfo.EF_FORCES_VIRTUAL_OR_VIRTUALIZABLE,
can_invalidate=True))
arraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [arraydescr], [], [], [arraydescr], [],
EffectInfo.EF_CANNOT_RAISE,
oopspecindex=EffectInfo.OS_ARRAYCOPY))
raw_malloc_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], [],
EffectInfo.EF_CAN_RAISE,
oopspecindex=EffectInfo.OS_RAW_MALLOC_VARSIZE_CHAR))
raw_free_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], [],
EffectInfo.EF_CANNOT_RAISE,
oopspecindex=EffectInfo.OS_RAW_FREE))
chararray = lltype.GcArray(lltype.Char)
chararraydescr = cpu.arraydescrof(chararray)
u2array = lltype.GcArray(rffi.USHORT)
u2arraydescr = cpu.arraydescrof(u2array)
nodefull = lltype.malloc(NODE2, zero=True)
nodefull.parent.next = lltype.cast_pointer(lltype.Ptr(NODE), nodefull)
nodefull.parent.nexttuple = tpl
nodefulladdr = lltype.cast_opaque_ptr(llmemory.GCREF, nodefull)
# array of structs (complex data)
complexarray = lltype.GcArray(
lltype.Struct("complex",
("real", lltype.Float),
("imag", lltype.Float),
)
)
complexarraydescr = cpu.arraydescrof(complexarray)
complexrealdescr = cpu.interiorfielddescrof(complexarray, "real")
compleximagdescr = cpu.interiorfielddescrof(complexarray, "imag")
complexarraycopydescr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [complexarraydescr], [], [], [complexarraydescr], [],
EffectInfo.EF_CANNOT_RAISE,
oopspecindex=EffectInfo.OS_ARRAYCOPY))
rawarraydescr = cpu.arraydescrof(lltype.Array(lltype.Signed,
hints={'nolength': True}))
rawarraydescr_char = cpu.arraydescrof(lltype.Array(lltype.Char,
hints={'nolength': True}))
rawarraydescr_float = cpu.arraydescrof(lltype.Array(lltype.Float,
hints={'nolength': True}))
fc_array = lltype.GcArray(
lltype.Struct(
"floatchar", ("float", lltype.Float), ("char", lltype.Char)))
fc_array_descr = cpu.arraydescrof(fc_array)
fc_array_floatdescr = cpu.interiorfielddescrof(fc_array, "float")
fc_array_chardescr = cpu.interiorfielddescrof(fc_array, "char")
for _name, _os in [
('strconcatdescr', 'OS_STR_CONCAT'),
('strslicedescr', 'OS_STR_SLICE'),
('strequaldescr', 'OS_STR_EQUAL'),
('streq_slice_checknull_descr', 'OS_STREQ_SLICE_CHECKNULL'),
('streq_slice_nonnull_descr', 'OS_STREQ_SLICE_NONNULL'),
('streq_slice_char_descr', 'OS_STREQ_SLICE_CHAR'),
('streq_nonnull_descr', 'OS_STREQ_NONNULL'),
('streq_nonnull_char_descr', 'OS_STREQ_NONNULL_CHAR'),
('streq_checknull_char_descr', 'OS_STREQ_CHECKNULL_CHAR'),
('streq_lengthok_descr', 'OS_STREQ_LENGTHOK'),
]:
if _name in ('strconcatdescr', 'strslicedescr'):
_extra = EffectInfo.EF_ELIDABLE_OR_MEMORYERROR
else:
_extra = EffectInfo.EF_ELIDABLE_CANNOT_RAISE
_oopspecindex = getattr(EffectInfo, _os)
locals()[_name] = \
cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], [], _extra,
oopspecindex=_oopspecindex))
#
_oopspecindex = getattr(EffectInfo, _os.replace('STR', 'UNI'))
locals()[_name.replace('str', 'unicode')] = \
cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], [], _extra,
oopspecindex=_oopspecindex))
s2u_descr = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT,
EffectInfo([], [], [], [], [], [], EffectInfo.EF_ELIDABLE_CAN_RAISE,
oopspecindex=EffectInfo.OS_STR2UNICODE))
#
class LoopToken(AbstractDescr):
pass
asmdescr = LoopToken() # it can be whatever, it's not a descr though
from rpython.jit.metainterp.virtualref import VirtualRefInfo
class FakeWarmRunnerDesc:
pass
FakeWarmRunnerDesc.cpu = cpu
vrefinfo = VirtualRefInfo(FakeWarmRunnerDesc)
virtualtokendescr = vrefinfo.descr_virtual_token
virtualforceddescr = vrefinfo.descr_forced
FUNC = lltype.FuncType([], lltype.Void)
ei = EffectInfo([], [], [], [], [], [], EffectInfo.EF_CANNOT_RAISE,
can_invalidate=False,
oopspecindex=EffectInfo.OS_JIT_FORCE_VIRTUALIZABLE)
clear_vable = cpu.calldescrof(FUNC, FUNC.ARGS, FUNC.RESULT, ei)
jit_virtual_ref_vtable = vrefinfo.jit_virtual_ref_vtable
jvr_vtable_adr = llmemory.cast_ptr_to_adr(jit_virtual_ref_vtable)
vref_descr = cpu.sizeof(vrefinfo.JIT_VIRTUAL_REF, jit_virtual_ref_vtable)
namespace = locals()
def llhelper_args(f, ARGS, RESULT):
return llhelper(lltype.Ptr(lltype.FuncType(ARGS, RESULT)), f)
def test_various_ops():
from rpython.flowspace.model import SpaceOperation, Constant
X = lltype.Ptr(lltype.GcStruct('X'))
Z = lltype.Ptr(lltype.Struct('Z'))
S = lltype.GcStruct('S', ('x', lltype.Signed), ('y', X), ('z', Z))
v1 = varoftype(lltype.Bool)
v2 = varoftype(lltype.Signed)
f = FinalizerAnalyzer(None)
r = f.analyze(SpaceOperation('cast_int_to_bool', [v2], v1))
assert not r
v1 = varoftype(lltype.Ptr(S))
v2 = varoftype(lltype.Signed)
v3 = varoftype(X)
v4 = varoftype(Z)
assert not f.analyze(
SpaceOperation('bare_setfield', [v1, Constant('x'), v2], None))
assert f.analyze(
SpaceOperation('bare_setfield', [v1, Constant('y'), v3], None))
assert not f.analyze(
SpaceOperation('bare_setfield', [v1, Constant('z'), v4], None))
def test_malloc(self):
S = lltype.GcStruct('S')
def f():
return lltype.malloc(S)
r = self.analyze(f, [])
assert r
def test_raw_free_getfield(self):
S = lltype.Struct('S')
class A(object):
def __init__(self):
self.x = lltype.malloc(S, flavor='raw')
def __del__(self):
if self.x:
lltype.free(self.x, flavor='raw')
self.x = lltype.nullptr(S)
def f():
return A()
r = self.analyze(f, [], A.__del__.im_func)
assert not r
def test_c_call(self):
C = rffi.CArray(lltype.Signed)
c = rffi.llexternal('x', [lltype.Ptr(C)], lltype.Signed)
def g():
p = lltype.malloc(C, 3, flavor='raw')
f(p)
def f(p):
c(rffi.ptradd(p, 0))
lltype.free(p, flavor='raw')
r = self.analyze(g, [], f, backendopt=True)
assert not r
def test_chain(self):
class B(object):
def __init__(self):
self.counter = 1
class A(object):
def __init__(self):
self.x = B()
def __del__(self):
self.x.counter += 1
def f():
A()
r = self.analyze(f, [], A.__del__.im_func)
assert r
def test_must_be_light_finalizer_decorator(self):
S = lltype.GcStruct('S')
@rgc.must_be_light_finalizer
def f():
lltype.malloc(S)
@rgc.must_be_light_finalizer
def g():
pass
self.analyze(g, []) # did not explode
py.test.raises(FinalizerError, self.analyze, f, [])
def expand(s_TYPE, *args_s):
assert isinstance(s_TYPE, annmodel.SomePBC)
assert s_TYPE.is_constant()
return lltype.Ptr(s_TYPE.const)
def getname(T):
try:
return "field:" + T._name
except:
return "field:" + T.__name__
S = lltype.Struct('S', ('s', lltype.Signed), ('char', lltype.Char))
GC_S = lltype.GcStruct('GC_S', ('S', S))
A = lltype.Array(S)
GC_A = lltype.GcArray(S)
S2 = lltype.Struct(
'SPTRS', *[(getname(TYPE), lltype.Ptr(TYPE)) for TYPE in (GC_S, GC_A)])
GC_S2 = lltype.GcStruct('GC_S2', ('S2', S2))
A2 = lltype.Array(S2)
GC_A2 = lltype.GcArray(S2)
l = [(getname(TYPE), lltype.Ptr(TYPE)) for TYPE in (GC_S, GC_A)]
l.append(('vararray', A2))
GC_S3 = lltype.GcStruct('GC_S3', *l)
def test_struct():
for T, c in [(GC_S, 0), (GC_S2, 2), (GC_A, 0), (GC_A2, 0), (GC_S3, 2)]:
assert len(offsets_to_gc_pointers(T)) == c
return self.write_barrier_fn
# a copy of JITFRAM that has 'hdr' field for tests
def jitframe_allocate(frame_info):
frame = lltype.malloc(JITFRAME, frame_info.jfi_frame_depth, zero=True)
frame.jf_frame_info = frame_info
return frame
JITFRAME = lltype.GcStruct(
'JITFRAME',
('hdr', lltype.Signed),
('jf_frame_info', lltype.Ptr(jitframe.JITFRAMEINFO)),
('jf_descr', llmemory.GCREF),
('jf_force_descr', llmemory.GCREF),
('jf_extra_stack_depth', lltype.Signed),
('jf_guard_exc', llmemory.GCREF),
('jf_gcmap', lltype.Ptr(jitframe.GCMAP)),
('jf_gc_trace_state', lltype.Signed),
('jf_frame', lltype.Array(lltype.Signed)),
adtmeths={
'allocate': jitframe_allocate,
},
)
JITFRAMEPTR = lltype.Ptr(JITFRAME)
EPOLL_CTL_ADD = cconfig["EPOLL_CTL_ADD"]
EPOLL_CTL_MOD = cconfig["EPOLL_CTL_MOD"]
EPOLL_CTL_DEL = cconfig["EPOLL_CTL_DEL"]
EPOLL_CLOEXEC = cconfig["EPOLL_CLOEXEC"]
DEF_REGISTER_EVENTMASK = (public_symbols["EPOLLIN"] |
public_symbols["EPOLLOUT"] |
public_symbols["EPOLLPRI"])
epoll_create1 = rffi.llexternal(
"epoll_create1", [rffi.INT], rffi.INT, compilation_info=eci,
save_err=rffi.RFFI_SAVE_ERRNO
)
epoll_ctl = rffi.llexternal(
"epoll_ctl",
[rffi.INT, rffi.INT, rffi.INT, lltype.Ptr(epoll_event)],
rffi.INT,
compilation_info=eci,
save_err=rffi.RFFI_SAVE_ERRNO
)
epoll_wait = rffi.llexternal(
"epoll_wait",
[rffi.INT, rffi.CArrayPtr(epoll_event), rffi.INT, rffi.INT],
rffi.INT,
compilation_info=eci,
save_err=rffi.RFFI_SAVE_ERRNO
)
class W_Epoll(W_Root):
def __init__(self, space, epfd):
def test_save_regs_around_malloc(self):
def check(frame):
x = frame.jf_gcmap
if self.cpu.IS_64_BIT:
assert len(x) == 1
assert (bin(x[0]).count('1') ==
'0b1111100000000000000001111111011110'.count('1'))
else:
assert len(x) == 2
s = bin(x[0]).count('1') + bin(x[1]).count('1')
assert s == 16
# all but two registers + some stuff on stack
self.cpu = self.getcpu(check)
S1 = lltype.GcStruct('S1')
S2 = lltype.GcStruct('S2', ('s0', lltype.Ptr(S1)),
('s1', lltype.Ptr(S1)), ('s2', lltype.Ptr(S1)),
('s3', lltype.Ptr(S1)), ('s4', lltype.Ptr(S1)),
('s5', lltype.Ptr(S1)), ('s6', lltype.Ptr(S1)),
('s7', lltype.Ptr(S1)), ('s8', lltype.Ptr(S1)),
('s9', lltype.Ptr(S1)), ('s10', lltype.Ptr(S1)),
('s11', lltype.Ptr(S1)), ('s12', lltype.Ptr(S1)),
('s13', lltype.Ptr(S1)), ('s14', lltype.Ptr(S1)),
('s15', lltype.Ptr(S1)))
cpu = self.cpu
self.namespace = self.namespace.copy()
for i in range(16):
self.namespace['ds%i' % i] = cpu.fielddescrof(S2, 's%d' % i)
ops = '''
[i0, p0]
p1 = getfield_gc_r(p0, descr=ds0)
p2 = getfield_gc_r(p0, descr=ds1)
p3 = getfield_gc_r(p0, descr=ds2)
p4 = getfield_gc_r(p0, descr=ds3)
p5 = getfield_gc_r(p0, descr=ds4)
p6 = getfield_gc_r(p0, descr=ds5)
p7 = getfield_gc_r(p0, descr=ds6)
p8 = getfield_gc_r(p0, descr=ds7)
p9 = getfield_gc_r(p0, descr=ds8)
p10 = getfield_gc_r(p0, descr=ds9)
p11 = getfield_gc_r(p0, descr=ds10)
p12 = getfield_gc_r(p0, descr=ds11)
p13 = getfield_gc_r(p0, descr=ds12)
p14 = getfield_gc_r(p0, descr=ds13)
p15 = getfield_gc_r(p0, descr=ds14)
p16 = getfield_gc_r(p0, descr=ds15)
#
# now all registers are in use
p17 = call_malloc_nursery(40)
p18 = call_malloc_nursery(40) # overflow
#
guard_true(i0) [p1, p2, p3, p4, p5, p6, \
p7, p8, p9, p10, p11, p12, p13, p14, p15, p16]
'''
s2 = lltype.malloc(S2)
for i in range(16):
setattr(s2, 's%d' % i, lltype.malloc(S1))
s2ref = lltype.cast_opaque_ptr(llmemory.GCREF, s2)
#
self.interpret(ops, [0, s2ref])
gc_ll_descr = cpu.gc_ll_descr
gc_ll_descr.check_nothing_in_nursery()
assert gc_ll_descr.calls == [40]
# check the returned pointers
for i in range(16):
s1ref = self.cpu.get_ref_value(self.deadframe, i)
s1 = lltype.cast_opaque_ptr(lltype.Ptr(S1), s1ref)
assert s1 == getattr(s2, 's%d' % i)
import py
from rpython.rtyper.lltypesystem import lltype, llmemory, llarena
from rpython.memory.gc.incminimark import IncrementalMiniMarkGC, WORD
from test_direct import BaseDirectGCTest
T = lltype.GcForwardReference()
T.become(lltype.GcStruct('pinning_test_struct2', ('someInt', lltype.Signed)))
S = lltype.GcForwardReference()
S.become(
lltype.GcStruct('pinning_test_struct1', ('someInt', lltype.Signed),
('next', lltype.Ptr(T)), ('data', lltype.Ptr(T))))
class PinningGCTest(BaseDirectGCTest):
def setup_method(self, meth):
BaseDirectGCTest.setup_method(self, meth)
max = getattr(meth, 'max_number_of_pinned_objects', 20)
self.gc.max_number_of_pinned_objects = max
def test_pin_can_move(self):
# even a pinned object is considered to be movable. Only the caller
# of pin() knows if it is currently movable or not.
ptr = self.malloc(T)
adr = llmemory.cast_ptr_to_adr(ptr)
assert self.gc.can_move(adr)
assert self.gc.pin(adr)
assert self.gc.can_move(adr)
def test_pin_twice(self):
ptr = self.malloc(T)
