Did I find the right examples for you? yes no

All Samples(253)  |  Call(207)  |  Derive(0)  |  Import(46)

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/jit/backend/llgraph/runner.py   plexnet(Download)
        index = indexbox.getint()
        if arraydescr.typeinfo == REF:
            return history.BoxPtr(llimpl.do_getarrayitem_gc_ptr(array, index))
        elif arraydescr.typeinfo == INT:
            return history.BoxInt(llimpl.do_getarrayitem_gc_int(array, index,
    def do_getfield_gc(self, structbox, fielddescr):
        assert isinstance(fielddescr, Descr)
        struct = structbox.getref_base()
        if fielddescr.typeinfo == REF:
            return history.BoxPtr(llimpl.do_getfield_gc_ptr(struct,
    def do_getfield_raw(self, structbox, fielddescr):
        assert isinstance(fielddescr, Descr)
        struct = self.cast_int_to_adr(structbox.getint())
        if fielddescr.typeinfo == REF:
            return history.BoxPtr(llimpl.do_getfield_raw_ptr(struct,
    def do_new(self, size):
        assert isinstance(size, Descr)
        return history.BoxPtr(llimpl.do_new(size.ofs))
 
    def do_new_with_vtable(self, vtablebox):
        llimpl.do_setfield_gc_int(result, self.fielddescrof_vtable.ofs,
                                  vtable, self.memo_cast)
        return history.BoxPtr(result)
 
    def do_new_array(self, countbox, size):

src/s/y/Sypy-HEAD/jit/metainterp/resume.py   Sypy(Download)
import sys, os
from pypy.jit.metainterp.history import Box, Const, ConstInt, getkind
from pypy.jit.metainterp.history import BoxInt, BoxPtr, BoxFloat
from pypy.jit.metainterp.history import INT, REF, FLOAT, HOLE
from pypy.jit.metainterp.history import AbstractDescr
            box = BoxInt(self.cpu.get_latest_value_int(num))
        elif kind == REF:
            box = BoxPtr(self.cpu.get_latest_value_ref(num))
        elif kind == FLOAT:
            box = BoxFloat(self.cpu.get_latest_value_float(num))

src/s/y/Sypy-HEAD/jit/metainterp/executor.py   Sypy(Download)
from pypy.rlib.rtimer import read_timestamp
from pypy.rlib.unroll import unrolling_iterable
from pypy.jit.metainterp.history import BoxInt, BoxPtr, BoxFloat, check_descr
from pypy.jit.metainterp.history import INT, REF, FLOAT, VOID, AbstractDescr
from pypy.jit.metainterp import resoperation
            metainterp.execute_raised(e)
            result = NULL
        return BoxPtr(result)
    if rettype == FLOAT or rettype == 'L':     # *L*ong long
        try:
def do_getarrayitem_gc(cpu, _, arraybox, indexbox, arraydescr):
    array = arraybox.getref_base()
    index = indexbox.getint()
    if arraydescr.is_array_of_pointers():
        return BoxPtr(cpu.bh_getarrayitem_gc_r(arraydescr, array, index))
def do_getinteriorfield_gc(cpu, _, arraybox, indexbox, descr):
    array = arraybox.getref_base()
    index = indexbox.getint()
    if descr.is_pointer_field():
        return BoxPtr(cpu.bh_getinteriorfield_gc_r(array, index, descr))
def do_getfield_gc(cpu, _, structbox, fielddescr):
    struct = structbox.getref_base()
    if fielddescr.is_pointer_field():
        return BoxPtr(cpu.bh_getfield_gc_r(struct, fielddescr))
    elif fielddescr.is_float_field():

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/jit/backend/llvm/runner.py   plexnet(Download)
from pypy.rlib import runicode
from pypy.jit.metainterp.history import AbstractDescr, INT
from pypy.jit.metainterp.history import BoxInt, BoxPtr
from pypy.jit.backend.model import AbstractCPU
from pypy.jit.backend.llvm import llvm_rffi
            p = rffi.cast(lltype.Ptr(self.gcarray_gcref), array)
            res = p[index]
            return BoxPtr(res)
        elif itemsize_index == self.SIZE_INT:
            p = rffi.cast(lltype.Ptr(self.gcarray_signed), array)
            p = rffi.cast(rffi.CArrayPtr(llmemory.GCREF), struct)
            res = p[fielddescr.offset / rffi.sizeof(llmemory.GCREF)]
            return BoxPtr(res)
        elif size_index == self.SIZE_INT:
            p = rffi.cast(rffi.CArrayPtr(lltype.Signed), struct)
    def do_new(self, args, sizedescr):
        assert isinstance(sizedescr, SizeDescr)
        res = self.malloc_fn_ptr(rffi.cast(rffi.SIZE_T, sizedescr.size))
        return BoxPtr(res)
 
        res = self.malloc_fn_ptr(rffi.cast(rffi.SIZE_T, sizedescr.size))
        self._do_setfield(res, args[0], self.vtable_descr)
        return BoxPtr(res)
 
    def _allocate_new_array(self, args, item_size, index_array, index_length):

src/s/y/Sypy-HEAD/jit/backend/llvm/runner.py   Sypy(Download)
from pypy.rlib import runicode
from pypy.jit.metainterp.history import AbstractDescr, INT
from pypy.jit.metainterp.history import BoxInt, BoxPtr
from pypy.jit.backend.model import AbstractCPU
from pypy.jit.backend.llvm import llvm_rffi
            p = rffi.cast(lltype.Ptr(self.gcarray_gcref), array)
            res = p[index]
            return BoxPtr(res)
        elif itemsize_index == self.SIZE_INT:
            p = rffi.cast(lltype.Ptr(self.gcarray_signed), array)
            p = rffi.cast(rffi.CArrayPtr(llmemory.GCREF), struct)
            res = p[fielddescr.offset / rffi.sizeof(llmemory.GCREF)]
            return BoxPtr(res)
        elif size_index == self.SIZE_INT:
            p = rffi.cast(rffi.CArrayPtr(lltype.Signed), struct)
    def do_new(self, args, sizedescr):
        assert isinstance(sizedescr, SizeDescr)
        res = self.malloc_fn_ptr(rffi.cast(rffi.SIZE_T, sizedescr.size))
        return BoxPtr(res)
 
        res = self.malloc_fn_ptr(rffi.cast(rffi.SIZE_T, sizedescr.size))
        self._do_setfield(res, args[0], self.vtable_descr)
        return BoxPtr(res)
 
    def _allocate_new_array(self, args, item_size, index_array, index_length):

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/jit/metainterp/warmstate.py   plexnet(Download)
                return history.ConstPtr(value)
            else:
                return history.BoxPtr(value)
        else:
            adr = llmemory.cast_ptr_to_adr(value)

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/jit/backend/llgraph/llimpl.py   plexnet(Download)
from pypy.objspace.flow.model import Variable, Constant
from pypy.annotation import model as annmodel
from pypy.jit.metainterp.history import (ConstInt, ConstPtr, ConstAddr,
                                         BoxInt, BoxPtr, BoxObj, BoxFloat,
                                         REF, INT, FLOAT)
                            boxedargs.append(BoxObj(ootype.cast_to_object(x)))
                        else:
                            boxedargs.append(BoxPtr(x))
                    # xxx this passes the 'llimpl' module as the CPU argument
                    resbox = impl(llimpl, *boxedargs)

src/p/l/plexnet-HEAD/third_party/generic/pypy/pypy/jit/backend/llsupport/llmodel.py   plexnet(Download)
from pypy.rpython.annlowlevel import llhelper
from pypy.rlib.objectmodel import we_are_translated, specialize
from pypy.jit.metainterp.history import BoxInt, BoxPtr, set_future_values,\
     BoxFloat
from pypy.jit.backend.model import AbstractCPU
            pval = self._cast_int_to_gcref(items[itemindex])
            # --- end of GC unsafe code ---
            return BoxPtr(pval)
        #
        if float:
            pval = self._cast_int_to_gcref(pval)
            # --- end of GC unsafe code ---
            return BoxPtr(pval)
        #
        if float:
    def do_new(self, sizedescr):
        res = self.gc_ll_descr.gc_malloc(sizedescr)
        return BoxPtr(res)
 
    def do_new_with_vtable(self, classbox):
        as_array = rffi.cast(rffi.CArrayPtr(lltype.Signed), res)
        as_array[self.vtable_offset/WORD] = classint
        return BoxPtr(res)
 
    def do_new_array(self, countbox, arraydescr):

src/s/y/Sypy-HEAD/jit/metainterp/warmstate.py   Sypy(Download)
                return history.ConstPtr(value)
            else:
                return history.BoxPtr(value)
        else:
            adr = llmemory.cast_ptr_to_adr(value)

src/s/y/Sypy-HEAD/jit/metainterp/pyjitpl.py   Sypy(Download)
        obj = box.getref_base()
        vref = vrefinfo.virtual_ref_during_tracing(obj)
        resbox = history.BoxPtr(vref)
        cindex = history.ConstInt(len(metainterp.virtualref_boxes) // 2)
        metainterp.history.record(rop.VIRTUAL_REF, [box, cindex], resbox)

  1 | 2 | 3 | 4 | 5 | 6  Next