예제 #1
0
    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))
예제 #2
0
파일: support.py 프로젝트: sota/pypy-old
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)
예제 #3
0
파일: support.py 프로젝트: cimarieta/usp
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)
예제 #4
0
파일: llmodel.py 프로젝트: mozillazg/pypy
    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))
예제 #5
0
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
예제 #6
0
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
예제 #7
0
파일: rewrite.py 프로젝트: tools-env/mesapy
    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)
예제 #8
0
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)
예제 #9
0
 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()))
예제 #10
0
파일: rewrite.py 프로젝트: Darriall/pypy
 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()))
예제 #11
0
파일: virtualref.py 프로젝트: charred/pypy
 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)
예제 #12
0
 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)
예제 #13
0
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]
예제 #14
0
 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)
예제 #15
0
    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)
예제 #16
0
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)
예제 #17
0
파일: compile.py 프로젝트: weijiwei/pypy
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
예제 #18
0
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)
예제 #19
0
파일: compile.py 프로젝트: bukzor/pypy
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
예제 #20
0
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)
예제 #21
0
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]
예제 #22
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
예제 #23
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
예제 #24
0
 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
예제 #25
0
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
예제 #26
0
파일: compile.py 프로젝트: mozillazg/pypy
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
예제 #27
0
파일: assembler.py 프로젝트: charred/pypy
 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
예제 #28
0
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
예제 #29
0
 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)
예제 #30
0
파일: history.py 프로젝트: weijiwei/pypy
 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)
예제 #31
0
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
예제 #32
0
파일: support.py 프로젝트: charred/pypy
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)
예제 #33
0
파일: support.py 프로젝트: sota/pypy-old
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)
예제 #34
0
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]
예제 #35
0
파일: gc.py 프로젝트: weijiwei/pypy
 def get_malloc_fn_addr(self, funcname):
     ll_func = self.get_malloc_fn(funcname)
     return heaptracker.adr2int(llmemory.cast_ptr_to_adr(ll_func))
예제 #36
0
def ConstAddr(addr, cpu):
    return ConstInt(heaptracker.adr2int(addr))
예제 #37
0
파일: descr.py 프로젝트: sota/pypy-old
 def get_vtable(self):
     return heaptracker.adr2int(llmemory.cast_ptr_to_adr(self.vtable))
예제 #38
0
파일: jitcode.py 프로젝트: sota/pypy-old
 def get_fnaddr_as_int(self):
     return heaptracker.adr2int(self.fnaddr)
예제 #39
0
 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))
예제 #40
0
 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))
예제 #41
0
파일: typesystem.py 프로젝트: sota/pypy-old
 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))
예제 #42
0
파일: llmodel.py 프로젝트: mozillazg/pypy
 def pos_exc_value():
     addr = llop.get_exc_value_addr(llmemory.Address)
     return heaptracker.adr2int(addr)
예제 #43
0
파일: runner.py 프로젝트: Qointum/pypy
 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)
예제 #44
0
 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))
예제 #45
0
파일: descr.py 프로젝트: cimarieta/usp
 def get_vtable(self):
     return heaptracker.adr2int(llmemory.cast_ptr_to_adr(self.vtable))
예제 #46
0
 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)
예제 #47
0
 def pos_exc_value():
     addr = llop.get_exc_value_addr(llmemory.Address)
     return heaptracker.adr2int(addr)
예제 #48
0
 def pos_exception():
     addr = llop.get_exception_addr(llmemory.Address)
     return heaptracker.adr2int(addr)
예제 #49
0
파일: typesystem.py 프로젝트: sota/pypy-old
 def cast_vtable_to_hashable(self, cpu, ptr):
     adr = llmemory.cast_ptr_to_adr(ptr)
     return heaptracker.adr2int(adr)
예제 #50
0
 def get_funcbox(cls, cpu, func_ptr):
     addr = llmemory.cast_ptr_to_adr(func_ptr)
     return ConstInt(heaptracker.adr2int(addr))
예제 #51
0
def ConstAddr(addr, cpu):
    return ConstInt(heaptracker.adr2int(addr))
예제 #52
0
파일: llmodel.py 프로젝트: mozillazg/pypy
 def pos_exception():
     addr = llop.get_exception_addr(llmemory.Address)
     return heaptracker.adr2int(addr)
예제 #53
0
 def get_funcbox(cls, cpu, func_ptr):
     addr = llmemory.cast_ptr_to_adr(func_ptr)
     return ConstInt(heaptracker.adr2int(addr))
예제 #54
0
 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))
예제 #55
0
파일: gc.py 프로젝트: mozillazg/pypy
 def get_malloc_fn_addr(self, funcname):
     ll_func = self.get_malloc_fn(funcname)
     return heaptracker.adr2int(llmemory.cast_ptr_to_adr(ll_func))
예제 #56
0
 def get_fnaddr_as_int(self):
     return heaptracker.adr2int(self.fnaddr)