def _setup_frame_realloc(self, translate_support_code):
FUNC_TP = lltype.Ptr(
lltype.FuncType([llmemory.GCREF, lltype.Signed], llmemory.GCREF))
base_ofs = self.get_baseofs_of_frame_field()
def realloc_frame(frame, size):
try:
if not we_are_translated():
assert not self._exception_emulator[0]
frame = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, frame)
if size > frame.jf_frame_info.jfi_frame_depth:
# update the frame_info size, which is for whatever reason
# not up to date
frame.jf_frame_info.update_frame_depth(base_ofs, size)
new_frame = jitframe.JITFRAME.allocate(frame.jf_frame_info)
frame.jf_forward = new_frame
i = 0
while i < len(frame.jf_frame):
new_frame.jf_frame[i] = frame.jf_frame[i]
frame.jf_frame[i] = 0
i += 1
new_frame.jf_savedata = frame.jf_savedata
new_frame.jf_guard_exc = frame.jf_guard_exc
# all other fields are empty
llop.gc_writebarrier(lltype.Void, new_frame)
return lltype.cast_opaque_ptr(llmemory.GCREF, new_frame)
except Exception as e:
print "Unhandled exception", e, "in realloc_frame"
return lltype.nullptr(llmemory.GCREF.TO)
def realloc_frame_crash(frame, size):
print "frame", frame, "size", size
return lltype.nullptr(llmemory.GCREF.TO)
if not translate_support_code:
fptr = llhelper(FUNC_TP, realloc_frame)
else:
FUNC = FUNC_TP.TO
args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
s_result = lltype_to_annotation(FUNC.RESULT)
mixlevelann = MixLevelHelperAnnotator(self.rtyper)
graph = mixlevelann.getgraph(realloc_frame, args_s, s_result)
fptr = mixlevelann.graph2delayed(graph, FUNC)
mixlevelann.finish()
self.realloc_frame = heaptracker.adr2int(
llmemory.cast_ptr_to_adr(fptr))
if not translate_support_code:
fptr = llhelper(FUNC_TP, realloc_frame_crash)
else:
FUNC = FUNC_TP.TO
args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
s_result = lltype_to_annotation(FUNC.RESULT)
mixlevelann = MixLevelHelperAnnotator(self.rtyper)
graph = mixlevelann.getgraph(realloc_frame_crash, args_s, s_result)
fptr = mixlevelann.graph2delayed(graph, FUNC)
mixlevelann.finish()
self.realloc_frame_crash = heaptracker.adr2int(
llmemory.cast_ptr_to_adr(fptr))
def cast_to_int(x):
TP = lltype.typeOf(x)
if isinstance(TP, lltype.Ptr):
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(x))
if TP == llmemory.Address:
return heaptracker.adr2int(x)
if TP is lltype.SingleFloat:
return longlong.singlefloat2int(x)
return lltype.cast_primitive(lltype.Signed, x)
def cast_to_int(x):
TP = lltype.typeOf(x)
if isinstance(TP, lltype.Ptr):
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(x))
if TP == llmemory.Address:
return heaptracker.adr2int(x)
if TP is lltype.SingleFloat:
return longlong.singlefloat2int(x)
return lltype.cast_primitive(lltype.Signed, x)
def _setup_frame_realloc(self, translate_support_code):
FUNC_TP = lltype.Ptr(lltype.FuncType([llmemory.GCREF, lltype.Signed],
llmemory.GCREF))
base_ofs = self.get_baseofs_of_frame_field()
def realloc_frame(frame, size):
try:
if not we_are_translated():
assert not self._exception_emulator[0]
frame = lltype.cast_opaque_ptr(jitframe.JITFRAMEPTR, frame)
if size > frame.jf_frame_info.jfi_frame_depth:
# update the frame_info size, which is for whatever reason
# not up to date
frame.jf_frame_info.update_frame_depth(base_ofs, size)
new_frame = jitframe.JITFRAME.allocate(frame.jf_frame_info)
frame.jf_forward = new_frame
i = 0
while i < len(frame.jf_frame):
new_frame.jf_frame[i] = frame.jf_frame[i]
frame.jf_frame[i] = 0
i += 1
new_frame.jf_savedata = frame.jf_savedata
new_frame.jf_guard_exc = frame.jf_guard_exc
# all other fields are empty
llop.gc_writebarrier(lltype.Void, new_frame)
return lltype.cast_opaque_ptr(llmemory.GCREF, new_frame)
except Exception as e:
print "Unhandled exception", e, "in realloc_frame"
return lltype.nullptr(llmemory.GCREF.TO)
def realloc_frame_crash(frame, size):
print "frame", frame, "size", size
return lltype.nullptr(llmemory.GCREF.TO)
if not translate_support_code:
fptr = llhelper(FUNC_TP, realloc_frame)
else:
FUNC = FUNC_TP.TO
args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
s_result = lltype_to_annotation(FUNC.RESULT)
mixlevelann = MixLevelHelperAnnotator(self.rtyper)
graph = mixlevelann.getgraph(realloc_frame, args_s, s_result)
fptr = mixlevelann.graph2delayed(graph, FUNC)
mixlevelann.finish()
self.realloc_frame = heaptracker.adr2int(llmemory.cast_ptr_to_adr(fptr))
if not translate_support_code:
fptr = llhelper(FUNC_TP, realloc_frame_crash)
else:
FUNC = FUNC_TP.TO
args_s = [lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
s_result = lltype_to_annotation(FUNC.RESULT)
mixlevelann = MixLevelHelperAnnotator(self.rtyper)
graph = mixlevelann.getgraph(realloc_frame_crash, args_s, s_result)
fptr = mixlevelann.graph2delayed(graph, FUNC)
mixlevelann.finish()
self.realloc_frame_crash = heaptracker.adr2int(llmemory.cast_ptr_to_adr(fptr))
def test_cast_adr_to_int_and_back():
X = lltype.Struct('X', ('foo', lltype.Signed))
x = lltype.malloc(X, immortal=True)
x.foo = 42
a = llmemory.cast_ptr_to_adr(x)
i = heaptracker.adr2int(a)
assert lltype.typeOf(i) is lltype.Signed
a2 = heaptracker.int2adr(i)
assert llmemory.cast_adr_to_ptr(a2, lltype.Ptr(X)) == x
assert heaptracker.adr2int(llmemory.NULL) == 0
assert heaptracker.int2adr(0) == llmemory.NULL
def test_cast_adr_to_int_and_back():
X = lltype.Struct('X', ('foo', lltype.Signed))
x = lltype.malloc(X, immortal=True)
x.foo = 42
a = llmemory.cast_ptr_to_adr(x)
i = heaptracker.adr2int(a)
assert lltype.typeOf(i) is lltype.Signed
a2 = heaptracker.int2adr(i)
assert llmemory.cast_adr_to_ptr(a2, lltype.Ptr(X)) == x
assert heaptracker.adr2int(llmemory.NULL) == 0
assert heaptracker.int2adr(0) == llmemory.NULL
def handle_call_assembler(self, op):
descrs = self.gc_ll_descr.getframedescrs(self.cpu)
loop_token = op.getdescr()
assert isinstance(loop_token, history.JitCellToken)
jfi = loop_token.compiled_loop_token.frame_info
llfi = heaptracker.adr2int(llmemory.cast_ptr_to_adr(jfi))
frame = self.gen_malloc_frame(llfi)
self.emit_setfield(frame,
history.ConstInt(llfi),
descr=descrs.jf_frame_info)
arglist = op.getarglist()
index_list = loop_token.compiled_loop_token._ll_initial_locs
for i, arg in enumerate(arglist):
descr = self.cpu.getarraydescr_for_frame(arg.type)
assert self.cpu.JITFRAME_FIXED_SIZE & 1 == 0
_, itemsize, _ = self.cpu.unpack_arraydescr_size(descr)
array_offset = index_list[i] # index, already measured in bytes
# emit GC_STORE
_, basesize, _ = unpack_arraydescr(descr)
offset = basesize + array_offset
args = [frame, ConstInt(offset), arg, ConstInt(itemsize)]
self.emit_op(ResOperation(rop.GC_STORE, args))
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
args = [frame]
if jd and jd.index_of_virtualizable >= 0:
args = [frame, arglist[jd.index_of_virtualizable]]
else:
args = [frame]
call_asm = ResOperation(op.getopnum(), args, descr=op.getdescr())
self.replace_op_with(self.get_box_replacement(op), call_asm)
self.emit_op(call_asm)
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 resoperation.InputArgRef(value)
else:
adr = llmemory.cast_ptr_to_adr(value)
value = heaptracker.adr2int(adr)
# fall through to the end of the function
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 resoperation.InputArgFloat(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 resoperation.InputArgInt(value)
def handle_call_assembler(self, op):
descrs = self.gc_ll_descr.getframedescrs(self.cpu)
loop_token = op.getdescr()
assert isinstance(loop_token, history.JitCellToken)
jfi = loop_token.compiled_loop_token.frame_info
llfi = heaptracker.adr2int(llmemory.cast_ptr_to_adr(jfi))
size_box = history.BoxInt()
frame = history.BoxPtr()
self.gen_malloc_frame(llfi, frame, size_box)
op2 = ResOperation(rop.SETFIELD_GC,
[frame, history.ConstInt(llfi)],
None,
descr=descrs.jf_frame_info)
self.newops.append(op2)
arglist = op.getarglist()
index_list = loop_token.compiled_loop_token._ll_initial_locs
for i, arg in enumerate(arglist):
descr = self.cpu.getarraydescr_for_frame(arg.type)
assert self.cpu.JITFRAME_FIXED_SIZE & 1 == 0
_, itemsize, _ = self.cpu.unpack_arraydescr_size(descr)
index = index_list[i] // itemsize # index is in bytes
self.newops.append(
ResOperation(rop.SETARRAYITEM_GC,
[frame, ConstInt(index), arg], None, descr))
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
args = [frame]
if jd and jd.index_of_virtualizable >= 0:
args = [frame, arglist[jd.index_of_virtualizable]]
else:
args = [frame]
self.newops.append(
ResOperation(rop.CALL_ASSEMBLER, args, op.result, op.getdescr()))
def handle_call_assembler(self, op):
descrs = self.gc_ll_descr.getframedescrs(self.cpu)
loop_token = op.getdescr()
assert isinstance(loop_token, history.JitCellToken)
jfi = loop_token.compiled_loop_token.frame_info
llfi = heaptracker.adr2int(llmemory.cast_ptr_to_adr(jfi))
size_box = history.BoxInt()
frame = history.BoxPtr()
self.gen_malloc_frame(llfi, frame, size_box)
op2 = ResOperation(rop.SETFIELD_GC, [frame, history.ConstInt(llfi)],
None, descr=descrs.jf_frame_info)
self.newops.append(op2)
arglist = op.getarglist()
index_list = loop_token.compiled_loop_token._ll_initial_locs
for i, arg in enumerate(arglist):
descr = self.cpu.getarraydescr_for_frame(arg.type)
assert self.cpu.JITFRAME_FIXED_SIZE & 1 == 0
_, itemsize, _ = self.cpu.unpack_arraydescr_size(descr)
index = index_list[i] // itemsize # index is in bytes
self.newops.append(ResOperation(rop.SETARRAYITEM_GC,
[frame, ConstInt(index),
arg],
None, descr))
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
args = [frame]
if jd and jd.index_of_virtualizable >= 0:
args = [frame, arglist[jd.index_of_virtualizable]]
else:
args = [frame]
self.newops.append(ResOperation(rop.CALL_ASSEMBLER, args,
op.result, op.getdescr()))
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', llmemory.GCREF),
('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 __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', llmemory.GCREF), ('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 test_assemble_cast_consts():
ssarepr = SSARepr("test")
S = lltype.GcStruct('S')
s = lltype.malloc(S)
F = lltype.FuncType([], lltype.Signed)
f = lltype.functionptr(F, 'f')
ssarepr.insns = [
('int_return', Constant('X', lltype.Char)),
('int_return', Constant(unichr(0x1234), lltype.UniChar)),
('int_return', Constant(f, lltype.Ptr(F))),
('ref_return', Constant(s, lltype.Ptr(S))),
]
assembler = Assembler()
jitcode = assembler.assemble(ssarepr)
assert jitcode.code == ("\x00\x58"
"\x01\xFF"
"\x01\xFE"
"\x02\xFF")
assert assembler.insns == {'int_return/c': 0,
'int_return/i': 1,
'ref_return/r': 2}
f_int = heaptracker.adr2int(llmemory.cast_ptr_to_adr(f))
assert jitcode.constants_i == [0x1234, f_int]
s_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, s)
assert jitcode.constants_r == [s_gcref]
def handle_call_assembler(self, op):
descrs = self.gc_ll_descr.getframedescrs(self.cpu)
loop_token = op.getdescr()
assert isinstance(loop_token, history.JitCellToken)
jfi = loop_token.compiled_loop_token.frame_info
llfi = heaptracker.adr2int(llmemory.cast_ptr_to_adr(jfi))
frame = self.gen_malloc_frame(llfi)
op2 = ResOperation(rop.SETFIELD_GC, [frame, history.ConstInt(llfi)],
descr=descrs.jf_frame_info)
self.emit_op(op2)
arglist = op.getarglist()
index_list = loop_token.compiled_loop_token._ll_initial_locs
for i, arg in enumerate(arglist):
descr = self.cpu.getarraydescr_for_frame(arg.type)
assert self.cpu.JITFRAME_FIXED_SIZE & 1 == 0
_, itemsize, _ = self.cpu.unpack_arraydescr_size(descr)
index = index_list[i] // itemsize # index is in bytes
self.emit_op(ResOperation(rop.SETARRAYITEM_GC,
[frame, ConstInt(index),
arg],
descr))
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
args = [frame]
if jd and jd.index_of_virtualizable >= 0:
args = [frame, arglist[jd.index_of_virtualizable]]
else:
args = [frame]
call_asm = ResOperation(op.getopnum(), args,
op.getdescr())
self.replace_op_with(self.get_box_replacement(op), call_asm)
self.emit_op(call_asm)
def handle_call_assembler(self, op):
descrs = self.gc_ll_descr.getframedescrs(self.cpu)
loop_token = op.getdescr()
assert isinstance(loop_token, history.JitCellToken)
jfi = loop_token.compiled_loop_token.frame_info
llfi = heaptracker.adr2int(llmemory.cast_ptr_to_adr(jfi))
frame = self.gen_malloc_frame(llfi)
self.emit_setfield(frame, history.ConstInt(llfi),
descr=descrs.jf_frame_info)
arglist = op.getarglist()
index_list = loop_token.compiled_loop_token._ll_initial_locs
for i, arg in enumerate(arglist):
descr = self.cpu.getarraydescr_for_frame(arg.type)
assert self.cpu.JITFRAME_FIXED_SIZE & 1 == 0
_, itemsize, _ = self.cpu.unpack_arraydescr_size(descr)
array_offset = index_list[i] # index, already measured in bytes
# emit GC_STORE
_, basesize, _ = unpack_arraydescr(descr)
offset = basesize + array_offset
args = [frame, ConstInt(offset), arg, ConstInt(itemsize)]
self.emit_op(ResOperation(rop.GC_STORE, args))
descr = op.getdescr()
assert isinstance(descr, JitCellToken)
jd = descr.outermost_jitdriver_sd
args = [frame]
if jd and jd.index_of_virtualizable >= 0:
args = [frame, arglist[jd.index_of_virtualizable]]
else:
args = [frame]
call_asm = ResOperation(op.getopnum(), args, descr=op.getdescr())
self.replace_op_with(self.get_box_replacement(op), call_asm)
self.emit_op(call_asm)
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(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 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 = jitdriver_sd.propagate_exc_descr
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 unspecialize_value(value):
"""Casts 'value' to a Signed, a GCREF or a FLOATSTORAGE."""
if isinstance(lltype.typeOf(value), lltype.Ptr):
if lltype.typeOf(value).TO._gckind == 'gc':
return lltype.cast_opaque_ptr(llmemory.GCREF, value)
else:
adr = llmemory.cast_ptr_to_adr(value)
return heaptracker.adr2int(adr)
elif isinstance(value, float):
return longlong.getfloatstorage(value)
else:
return lltype.cast_primitive(lltype.Signed, value)
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 = jitdriver_sd.propagate_exc_descr
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 unspecialize_value(value):
"""Casts 'value' to a Signed, a GCREF or a FLOATSTORAGE."""
if isinstance(lltype.typeOf(value), lltype.Ptr):
if lltype.typeOf(value).TO._gckind == 'gc':
return lltype.cast_opaque_ptr(llmemory.GCREF, value)
else:
adr = llmemory.cast_ptr_to_adr(value)
return heaptracker.adr2int(adr)
elif isinstance(value, float):
return longlong.getfloatstorage(value)
else:
return lltype.cast_primitive(lltype.Signed, value)
def test_malloc_new_with_vtable():
vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
S = lltype.GcStruct("S", ("parent", rclass.OBJECT))
heaptracker.set_testing_vtable_for_gcstruct(S, vtable, "S")
v = varoftype(lltype.Ptr(S))
op = SpaceOperation("malloc", [Constant(S, lltype.Void), Constant({"flavor": "gc"}, lltype.Void)], v)
cpu = FakeCPU()
op1 = Transformer(cpu).rewrite_operation(op)
assert op1.opname == "new_with_vtable"
assert op1.args == [("sizedescr", S)]
# assert heaptracker.descr2vtable(cpu, op1.args[0]) == vtable [type check]
vtable_int = heaptracker.adr2int(llmemory.cast_ptr_to_adr(vtable))
assert heaptracker.vtable2descr(cpu, vtable_int) == op1.args[0]
def test_guard_class(self):
loop = """
[p0]
guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
es, loop, preamble = self.optimize(loop)
p0 = preamble.inputargs[0]
expected_class = heaptracker.adr2int(self.node_vtable_adr)
assert expected_class == es.exported_infos[p0]._known_class.getint()
vs = es.virtual_state
assert vs.state[0].level == LEVEL_KNOWNCLASS
assert vs.state[0].known_class.getint() == expected_class
def test_guard_class(self):
loop = """
[p0]
guard_class(p0, ConstClass(node_vtable)) []
jump(p0)
"""
es, loop, preamble = self.optimize(loop)
p0 = preamble.inputargs[0]
expected_class = heaptracker.adr2int(self.node_vtable_adr)
assert expected_class == es.exported_infos[p0]._known_class.getint()
vs = es.virtual_state
assert vs.state[0].level == LEVEL_KNOWNCLASS
assert vs.state[0].known_class.getint() == expected_class
def emit_const(self, const, kind, allow_short=False):
value = const.value
if kind == 'int':
TYPE = const.concretetype
if isinstance(TYPE, lltype.Ptr):
assert TYPE.TO._gckind == 'raw'
self.see_raw_object(value)
value = llmemory.cast_ptr_to_adr(value)
TYPE = llmemory.Address
if TYPE == llmemory.Address:
value = heaptracker.adr2int(value)
if TYPE is lltype.SingleFloat:
value = longlong.singlefloat2int(value)
if not isinstance(value,
(llmemory.AddressAsInt, ComputedIntSymbolic)):
value = lltype.cast_primitive(lltype.Signed, value)
if type(value) is r_int:
value = int(value)
if allow_short:
try:
short_num = -128 <= value <= 127
except TypeError: # "Symbolics cannot be compared!"
short_num = False
if short_num:
# emit the constant as a small integer
self.code.append(chr(value & 0xFF))
return True
constants = self.constants_i
elif kind == 'ref':
value = lltype.cast_opaque_ptr(llmemory.GCREF, value)
constants = self.constants_r
elif kind == 'float':
if const.concretetype == lltype.Float:
value = longlong.getfloatstorage(value)
else:
assert longlong.is_longlong(const.concretetype)
value = rffi.cast(lltype.SignedLongLong, value)
constants = self.constants_f
else:
raise AssemblerError('unimplemented %r in %r' %
(const, self.ssareprname))
key = (kind, Constant(value))
if key not in self.constants_dict:
constants.append(value)
val = 256 - len(constants)
assert val >= 0, "too many constants"
self.constants_dict[key] = val
# emit the constant normally, as one byte that is an index in the
# list of constants
self.code.append(chr(self.constants_dict[key]))
return False
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)
#
# record the target of a temporary callback to the interpreter
jl.tmp_callback(jitcell_token)
#
nb_red_args = jitdriver_sd.num_red_args
assert len(redargtypes) == nb_red_args
inputargs = []
for kind in redargtypes:
if kind == history.INT:
box = InputArgInt()
elif kind == history.REF:
box = InputArgRef()
elif kind == history.FLOAT:
box = InputArgFloat()
else:
raise AssertionError
inputargs.append(box)
k = jitdriver_sd.portal_runner_adr
funcbox = history.ConstInt(heaptracker.adr2int(k))
callargs = [funcbox] + greenboxes + inputargs
#
jd = jitdriver_sd
opnum = OpHelpers.call_for_descr(jd.portal_calldescr)
call_op = ResOperation(opnum, callargs, descr=jd.portal_calldescr)
if call_op.type != 'v' is not None:
finishargs = [call_op]
else:
finishargs = []
#
faildescr = jitdriver_sd.propagate_exc_descr
operations = [
call_op,
ResOperation(rop.GUARD_NO_EXCEPTION, [], descr=faildescr),
ResOperation(rop.FINISH, finishargs, 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 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)
#
# record the target of a temporary callback to the interpreter
jl.tmp_callback(jitcell_token)
#
nb_red_args = jitdriver_sd.num_red_args
assert len(redargtypes) == nb_red_args
inputargs = []
for kind in redargtypes:
if kind == history.INT:
box = InputArgInt()
elif kind == history.REF:
box = InputArgRef()
elif kind == history.FLOAT:
box = InputArgFloat()
else:
raise AssertionError
inputargs.append(box)
k = jitdriver_sd.portal_runner_adr
funcbox = history.ConstInt(heaptracker.adr2int(k))
callargs = [funcbox] + greenboxes + inputargs
#
jd = jitdriver_sd
opnum = OpHelpers.call_for_descr(jd.portal_calldescr)
call_op = ResOperation(opnum, callargs, descr=jd.portal_calldescr)
if call_op.type != 'v' is not None:
finishargs = [call_op]
else:
finishargs = []
#
faildescr = jitdriver_sd.propagate_exc_descr
operations = [
call_op,
ResOperation(rop.GUARD_NO_EXCEPTION, [], descr=faildescr),
ResOperation(rop.FINISH, finishargs, 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 emit_const(self, const, kind, allow_short=False):
value = const.value
if kind == 'int':
TYPE = const.concretetype
if isinstance(TYPE, lltype.Ptr):
assert TYPE.TO._gckind == 'raw'
self.see_raw_object(value)
value = llmemory.cast_ptr_to_adr(value)
TYPE = llmemory.Address
if TYPE == llmemory.Address:
value = heaptracker.adr2int(value)
if TYPE is lltype.SingleFloat:
value = longlong.singlefloat2int(value)
if not isinstance(value, (llmemory.AddressAsInt,
ComputedIntSymbolic)):
value = lltype.cast_primitive(lltype.Signed, value)
if allow_short:
try:
short_num = -128 <= value <= 127
except TypeError: # "Symbolics cannot be compared!"
short_num = False
if short_num:
# emit the constant as a small integer
self.code.append(chr(value & 0xFF))
return True
constants = self.constants_i
elif kind == 'ref':
value = lltype.cast_opaque_ptr(llmemory.GCREF, value)
constants = self.constants_r
elif kind == 'float':
if const.concretetype == lltype.Float:
value = longlong.getfloatstorage(value)
else:
assert longlong.is_longlong(const.concretetype)
value = rffi.cast(lltype.SignedLongLong, value)
constants = self.constants_f
else:
raise AssemblerError('unimplemented %r in %r' %
(const, self.ssareprname))
key = (kind, Constant(value))
if key not in self.constants_dict:
constants.append(value)
val = 256 - len(constants)
assert val >= 0, "too many constants"
self.constants_dict[key] = val
# emit the constant normally, as one byte that is an index in the
# list of constants
self.code.append(chr(self.constants_dict[key]))
return False
def getexception(cpu, count):
xtp = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
xtp.subclassrange_min = 1
xtp.subclassrange_max = 3
X = lltype.GcStruct('X', ('parent', rclass.OBJECT),
hints={'vtable': xtp._obj})
xptr = lltype.malloc(X)
vtableptr = X._hints['vtable']._as_ptr()
def f(*args):
raise LLException(vtableptr, xptr)
fptr, funcdescr = getllhelper(cpu, f, [lltype.Signed] * count, lltype.Void)
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(vtableptr)), fptr, funcdescr
def _new(x):
"NOT_RPYTHON"
T = lltype.typeOf(x)
kind = getkind(T)
if kind == "int":
if isinstance(T, lltype.Ptr):
intval = heaptracker.adr2int(llmemory.cast_ptr_to_adr(x))
else:
intval = lltype.cast_primitive(lltype.Signed, x)
return ConstInt(intval)
elif kind == "ref":
return cpu.ts.new_ConstRef(x)
elif kind == "float":
return ConstFloat(longlong.getfloatstorage(x))
else:
raise NotImplementedError(kind)
def _new(x):
"NOT_RPYTHON"
T = lltype.typeOf(x)
kind = getkind(T)
if kind == "int":
if isinstance(T, lltype.Ptr):
intval = heaptracker.adr2int(llmemory.cast_ptr_to_adr(x))
else:
intval = lltype.cast_primitive(lltype.Signed, x)
return ConstInt(intval)
elif kind == "ref":
return cpu.ts.new_ConstRef(x)
elif kind == "float":
return ConstFloat(longlong.getfloatstorage(x))
else:
raise NotImplementedError(kind)
def getexception(cpu, count):
xtp = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
xtp.subclassrange_min = 1
xtp.subclassrange_max = 3
X = lltype.GcStruct('X', ('parent', rclass.OBJECT),
hints={'vtable': xtp._obj})
xptr = lltype.malloc(X)
vtableptr = X._hints['vtable']._as_ptr()
def f(*args):
raise LLException(vtableptr, xptr)
fptr, funcdescr = getllhelper(cpu, f, [lltype.Signed] * count, lltype.Void)
return heaptracker.adr2int(
llmemory.cast_ptr_to_adr(vtableptr)), fptr, funcdescr
def cast_from_int(TYPE, x):
if isinstance(TYPE, lltype.Ptr):
if isinstance(x, (int, long, llmemory.AddressAsInt)):
x = llmemory.cast_int_to_adr(x)
#if repr(x.ptr).startswith('<* <C object '): # pom pom pom
# # assume that we want a "C-style" cast, without typechecking the value
return rffi.cast(TYPE, x)
#return llmemory.cast_adr_to_ptr(x, TYPE)
elif TYPE == llmemory.Address:
if isinstance(x, (int, long, llmemory.AddressAsInt)):
x = llmemory.cast_int_to_adr(x)
assert lltype.typeOf(x) == llmemory.Address
return x
elif TYPE is lltype.SingleFloat:
assert lltype.typeOf(x) is lltype.Signed
return longlong.int2singlefloat(x)
else:
if lltype.typeOf(x) == llmemory.Address:
x = heaptracker.adr2int(x)
return lltype.cast_primitive(TYPE, x)
def cast_from_int(TYPE, x):
if isinstance(TYPE, lltype.Ptr):
if isinstance(x, (int, long, llmemory.AddressAsInt)):
x = llmemory.cast_int_to_adr(x)
try: # pom pom pom
return llmemory.cast_adr_to_ptr(x, TYPE)
except Exception:
# assume that we want a "C-style" cast, without typechecking the value
return rffi.cast(TYPE, x)
elif TYPE == llmemory.Address:
if isinstance(x, (int, long, llmemory.AddressAsInt)):
x = llmemory.cast_int_to_adr(x)
assert lltype.typeOf(x) == llmemory.Address
return x
elif TYPE is lltype.SingleFloat:
assert lltype.typeOf(x) is lltype.Signed
return longlong.int2singlefloat(x)
else:
if lltype.typeOf(x) == llmemory.Address:
x = heaptracker.adr2int(x)
return lltype.cast_primitive(TYPE, x)
def test_assemble_cast_consts():
ssarepr = SSARepr("test")
S = lltype.GcStruct('S')
s = lltype.malloc(S)
F = lltype.FuncType([], lltype.Signed)
f = lltype.functionptr(F, 'f')
ssarepr.insns = [
('int_return', Constant('X', lltype.Char)),
('int_return', Constant(unichr(0x1234), lltype.UniChar)),
('int_return', Constant(f, lltype.Ptr(F))),
('ref_return', Constant(s, lltype.Ptr(S))),
]
assembler = Assembler()
jitcode = assembler.assemble(ssarepr)
assert jitcode.code == ("\x00\x58" "\x01\xFF" "\x01\xFE" "\x02\xFF")
assert assembler.insns == {
'int_return/c': 0,
'int_return/i': 1,
'ref_return/r': 2
}
f_int = heaptracker.adr2int(llmemory.cast_ptr_to_adr(f))
assert jitcode.constants_i == [0x1234, f_int]
s_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, s)
assert jitcode.constants_r == [s_gcref]
def get_malloc_fn_addr(self, funcname):
ll_func = self.get_malloc_fn(funcname)
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(ll_func))
def ConstAddr(addr, cpu):
return ConstInt(heaptracker.adr2int(addr))
def get_vtable(self):
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(self.vtable))
def get_fnaddr_as_int(self):
return heaptracker.adr2int(self.fnaddr)
def ptr_to_int(obj):
from rpython.jit.codewriter.heaptracker import adr2int
from rpython.rtyper.lltypesystem import llmemory
return adr2int(llmemory.cast_ptr_to_adr(obj))
def cls_of_box(self, box):
obj = box.getref(lltype.Ptr(rclass.OBJECT))
cls = llmemory.cast_ptr_to_adr(obj.typeptr)
return history.ConstInt(heaptracker.adr2int(cls))
def cls_of_box(self, box):
PTR = lltype.Ptr(rclass.OBJECT)
obj = lltype.cast_opaque_ptr(PTR, box.getref_base())
cls = llmemory.cast_ptr_to_adr(obj.typeptr)
return history.ConstInt(heaptracker.adr2int(cls))
def pos_exc_value():
addr = llop.get_exc_value_addr(llmemory.Address)
return heaptracker.adr2int(addr)
def bh_classof(self, struct):
struct = lltype.cast_opaque_ptr(rclass.OBJECTPTR, struct)
result_adr = llmemory.cast_ptr_to_adr(struct.typeptr)
return heaptracker.adr2int(result_adr)
def get_vtable(self):
assert self._vtable is not None
if self._vtable is Ellipsis:
self._vtable = heaptracker.get_vtable_for_gcstruct(self._runner,
self.S)
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(self._vtable))
def get_vtable(self):
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(self.vtable))
def bh_classof(self, struct):
struct = lltype.cast_opaque_ptr(rclass.OBJECTPTR, struct)
result_adr = llmemory.cast_ptr_to_adr(struct.typeptr)
return heaptracker.adr2int(result_adr)
def pos_exc_value():
addr = llop.get_exc_value_addr(llmemory.Address)
return heaptracker.adr2int(addr)
def pos_exception():
addr = llop.get_exception_addr(llmemory.Address)
return heaptracker.adr2int(addr)
def cast_vtable_to_hashable(self, cpu, ptr):
adr = llmemory.cast_ptr_to_adr(ptr)
return heaptracker.adr2int(adr)
def get_funcbox(cls, cpu, func_ptr):
addr = llmemory.cast_ptr_to_adr(func_ptr)
return ConstInt(heaptracker.adr2int(addr))
def ConstAddr(addr, cpu):
return ConstInt(heaptracker.adr2int(addr))
def pos_exception():
addr = llop.get_exception_addr(llmemory.Address)
return heaptracker.adr2int(addr)
def get_funcbox(cls, cpu, func_ptr):
addr = llmemory.cast_ptr_to_adr(func_ptr)
return ConstInt(heaptracker.adr2int(addr))
def ptr_to_int(obj):
from rpython.jit.codewriter.heaptracker import adr2int
from rpython.rtyper.lltypesystem import llmemory
return adr2int(llmemory.cast_ptr_to_adr(obj))
def get_malloc_fn_addr(self, funcname):
ll_func = self.get_malloc_fn(funcname)
return heaptracker.adr2int(llmemory.cast_ptr_to_adr(ll_func))
def get_fnaddr_as_int(self):
return heaptracker.adr2int(self.fnaddr)
