def wrap(cpu, value, in_const_box=False):
if isinstance(lltype.typeOf(value), lltype.Ptr):
if lltype.typeOf(value).TO._gckind == 'gc':
value = lltype.cast_opaque_ptr(llmemory.GCREF, value)
if in_const_box:
return history.ConstPtr(value)
else:
return history.BoxPtr(value)
else:
adr = llmemory.cast_ptr_to_adr(value)
value = cpu.cast_adr_to_int(adr)
# fall through to the end of the function
elif isinstance(lltype.typeOf(value), ootype.OOType):
value = ootype.cast_to_object(value)
if in_const_box:
return history.ConstObj(value)
else:
return history.BoxObj(value)
elif isinstance(value, float):
if in_const_box:
return history.ConstFloat(value)
else:
return history.BoxFloat(value)
else:
value = intmask(value)
if in_const_box:
return history.ConstInt(value)
else:
return history.BoxInt(value)
def __init__(self, warmrunnerdesc):
self.warmrunnerdesc = warmrunnerdesc
self.cpu = warmrunnerdesc.cpu
# we make the low-level type of an RPython class directly
self.JIT_VIRTUAL_REF = lltype.GcStruct(
'JitVirtualRef', ('super', rclass.OBJECT),
('virtual_token', lltype.Signed), ('forced', rclass.OBJECTPTR))
self.jit_virtual_ref_vtable = lltype.malloc(rclass.OBJECT_VTABLE,
zero=True,
flavor='raw',
immortal=True)
self.jit_virtual_ref_vtable.name = rclass.alloc_array_name(
'jit_virtual_ref')
# build some constants
adr = llmemory.cast_ptr_to_adr(self.jit_virtual_ref_vtable)
adr = heaptracker.adr2int(adr)
self.jit_virtual_ref_const_class = history.ConstInt(adr)
fielddescrof = self.cpu.fielddescrof
self.descr_virtual_token = fielddescrof(self.JIT_VIRTUAL_REF,
'virtual_token')
self.descr_forced = fielddescrof(self.JIT_VIRTUAL_REF, 'forced')
#
# record the type JIT_VIRTUAL_REF explicitly in the rtyper, too
if hasattr(self.warmrunnerdesc, 'rtyper'): # <-- for tests
self.warmrunnerdesc.rtyper.set_type_for_typeptr(
self.jit_virtual_ref_vtable, self.JIT_VIRTUAL_REF)
def extract_runtime_data(self, cpu, valuebox, resultlist):
from pypy.jit.metainterp import executor, history, resoperation
for i in range(len(self.items)):
itembox = executor.execute(cpu, resoperation.rop.GETARRAYITEM_GC,
self.arraydescr, valuebox,
history.ConstInt(i))
subspecnode = self.items[i]
subspecnode.extract_runtime_data(cpu, itembox, resultlist)
class MyMIFrame:
jitcode = JitCode("test")
jitcode.setup("\xFF" # illegal instruction
"\x00\x00\x01\x02" # int_add/ii>i
"\x01\x02", # int_return/i
[],
num_regs_i=3, num_regs_r=0, num_regs_f=0)
pc = 1
registers_i = [history.BoxInt(40), history.ConstInt(2), None]
def compile_tmp_callback(cpu,
jitdriver_sd,
greenboxes,
redargtypes,
memory_manager=None):
"""Make a LoopToken that corresponds to assembler code that just
calls back the interpreter. Used temporarily: a fully compiled
version of the code may end up replacing it.
"""
jitcell_token = make_jitcell_token(jitdriver_sd)
nb_red_args = jitdriver_sd.num_red_args
assert len(redargtypes) == nb_red_args
inputargs = []
for kind in redargtypes:
if kind == history.INT: box = BoxInt()
elif kind == history.REF: box = BoxPtr()
elif kind == history.FLOAT: box = BoxFloat()
else: raise AssertionError
inputargs.append(box)
k = jitdriver_sd.portal_runner_adr
funcbox = history.ConstInt(heaptracker.adr2int(k))
callargs = [funcbox] + greenboxes + inputargs
#
result_type = jitdriver_sd.result_type
if result_type == history.INT:
result = BoxInt()
elif result_type == history.REF:
result = BoxPtr()
elif result_type == history.FLOAT:
result = BoxFloat()
elif result_type == history.VOID:
result = None
else:
assert 0, "bad result_type"
if result is not None:
finishargs = [result]
else:
finishargs = []
#
jd = jitdriver_sd
faildescr = PropagateExceptionDescr()
operations = [
ResOperation(rop.CALL, callargs, result, descr=jd.portal_calldescr),
ResOperation(rop.GUARD_NO_EXCEPTION, [], None, descr=faildescr),
ResOperation(rop.FINISH, finishargs, None, descr=jd.portal_finishtoken)
]
operations[1].setfailargs([])
operations = get_deep_immutable_oplist(operations)
cpu.compile_loop(inputargs, operations, jitcell_token, log=False)
if memory_manager is not None: # for tests
memory_manager.keep_loop_alive(jitcell_token)
return jitcell_token
def wrap(cpu, value, in_const_box=False):
if isinstance(lltype.typeOf(value), lltype.Ptr):
if lltype.typeOf(value).TO._gckind == 'gc':
value = lltype.cast_opaque_ptr(llmemory.GCREF, value)
if in_const_box:
return history.ConstPtr(value)
else:
return history.BoxPtr(value)
else:
adr = llmemory.cast_ptr_to_adr(value)
value = heaptracker.adr2int(adr)
# fall through to the end of the function
elif isinstance(lltype.typeOf(value), ootype.OOType):
value = ootype.cast_to_object(value)
if in_const_box:
return history.ConstObj(value)
else:
return history.BoxObj(value)
elif (isinstance(value, float)
or longlong.is_longlong(lltype.typeOf(value))):
if isinstance(value, float):
value = longlong.getfloatstorage(value)
else:
value = rffi.cast(lltype.SignedLongLong, value)
if in_const_box:
return history.ConstFloat(value)
else:
return history.BoxFloat(value)
elif isinstance(value, str) or isinstance(value, unicode):
assert len(value) == 1 # must be a character
value = ord(value)
elif lltype.typeOf(value) is lltype.SingleFloat:
value = longlong.singlefloat2int(value)
else:
value = intmask(value)
if in_const_box:
return history.ConstInt(value)
else:
return history.BoxInt(value)
def get_exception_box(self, etype):
return history.ConstInt(etype)
def cls_of_box(self, cpu, box):
obj = box.getref(lltype.Ptr(rclass.OBJECT))
cls = llmemory.cast_ptr_to_adr(obj.typeptr)
return history.ConstInt(cpu.cast_adr_to_int(cls))