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 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:
res = history.RefFrontendOp(0)
res.setref_base(value)
return res
else:
value = ptr2int(value)
# 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:
res = history.FloatFrontendOp(0)
res.setfloatstorage(value)
return res
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:
res = history.IntFrontendOp(0)
res.setint(value)
return res
def new_ConstRef(self, x):
ptrval = lltype.cast_opaque_ptr(llmemory.GCREF, x)
return history.ConstPtr(ptrval)
class LLTypeHelper(TypeSystemHelper):
name = 'lltype'
functionptr = staticmethod(lltype.functionptr)
nullptr = staticmethod(lltype.nullptr)
cast_instance_to_base_ref = staticmethod(cast_instance_to_base_ptr)
BASETYPE = llmemory.GCREF
ConstRef = history.ConstPtr
loops_done_with_this_frame_ref = None # patched by compile.py
NULLREF = history.ConstPtr.value
CONST_NULL = history.ConstPtr(NULLREF)
def new_ConstRef(self, x):
ptrval = lltype.cast_opaque_ptr(llmemory.GCREF, x)
return history.ConstPtr(ptrval)
def get_typeptr(self, obj):
return obj.typeptr
def get_FuncType(self, ARGS, RESULT):
FUNCTYPE = lltype.FuncType(ARGS, RESULT)
FUNCPTRTYPE = lltype.Ptr(FUNCTYPE)
return FUNCTYPE, FUNCPTRTYPE
def get_superclass(self, TYPE):
SUPER = TYPE.TO._first_struct()[1]
if SUPER is None:
return None
return lltype.Ptr(SUPER)
def cast_to_instance_maybe(self, TYPE, instance):
return lltype.cast_pointer(TYPE, instance)
cast_to_instance_maybe._annspecialcase_ = 'specialize:arg(1)'
def cast_fnptr_to_root(self, fnptr):
return llmemory.cast_ptr_to_adr(fnptr)
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 instanceOf(self, instbox, clsbox):
adr = clsbox.getaddr()
bounding_class = llmemory.cast_adr_to_ptr(adr, rclass.CLASSTYPE)
real_instance = instbox.getref(rclass.OBJECTPTR)
return rclass.ll_isinstance(real_instance, bounding_class)
def get_exception_box(self, etype):
return history.ConstInt(etype)
def get_exception_obj(self, evaluebox):
# only works when translated
obj = evaluebox.getref(lltype.Ptr(rclass.OBJECT))
return cast_base_ptr_to_instance(Exception, obj)
def cast_to_baseclass(self, value):
return lltype.cast_opaque_ptr(lltype.Ptr(rclass.OBJECT), value)
@specialize.ll()
def getlength(self, array):
return len(array)
@specialize.ll()
def getarrayitem(self, array, i):
return array[i]
@specialize.ll()
def setarrayitem(self, array, i, newvalue):
array[i] = newvalue
def conststr(self, str):
ll = llstr(str)
return history.ConstPtr(lltype.cast_opaque_ptr(llmemory.GCREF, ll))
# A dict whose keys are refs (like the .value of BoxPtr).
# It is an r_dict on lltype. Two copies, to avoid conflicts with
# the value type. Note that NULL is not allowed as a key.
def new_ref_dict(self):
return r_dict(rd_eq, rd_hash)
def new_ref_dict_2(self):
return r_dict(rd_eq, rd_hash)
def new_ref_dict_3(self):
return r_dict(rd_eq, rd_hash)
def cast_vtable_to_hashable(self, cpu, ptr):
adr = llmemory.cast_ptr_to_adr(ptr)
return heaptracker.adr2int(adr)
def cast_from_ref(self, TYPE, value):
return lltype.cast_opaque_ptr(TYPE, value)
cast_from_ref._annspecialcase_ = 'specialize:arg(1)'
def cast_to_ref(self, value):
return lltype.cast_opaque_ptr(llmemory.GCREF, value)
cast_to_ref._annspecialcase_ = 'specialize:ll'
def getaddr_for_box(self, box):
return box.getaddr()
def conststr(self, str):
ll = llstr(str)
return history.ConstPtr(lltype.cast_opaque_ptr(llmemory.GCREF, ll))