def finish_rtype(self): rtyper = self.rtyper translator = rtyper.annotator.translator original_graph_count = len(translator.graphs) rtyper.type_system.perform_normalizations(rtyper) for r in self.delayedreprs: r.set_setup_delayed(False) rtyper.call_all_setups() for p, repr, obj in self.delayedconsts: p._become(repr.convert_const(obj)) rtyper.call_all_setups() for p, graph in self.delayedfuncs: self.newgraphs[graph] = True real_p = rtyper.getcallable(graph) REAL = get_functype(lltype.typeOf(real_p)) FUNCTYPE = get_functype(lltype.typeOf(p)) if isinstance(FUNCTYPE, (lltype.ForwardReference, ootype.ForwardReference)): FUNCTYPE.become(REAL) assert FUNCTYPE == REAL p._become(real_p) rtyper.specialize_more_blocks() self.delayedreprs.clear() del self.delayedconsts[:] del self.delayedfuncs[:] for graph in translator.graphs[original_graph_count:]: self.newgraphs[graph] = True
def enum_content(self, o, name='', with_header=True): # XXX clean up T = lltype.typeOf(o) if (self.size_gc_header is not None and with_header and isinstance(T, lltype.ContainerType) and T._gckind == 'gc'): adr = llmemory.cast_ptr_to_adr(o._as_ptr()) adr -= self.size_gc_header o = adr.get()._obj T = lltype.typeOf(o) if isinstance(T, lltype.Struct): try: gcobjptr = header2obj[o] fmt = '(%s)' except KeyError: gcobjptr = None fmt = '%s' for name in T._names: for name, value in self.enum_content(getattr(o, name), name, with_header=False): yield fmt % (name,), value if gcobjptr: GCT = lltype.typeOf(gcobjptr) if self.size_gc_header is not None: for sub in self.enum_content(gcobjptr._obj, with_header=False): yield sub else: # display as a link to avoid the same data showing up # twice in the graph yield 'header of', gcobjptr._obj elif isinstance(T, lltype.Array): for index, o1 in enumerate(o.items): for sub in self.enum_content(o1, str(index)): yield sub elif isinstance(T, lltype.Ptr): if not o: yield name, 'null' else: yield name, self.normalize(lltype.normalizeptr(o)._obj) elif isinstance(T, lltype.OpaqueType) and hasattr(o, 'container'): T = lltype.typeOf(o.container) yield 'container', '<%s>' % (shorttypename(T),) for sub in self.enum_content(o.container, name, with_header=False): yield sub elif T == llmemory.Address: if not o: yield name, 'NULL' else: addrof = o.ref() T1 = lltype.typeOf(addrof) if (isinstance(T1, lltype.Ptr) and isinstance(T1.TO, lltype.Struct) and addrof._obj in header2obj): yield name + ' @hdr', self.normalize(addrof._obj) else: yield name + ' @', self.normalize(o.ptr._obj) ## if o.offset: ## yield '... offset', str(o.offset) else: yield name, str(o)
def _get_offset(self, cppinstance): if cppinstance: assert lltype.typeOf(cppinstance.cppclass.handle) == lltype.typeOf(self.scope.handle) offset = self.offset + capi.c_base_offset(cppinstance.cppclass, self.scope, cppinstance.get_rawobject(), 1) else: offset = self.offset return offset
def gendirectcall(self, ll_function, *args_v): rtyper = self.rtyper args_s = [] newargs_v = [] for v in args_v: if v.concretetype is Void: s_value = rtyper.binding(v, default=annmodel.s_None) if not s_value.is_constant(): raise TyperError("non-constant variable of type Void") if not isinstance(s_value, annmodel.SomePBC): raise TyperError("non-PBC Void argument: %r", (s_value,)) args_s.append(s_value) else: args_s.append(annmodel.lltype_to_annotation(v.concretetype)) newargs_v.append(v) self.rtyper.call_all_setups() # compute ForwardReferences now # hack for bound methods if hasattr(ll_function, 'im_func'): bk = rtyper.annotator.bookkeeper args_s.insert(0, bk.immutablevalue(ll_function.im_self)) newargs_v.insert(0, inputconst(Void, ll_function.im_self)) ll_function = ll_function.im_func graph = annotate_lowlevel_helper(rtyper.annotator, ll_function, args_s, rtyper.lowlevel_ann_policy) self.record_extra_call(graph) # build the 'direct_call' operation f = self.rtyper.getcallable(graph) c = inputconst(typeOf(f), f) fobj = self.rtyper.type_system_deref(f) return self.genop('direct_call', [c]+newargs_v, resulttype = typeOf(fobj).RESULT)
def op_gc_writebarrier_before_copy(source, dest): A = lltype.typeOf(source) assert A == lltype.typeOf(dest) assert isinstance(A.TO, lltype.GcArray) assert isinstance(A.TO.OF, lltype.Ptr) assert A.TO.OF.TO._gckind == 'gc' return True
def generic_initializationexpr(db, value, access_expr, decoration): if isinstance(typeOf(value), ContainerType): node = db.getcontainernode(value) lines = list(node.initializationexpr(decoration + ".")) lines[-1] += "," return lines else: comma = "," if typeOf(value) == Ptr(PyObject) and value: # cannot just write 'gxxx' as a constant in a structure :-( node = db.getcontainernode(value._obj) expr = "NULL /*%s*/" % node.name node.where_to_copy_me.append("&%s" % access_expr) elif typeOf(value) == Float and not isfinite(value): db.late_initializations.append(("%s" % access_expr, db.get(value))) expr = "0.0 /* patched later by %sinfinity */" % ("-+"[value > 0]) else: expr = db.get(value) if typeOf(value) is Void: comma = "" expr += comma i = expr.find("\n") if i < 0: i = len(expr) expr = "%s\t/* %s */%s" % (expr[:i], decoration, expr[i:]) return expr.split("\n")
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): value = longlong.getfloatstorage(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) else: value = intmask(value) if in_const_box: return history.ConstInt(value) else: return history.BoxInt(value)
def setinterior(self, toplevelcontainer, inneraddr, INNERTYPE, newvalue, offsets=()): if (lltype.typeOf(toplevelcontainer).TO._gckind == 'gc' and isinstance(INNERTYPE, lltype.Ptr) and INNERTYPE.TO._gckind == 'gc'): # wb = True if self.has_write_barrier_from_array: for index in offsets: if type(index) is not str: assert (type(index) is int # <- fast path or lltype.typeOf(index) == lltype.Signed) self.gc.write_barrier_from_array( llmemory.cast_ptr_to_adr(newvalue), llmemory.cast_ptr_to_adr(toplevelcontainer), index) wb = False break # if wb: self.gc.write_barrier( llmemory.cast_ptr_to_adr(newvalue), llmemory.cast_ptr_to_adr(toplevelcontainer)) llheap.setinterior(toplevelcontainer, inneraddr, INNERTYPE, newvalue)
def reccopy(source, dest): # copy recursively a structure or array onto another. T = lltype.typeOf(source).TO assert T == lltype.typeOf(dest).TO if isinstance(T, (lltype.Array, lltype.FixedSizeArray)): assert source._obj.getlength() == dest._obj.getlength() ITEMTYPE = T.OF for i in range(source._obj.getlength()): if isinstance(ITEMTYPE, lltype.ContainerType): subsrc = source[i] subdst = dest[i] reccopy(subsrc, subdst) else: # this is a hack XXX de-hack this llvalue = source._obj.getitem(i, uninitialized_ok=True) dest._obj.setitem(i, llvalue) elif isinstance(T, lltype.Struct): for name in T._names: FIELDTYPE = getattr(T, name) if isinstance(FIELDTYPE, lltype.ContainerType): subsrc = getattr(source, name) subdst = getattr(dest, name) reccopy(subsrc, subdst) else: # this is a hack XXX de-hack this llvalue = source._obj._getattr(name, uninitialized_ok=True) setattr(dest._obj, name, llvalue) else: raise TypeError(T)
def ref(self, firstitemptr): A = lltype.typeOf(firstitemptr).TO if A == self.TYPE: # for array of containers parent, index = lltype.parentlink(firstitemptr._obj) assert parent, "%r is not within a container" % (firstitemptr,) assert isinstance(lltype.typeOf(parent), (lltype.Array, lltype.FixedSizeArray)), ( "%r is not within an array" % (firstitemptr,)) if isinstance(index, str): assert index.startswith('item') # itemN => N index = int(index[4:]) index += self.repeat if index == parent.getlength(): # for references exactly to the end of the array try: endmarker = _end_markers[parent] except KeyError: endmarker = _endmarker_struct(A, parent=parent, parentindex=index) _end_markers[parent] = endmarker return endmarker._as_ptr() else: return parent.getitem(index)._as_ptr() elif (isinstance(A, lltype.FixedSizeArray) and array_item_type_match(A.OF, self.TYPE)): # for array of primitives or pointers return lltype.direct_ptradd(firstitemptr, self.repeat) else: raise TypeError('got %r, expected %r' % (A, self.TYPE))
def __init__(self, hrtyper, DICT): RGenOp = hrtyper.RGenOp rtyper = hrtyper.rtyper bk = rtyper.annotator.bookkeeper self.DICT = DICT self.DICTPTR = lltype.Ptr(DICT) self.ptrkind = RGenOp.kindToken(self.DICTPTR) argtypes = [bk.immutablevalue(DICT)] ll_newdict_ptr = rtyper.annotate_helper_fn(rdict.ll_newdict, argtypes) self.gv_ll_newdict = RGenOp.constPrebuiltGlobal(ll_newdict_ptr) self.tok_ll_newdict = RGenOp.sigToken(lltype.typeOf(ll_newdict_ptr).TO) argtypes = [self.DICTPTR, DICT.KEY, DICT.VALUE, HASH] ll_insertclean = rtyper.annotate_helper_fn(rdict.ll_dict_insertclean, argtypes) self.gv_ll_insertclean = RGenOp.constPrebuiltGlobal(ll_insertclean) self.tok_ll_insertclean = RGenOp.sigToken( lltype.typeOf(ll_insertclean).TO) # XXX some fishing that only works if the DICT does not come from # an r_dict if DICT.keyeq is None: keyeq = operator.eq else: assert isinstance(DICT.keyeq, lltype.staticAdtMethod) keyeq = DICT.keyeq.__get__(42) assert isinstance(DICT.keyhash, lltype.staticAdtMethod) keyhash = DICT.keyhash.__get__(42) keydesc = LLEqDesc(DICT.KEY, keyeq, keyhash) self.VirtualDict = keydesc.VirtualDict
def setup(self): for value in self._getvalues(): self.db.prepare_constant(lltype.typeOf(value), value) p, c = lltype.parentlink(self.value) if p is not None: self.db.prepare_constant(lltype.typeOf(p), p)
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 foo(): # a bit hard to test, really a = llop.get_exception_addr(llmemory.Address) assert lltype.typeOf(a) is llmemory.Address a = llop.get_exc_value_addr(llmemory.Address) assert lltype.typeOf(a) is llmemory.Address return 42
def ll_arraycopy(source, dest, source_start, dest_start, length): from pypy.rpython.lltypesystem.lloperation import llop from pypy.rlib.objectmodel import keepalive_until_here # supports non-overlapping copies only if not we_are_translated(): if source == dest: assert (source_start + length <= dest_start or dest_start + length <= source_start) TP = lltype.typeOf(source).TO assert TP == lltype.typeOf(dest).TO if isinstance(TP.OF, lltype.Ptr) and TP.OF.TO._gckind == 'gc': # perform a write barrier that copies necessary flags from # source to dest if not llop.gc_writebarrier_before_copy(lltype.Bool, source, dest): # if the write barrier is not supported, copy by hand for i in range(length): dest[i + dest_start] = source[i + source_start] return source_addr = llmemory.cast_ptr_to_adr(source) dest_addr = llmemory.cast_ptr_to_adr(dest) cp_source_addr = (source_addr + llmemory.itemoffsetof(TP, 0) + llmemory.sizeof(TP.OF) * source_start) cp_dest_addr = (dest_addr + llmemory.itemoffsetof(TP, 0) + llmemory.sizeof(TP.OF) * dest_start) llmemory.raw_memcopy(cp_source_addr, cp_dest_addr, llmemory.sizeof(TP.OF) * length) keepalive_until_here(source) keepalive_until_here(dest)
def generic_initializationexpr(db, value, access_expr, decoration): if isinstance(typeOf(value), ContainerType): node = db.getcontainernode(value) lines = list(node.initializationexpr(decoration+'.')) lines[-1] += ',' return lines else: comma = ',' if typeOf(value) == Ptr(PyObject) and value: # cannot just write 'gxxx' as a constant in a structure :-( node = db.getcontainernode(value._obj) expr = 'NULL /*%s*/' % node.name node.where_to_copy_me.append('&%s' % access_expr) elif typeOf(value) == Float and (isinf(value) or isnan(value)): db.late_initializations.append(('%s' % access_expr, db.get(value))) expr = '0.0 /* patched later by %sinfinity */' % ( '-+'[value > 0]) else: expr = db.get(value) if typeOf(value) is Void: comma = '' expr += comma i = expr.find('\n') if i<0: i = len(expr) expr = '%s\t/* %s */%s' % (expr[:i], decoration, expr[i:]) return expr.split('\n')
def dispatcher(self, shape, index, argtypes, resulttype): key = shape, index, tuple(argtypes), resulttype if key in self._dispatch_cache: return self._dispatch_cache[key] from pypy.translator.unsimplify import varoftype from pypy.objspace.flow.model import FunctionGraph, Link, Block, SpaceOperation inputargs = [varoftype(t) for t in [Char] + argtypes] startblock = Block(inputargs) startblock.exitswitch = inputargs[0] graph = FunctionGraph("dispatcher", startblock, varoftype(resulttype)) row_of_graphs = self.callfamily.calltables[shape][index] links = [] descs = list(self.s_pbc.descriptions) if self.s_pbc.can_be_None: descs.insert(0, None) for desc in descs: if desc is None: continue args_v = [varoftype(t) for t in argtypes] b = Block(args_v) llfn = self.rtyper.getcallable(row_of_graphs[desc]) v_fn = inputconst(typeOf(llfn), llfn) v_result = varoftype(resulttype) b.operations.append( SpaceOperation("direct_call", [v_fn] + args_v, v_result)) b.closeblock(Link([v_result], graph.returnblock)) i = self.descriptions.index(desc) links.append(Link(inputargs[1:], b, chr(i))) links[-1].llexitcase = chr(i) startblock.closeblock(*links) self.rtyper.annotator.translator.graphs.append(graph) ll_ret = self.rtyper.type_system.getcallable(graph) #FTYPE = FuncType c_ret = self._dispatch_cache[key] = inputconst(typeOf(ll_ret), ll_ret) return c_ret
def setup_externs(c_db, db): rtyper = db.translator.rtyper from pypy.translator.c.extfunc import predeclare_all # hacks to make predeclare_all work decls = list(predeclare_all(c_db, rtyper)) for c_name, obj in decls: if isinstance(obj, lltype.LowLevelType): db.prepare_type(obj) elif isinstance(obj, FunctionGraph): funcptr = rtyper.getcallable(obj) c = inputconst(lltype.typeOf(funcptr), funcptr) db.prepare_arg_value(c) elif isinstance(lltype.typeOf(obj), lltype.Ptr): db.prepare_constant(lltype.typeOf(obj), obj) elif type(c_name) is str and type(obj) is int: pass #define c_name obj else: assert False, "unhandled predeclare %s %s %s" % (c_name, type(obj), obj) def annotatehelper(func, *argtypes): graph = db.translator.rtyper.annotate_helper(func, argtypes) fptr = rtyper.getcallable(graph) c = inputconst(lltype.typeOf(fptr), fptr) db.prepare_arg_value(c) decls.append(("ll_" + func.func_name, graph)) return graph.name return decls
def get(self, obj, funcgen=None): if isinstance(obj, CConstant): return obj.c_name # without further checks T = typeOf(obj) if isinstance(T, Primitive) or T == GCREF: return PrimitiveName[T](obj, self) elif isinstance(T, Ptr): if (isinstance(T.TO, OpaqueType) and T.TO.hints.get('c_pointer_typedef') is not None): if obj._obj is not None: value = rffi.cast(rffi.SSIZE_T, obj) return '((%s) %s)' % (cdecl(self.gettype(T), ''), self.get(value)) if obj: # test if the ptr is non-NULL try: container = obj._obj except lltype.DelayedPointer: # hack hack hack name = obj._obj0 assert name.startswith('delayed!') n = len('delayed!') if len(name) == n: raise if isinstance(lltype.typeOf(obj).TO, lltype.FuncType): if obj in self.idelayedfunctionnames: return self.idelayedfunctionnames[obj][0] funcname = name[n:] funcname = self.namespace.uniquename('g_'+funcname) self.idelayedfunctionnames[obj] = funcname, obj else: funcname = None # can't use the name of a # delayed non-function ptr self.delayedfunctionptrs.append(obj) return funcname # /hack hack hack else: # hack hack hack if obj in self.idelayedfunctionnames: # this used to be a delayed function, # make sure we use the same name forcename = self.idelayedfunctionnames[obj][0] node = self.getcontainernode(container, forcename=forcename) assert node.getptrname() == forcename return forcename # /hack hack hack if isinstance(container, int): # special case for tagged odd-valued pointers return '((%s) %d)' % (cdecl(self.gettype(T), ''), obj._obj) node = self.getcontainernode(container) if node._funccodegen_owner is None: node._funccodegen_owner = funcgen return node.getptrname() else: return '((%s) NULL)' % (cdecl(self.gettype(T), ''), ) else: raise Exception("don't know about %r" % (obj,))
def __init__(self, db, value): assert isinstance(lltype.typeOf(value), lltype.Array) self.db = db self.value = value self.arraytype = lltype.typeOf(value).OF prefix = '%arrayinstance' name = '' #str(value).split()[1] self.ref = self.make_ref(prefix, name)
def op_check_and_clear_exc(self): exc_data = self.llinterpreter.get_transformed_exc_data(self.graph) assert exc_data etype = exc_data.exc_type evalue = exc_data.exc_value exc_data.exc_type = lltype.typeOf(etype )._defl() exc_data.exc_value = lltype.typeOf(evalue)._defl() return bool(etype)
def __init__(self, db, value): assert isinstance(lltype.typeOf(value), lltype.Array) self.db = db self.value = value self.arraytype = lltype.typeOf(value).OF name = '' #str(value).split()[1] self.make_name(name)
def setup(self): for value in self.db.gcpolicy.gcheader_initdata(self.value): self.db.prepare_constant(lltype.typeOf(value), value) for item in self.value.items: self.db.prepare_constant(self.arraytype, item) p, c = lltype.parentlink(self.value) if p is not None: self.db.prepare_constant(lltype.typeOf(p), p)
def cast_weakrefptr_to_ptr(PTRTYPE, pwref): assert lltype.typeOf(pwref) == WeakRefPtr if pwref: assert isinstance(pwref._obj, _gctransformed_wref) if PTRTYPE is not None: assert PTRTYPE == lltype.typeOf(pwref._obj._ptr) return pwref._obj._ptr else: return lltype.nullptr(PTRTYPE.TO)
def __init__(self, adrvalue, cpu): "NOT_RPYTHON" assert not we_are_translated() if isinstance(lltype.typeOf(adrvalue), lltype.Ptr): adrvalue = llmemory.cast_ptr_to_adr(adrvalue) # convenience else: assert lltype.typeOf(adrvalue) == llmemory.Address self.value = adrvalue self.cpu = cpu
def setintfield(pdst, fieldname, value): """Maybe temporary: a helper to set an integer field into a structure, transparently casting between the various integer types. """ STRUCT = lltype.typeOf(pdst).TO TSRC = lltype.typeOf(value) TDST = getattr(STRUCT, fieldname) assert isinstance(TSRC, lltype.Number) assert isinstance(TDST, lltype.Number) setattr(pdst, fieldname, cast(TDST, value))
def setparentstructure(container, chain): TP = lltype.typeOf(container) current = container for i, elem in enumerate(chain): if lltype.typeOf(elem[0]) == TP: chain = chain[i + 1:] break for elem in chain: current._setparentstructure(*elem) current = elem[0]
def op_oosend(self, message, inst, *args): checkinst(inst) assert isinstance(message, str) bm = getattr(inst, message) inst = bm.inst m = bm.meth args = m._checkargs(args, check_callable=False) if getattr(m, 'abstract', False): raise RuntimeError("calling abstract method %r" % (m,)) return self.perform_call(m, (lltype.typeOf(inst),)+lltype.typeOf(m).ARGS, [inst]+args)
def test_ptradd(): data = "hello, world!" a = lltype.malloc(ARRAY_OF_CHAR, len(data), flavor='raw') for i in xrange(len(data)): a[i] = data[i] a2 = ptradd(a, 2) assert lltype.typeOf(a2) == lltype.typeOf(a) == lltype.Ptr(ARRAY_OF_CHAR) for i in xrange(len(data) - 2): assert a2[i] == a[i + 2] lltype.free(a, flavor='raw')
def _next_section(reader, *expected): bh = MyBlackholeInterp(map(lltype.typeOf, expected)) reader.consume_one_section(bh) expected_i = [x for x in expected if lltype.typeOf(x) == lltype.Signed] expected_r = [x for x in expected if lltype.typeOf(x) == llmemory.GCREF] expected_f = [x for x in expected if lltype.typeOf(x) == longlong.FLOATSTORAGE] assert bh.written_i == expected_i assert bh.written_r == expected_r assert bh.written_f == expected_f
def generic_cpy_call_expect_null(space, func, *args): FT = lltype.typeOf(func).TO return make_generic_cpy_call(FT, True, True)(space, func, *args)
def export_struct(name, struct): assert name not in EXPORTS_names, "Duplicate export " + name assert isinstance(typeOf(struct), ContainerType) EXPORTS_names.add(name) EXPORTS_obj2name[struct] = name
def build_concrete_calltable(rtyper, callfamily): """Build a complete call table of a call family with concrete low-level function objs. """ concretetable = {} # (shape,index): row, maybe with duplicates uniquerows = [] # list of rows, without duplicates def lookuprow(row): # a 'matching' row is one that has the same llfn, expect # that it may have more or less 'holes' for existingindex, existingrow in enumerate(uniquerows): if row.fntype != existingrow.fntype: continue # not the same pointer type, cannot match for funcdesc, llfn in row.items(): if funcdesc in existingrow: if llfn != existingrow[funcdesc]: break # mismatch else: # potential match, unless the two rows have no common funcdesc merged = ConcreteCallTableRow(row) merged.update(existingrow) merged.fntype = row.fntype if len(merged) == len(row) + len(existingrow): pass # no common funcdesc, not a match else: return existingindex, merged raise LookupError def addrow(row): # add a row to the table, potentially merging it with an existing row try: index, merged = lookuprow(row) except LookupError: uniquerows.append(row) # new row else: if merged == uniquerows[index]: pass # already exactly in the table else: del uniquerows[index] addrow(merged) # add the potentially larger merged row concreterows = {} for shape, rows in callfamily.calltables.items(): for index, row in enumerate(rows): concreterow = ConcreteCallTableRow() for funcdesc, graph in row.items(): llfn = rtyper.getcallable(graph) concreterow[funcdesc] = llfn assert len(concreterow) > 0 concreterow.fntype = typeOf(llfn) # 'llfn' from the loop above # (they should all have the same type) concreterows[shape, index] = concreterow for row in concreterows.values(): addrow(row) for (shape, index), row in concreterows.items(): existingindex, biggerrow = lookuprow(row) row = uniquerows[existingindex] assert biggerrow == row # otherwise, addrow() is broken concretetable[shape, index] = row if len(uniquerows) == 1: uniquerows[0].attrname = None else: for finalindex, row in enumerate(uniquerows): row.attrname = 'variant%d' % finalindex return concretetable, uniquerows
def __init__(self, value=lltype.nullptr(llmemory.GCREF.TO)): assert lltype.typeOf(value) == llmemory.GCREF self.value = value
def __init__(self, value): assert lltype.typeOf(value) == llmemory.GCREF self.value = value
def raw_memclear(adr, size): if not isinstance(size, AddressOffset): raise NotImplementedError(size) assert lltype.typeOf(adr) == Address zeroadr = size._raw_malloc([], zero=True) size.raw_memcopy(zeroadr, adr)
def cast_ptr_to_adr(obj): assert isinstance(lltype.typeOf(obj), lltype.Ptr) return obj._cast_to_adr()
def castable(self, TO, var): return ootype.isSubclass(lltype.typeOf(var), TO)
def test_rtype_1(self): def f(): return virtual_ref(X()) x = self.interpret(f, []) assert lltype.typeOf(x) == self.OBJECTTYPE
def castable(self, TO, var): return lltype.castable(TO, lltype.typeOf(var)) > 0
def push_field(self, num, value): ptr = rffi.ptradd(self.ll_buffer, self.shape.ll_positions[num]) TP = lltype.typeOf(value) T = lltype.Ptr(rffi.CArray(TP)) rffi.cast(T, ptr)[0] = value
def raw_memcopy(source, dest, size): assert lltype.typeOf(source) == Address assert lltype.typeOf(dest) == Address size.raw_memcopy(source, dest)
def run(self, func): # for snippet.py res = self.interpret(func, []) if lltype.typeOf(res) == lltype.Ptr(STR): res = ''.join(res.chars) return res
def read_from_ptr(self, ptr): value = ptr[0] assert lltype.typeOf(value) == self.TYPE return value
def annotate(translator, func, result, args): args = [arg.concretetype for arg in args] graph = translator.rtyper.annotate_helper(func, args) fptr = lltype.functionptr(lltype.FuncType(args, result.concretetype), func.func_name, graph=graph) c = inputconst(lltype.typeOf(fptr), fptr) return c
def __setitem__(self, index, value): assert lltype.typeOf(value) == self.TYPE ptr = self.addr.ref() if index != 0: ptr = lltype.direct_ptradd(ptr, index) self.write_into_ptr(ptr, value)
def __init__(self, valuestorage=longlong.ZEROF): assert lltype.typeOf(valuestorage) is longlong.FLOATSTORAGE self.value = valuestorage
def ref(self, arrayptr): assert array_type_match(lltype.typeOf(arrayptr).TO, self.TYPE) return lltype._arraylenref._makeptr(arrayptr._obj, arrayptr._solid)
def _ll_1_jit_force_virtual(inst): return llop.jit_force_virtual(lltype.typeOf(inst), inst)
def __init__(self, cpu, result): assert lltype.typeOf(result) == cpu.ts.BASETYPE self.result = result
def __init__(self, cpu, value): assert lltype.typeOf(value) == cpu.ts.BASETYPE self.value = value
def checkadr(adr): if lltype.typeOf(adr) is not llmemory.Address: raise TypeError("arg must be an address, got %r instead" % (lltype.typeOf(adr), ))
def __init__(self, result): assert lltype.typeOf(result) is lltype.Float self.result = result
def consider_constant(self, p): obj = p._obj TYPE = lltype.typeOf(obj) self.layoutbuilder.consider_constant(TYPE, obj, self.gc)
def __init__(self, result): assert lltype.typeOf(result) is lltype.Signed self.result = result
ASM_CALLBACK_PTR = lltype.Ptr(lltype.FuncType([llmemory.Address], lltype.Void)) # used internally by walk_stack_from() WALKFRAME = lltype.Struct( 'WALKFRAME', ( 'regs_stored_at', # address of where the registers have been saved lltype.FixedSizeArray(llmemory.Address, CALLEE_SAVED_REGS)), ('frame_address', llmemory.Address), ) pypy_asm_stackwalk = rffi.llexternal('pypy_asm_stackwalk', [ASM_CALLBACK_PTR], lltype.Void, sandboxsafe=True, _nowrapper=True) pypy_asm_gcroot = rffi.llexternal('pypy_asm_gcroot', [llmemory.Address], llmemory.Address, sandboxsafe=True, _nowrapper=True) c_asm_gcroot = Constant(pypy_asm_gcroot, lltype.typeOf(pypy_asm_gcroot)) QSORT_CALLBACK_PTR = lltype.Ptr( lltype.FuncType([llmemory.Address, llmemory.Address], rffi.INT)) qsort = rffi.llexternal( 'qsort', [llmemory.Address, rffi.SIZE_T, rffi.SIZE_T, QSORT_CALLBACK_PTR], lltype.Void, sandboxsafe=True, _nowrapper=True)
def checkptr(ptr): if not isinstance(lltype.typeOf(ptr), lltype.Ptr): raise TypeError("arg must be a pointer, got %r instead" % (lltype.typeOf(ptr), ))
def setinterior(toplevelcontainer, inneraddr, INNERTYPE, newvalue): assert typeOf(newvalue) == INNERTYPE # xxx access the address object's ref() directly for performance inneraddr.ref()[0] = newvalue
def handle_unreachable(self, v_result): from pypy.rpython.lltypesystem.rstr import string_repr msg = "unreachable operation (from malloc.py)" ll_msg = string_repr.convert_const(msg) c_msg = Constant(ll_msg, lltype.typeOf(ll_msg)) return SpaceOperation("debug_fatalerror", [c_msg], v_result)
def generic_cpy_call_dont_decref(space, func, *args): FT = lltype.typeOf(func).TO return make_generic_cpy_call(FT, False, False)(space, func, *args)