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))