def effectinfo_from_writeanalyze(effects, cpu,
                                 extraeffect=EffectInfo.EF_CAN_RAISE,
                                 oopspecindex=EffectInfo.OS_NONE,
                                 can_invalidate=False):
    from pypy.translator.backendopt.writeanalyze import top_set
    if effects is top_set or extraeffect == EffectInfo.EF_RANDOM_EFFECTS:
        readonly_descrs_fields = None
        readonly_descrs_arrays = None
        write_descrs_fields = None
        write_descrs_arrays = None
        extraeffect = EffectInfo.EF_RANDOM_EFFECTS
    else:
        readonly_descrs_fields = []
        readonly_descrs_arrays = []
        write_descrs_fields = []
        write_descrs_arrays = []

        def add_struct(descrs_fields, (_, T, fieldname)):
            T = deref(T)
            if consider_struct(T, fieldname):
                descr = cpu.fielddescrof(T, fieldname)
                descrs_fields.append(descr)

        def add_array(descrs_arrays, (_, T)):
            ARRAY = deref(T)
            if consider_array(ARRAY):
                descr = cpu.arraydescrof(ARRAY)
                descrs_arrays.append(descr)

def builtin_func_for_spec(rtyper, oopspec_name, ll_args, ll_res):
    key = (oopspec_name, tuple(ll_args), ll_res)
    try:
        return rtyper._builtin_func_for_spec_cache[key]
    except (KeyError, AttributeError):
        pass
    args_s = [annmodel.lltype_to_annotation(v) for v in ll_args]
    if "." not in oopspec_name:  # 'newxxx' operations
        LIST_OR_DICT = ll_res
    else:
        LIST_OR_DICT = ll_args[0]
    s_result = annmodel.lltype_to_annotation(ll_res)
    impl = setup_extra_builtin(rtyper, oopspec_name, len(args_s))
    if getattr(impl, "need_result_type", False):
        bk = rtyper.annotator.bookkeeper
        args_s.insert(0, annmodel.SomePBC([bk.getdesc(deref(ll_res))]))
    #
    mixlevelann = MixLevelHelperAnnotator(rtyper)
    c_func = mixlevelann.constfunc(impl, args_s, s_result)
    mixlevelann.finish()
    #
    if not hasattr(rtyper, "_builtin_func_for_spec_cache"):
        rtyper._builtin_func_for_spec_cache = {}
    rtyper._builtin_func_for_spec_cache[key] = (c_func, LIST_OR_DICT)
    #
    return c_func, LIST_OR_DICT

 def test_immutable_subclass_2(self):
     from pypy.jit.metainterp.typesystem import deref
     class A(object):
         pass
     class B(A):
         _immutable_ = True
     def f():
         A()
         B().v = 123
         return B()
     t, typer, graph = self.gengraph(f, [])
     B_TYPE = deref(graph.getreturnvar().concretetype)
     assert B_TYPE._hints["immutable"]

 def test_immutable_subclass_void(self):
     from pypy.jit.metainterp.typesystem import deref
     class A(object):
         pass
     class B(A):
         _immutable_ = True
     def myfunc():
         pass
     def f():
         A().f = myfunc    # it's ok to add Void attributes to A
         B().v = 123       # even though only B is declared _immutable_
         return B()
     t, typer, graph = self.gengraph(f, [])
     B_TYPE = deref(graph.getreturnvar().concretetype)
     assert B_TYPE._hints["immutable"]

def effectinfo_from_writeanalyze(effects, cpu,
                                 forces_virtual_or_virtualizable=False):
    from pypy.translator.backendopt.writeanalyze import top_set
    if effects is top_set:
        return None
    readonly_descrs_fields = []
    # readonly_descrs_arrays = [] --- not enabled for now
    write_descrs_fields = []
    write_descrs_arrays = []

    def add_struct(descrs_fields, (_, T, fieldname)):
        T = deref(T)
        if consider_struct(T, fieldname):
            descr = cpu.fielddescrof(T, fieldname)
            descrs_fields.append(descr)

def effectinfo_from_writeanalyze(effects, cpu,
                                 extraeffect=EffectInfo.EF_CAN_RAISE,
                                 oopspecindex=EffectInfo.OS_NONE,
                                 can_invalidate=False):
    from pypy.translator.backendopt.writeanalyze import top_set
    if effects is top_set:
        return None
    readonly_descrs_fields = []
    # readonly_descrs_arrays = [] --- not enabled for now
    write_descrs_fields = []
    write_descrs_arrays = []

    def add_struct(descrs_fields, (_, T, fieldname)):
        T = deref(T)
        if consider_struct(T, fieldname):
            descr = cpu.fielddescrof(T, fieldname)
            descrs_fields.append(descr)

    def test_immutable_fields(self):
        from pypy.jit.metainterp.typesystem import deref
        class A(object):
            _immutable_fields_ = ["x", "y[*]"]

            def __init__(self, x, y):
                self.x = x
                self.y = y

        def f():
            return A(3, [])
        t, typer, graph = self.gengraph(f, [])
        A_TYPE = deref(graph.getreturnvar().concretetype)
        accessor = A_TYPE._hints["immutable_fields"]
        assert accessor.fields == {"inst_x": IR_IMMUTABLE,
                                   "inst_y": IR_IMMUTABLE_ARRAY} or \
               accessor.fields == {"ox": IR_IMMUTABLE,
                                   "oy": IR_IMMUTABLE_ARRAY} # for ootype

 def test_immutable_ok_inheritance_2(self):
     from pypy.jit.metainterp.typesystem import deref
     class A(object):
         _immutable_fields_ = ['v']
     class B(A):
         _immutable_ = True
     def f():
         A().v = 123
         B().w = 456
         return B()
     t, typer, graph = self.gengraph(f, [])
     B_TYPE = deref(graph.getreturnvar().concretetype)
     assert B_TYPE._hints["immutable"]
     try:
         A_TYPE = B_TYPE.super
     except AttributeError:
         A_TYPE = B_TYPE._superclass  # for ootype
     accessor = A_TYPE._hints["immutable_fields"]
     assert accessor.fields == {"inst_v": IR_IMMUTABLE} or \
            accessor.fields == {"ov": IR_IMMUTABLE} # for ootype

    from pypy.translator.backendopt.writeanalyze import top_set
    if effects is top_set:
        return None
    readonly_descrs_fields = []
    # readonly_descrs_arrays = [] --- not enabled for now
    write_descrs_fields = []
    write_descrs_arrays = []

    def add_struct(descrs_fields, (_, T, fieldname)):
        T = deref(T)
        if consider_struct(T, fieldname):
            descr = cpu.fielddescrof(T, fieldname)
            descrs_fields.append(descr)

    def add_array(descrs_arrays, (_, T)):
        ARRAY = deref(T)
        if consider_array(ARRAY):
            descr = cpu.arraydescrof(ARRAY)
            descrs_arrays.append(descr)

    for tup in effects:
        if tup[0] == "struct":
            add_struct(write_descrs_fields, tup)
        elif tup[0] == "readstruct":
            tupw = ("struct",) + tup[1:]
            if tupw not in effects:
                add_struct(readonly_descrs_fields, tup)
        elif tup[0] == "array":
            add_array(write_descrs_arrays, tup)
        elif tup[0] == "readarray":
            pass

    def __init__(self, warmrunnerdesc, VTYPEPTR):
        self.warmrunnerdesc = warmrunnerdesc
        cpu = warmrunnerdesc.cpu
        if cpu.ts.name == 'ootype':
            import py
            py.test.skip("ootype: fix virtualizables")
        self.cpu = cpu
        self.BoxArray = cpu.ts.BoxRef
        #
        while 'virtualizable2_accessor' not in deref(VTYPEPTR)._hints:
            VTYPEPTR = cpu.ts.get_superclass(VTYPEPTR)
        self.VTYPEPTR = VTYPEPTR
        self.VTYPE = VTYPE = deref(VTYPEPTR)
        self.vable_token_descr = cpu.fielddescrof(VTYPE, 'vable_token')
        #
        accessor = VTYPE._hints['virtualizable2_accessor']
        all_fields = accessor.fields
        static_fields = []
        array_fields = []
        for name, tp in all_fields.iteritems():
            if tp == IR_IMMUTABLE_ARRAY:
                array_fields.append(name)
            elif tp == IR_IMMUTABLE:
                static_fields.append(name)
            else:
                raise Exception("unknown type: %s" % tp)
        self.static_fields = static_fields
        self.array_fields = array_fields
        #
        FIELDTYPES = [fieldType(VTYPE, name) for name in static_fields]
        ARRAYITEMTYPES = []
        for name in array_fields:
            ARRAYPTR = fieldType(VTYPE, name)
            ARRAY = deref(ARRAYPTR)
            assert isinstance(ARRAYPTR, (lltype.Ptr, ootype.Array))
            assert isinstance(ARRAY, (lltype.GcArray, ootype.Array))
            ARRAYITEMTYPES.append(arrayItem(ARRAY))
        self.array_descrs = [cpu.arraydescrof(deref(fieldType(VTYPE, name)))
                             for name in array_fields]
        #
        self.num_static_extra_boxes = len(static_fields)
        self.num_arrays = len(array_fields)
        self.static_field_to_extra_box = dict(
            [(name, i) for (i, name) in enumerate(static_fields)])
        self.array_field_counter = dict(
            [(name, i) for (i, name) in enumerate(array_fields)])
        self.static_extra_types = [history.getkind(TYPE)
                                   for TYPE in FIELDTYPES]
        self.arrayitem_extra_types = [history.getkind(ITEM)
                                      for ITEM in ARRAYITEMTYPES]
        self.static_field_descrs = [cpu.fielddescrof(VTYPE, name)
                                    for name in static_fields]
        self.array_field_descrs = [cpu.fielddescrof(VTYPE, name)
                                   for name in array_fields]
        self.static_field_by_descrs = dict(
            [(descr, i) for (i, descr) in enumerate(self.static_field_descrs)])
        self.array_field_by_descrs = dict(
            [(descr, i) for (i, descr) in enumerate(self.array_field_descrs)])
        #
        getlength = cpu.ts.getlength
        getarrayitem = cpu.ts.getarrayitem
        setarrayitem = cpu.ts.setarrayitem
        #
        def read_boxes(cpu, virtualizable):
            assert lltype.typeOf(virtualizable) == llmemory.GCREF
            virtualizable = cast_gcref_to_vtype(virtualizable)
            boxes = []
            for _, fieldname in unroll_static_fields:
                x = getattr(virtualizable, fieldname)
                boxes.append(wrap(cpu, x))
            for _, fieldname in unroll_array_fields:
                lst = getattr(virtualizable, fieldname)
                for i in range(getlength(lst)):
                    boxes.append(wrap(cpu, getarrayitem(lst, i)))
            return boxes
        #
        def write_boxes(virtualizable, boxes):
            virtualizable = cast_gcref_to_vtype(virtualizable)
            i = 0
            for FIELDTYPE, fieldname in unroll_static_fields:
                x = unwrap(FIELDTYPE, boxes[i])
                setattr(virtualizable, fieldname, x)
                i = i + 1
            for ARRAYITEMTYPE, fieldname in unroll_array_fields:
                lst = getattr(virtualizable, fieldname)
                for j in range(getlength(lst)):
                    x = unwrap(ARRAYITEMTYPE, boxes[i])
                    setarrayitem(lst, j, x)
                    i = i + 1
            assert len(boxes) == i + 1
        #
        def write_from_resume_data_partial(virtualizable, reader, numb):
            virtualizable = cast_gcref_to_vtype(virtualizable)
            # Load values from the reader (see resume.py) described by
            # the list of numbers 'nums', and write them in their proper
            # place in the 'virtualizable'.  This works from the end of
            # the list and returns the index in 'nums' of the start of
            # the virtualizable data found, allowing the caller to do
            # further processing with the start of the list.
            i = len(numb.nums) - 1
#.........这里部分代码省略.........

 def __init__(self, warmrunnerdesc):
     self.warmrunnerdesc = warmrunnerdesc
     jitdriver = warmrunnerdesc.jitdriver
     cpu = warmrunnerdesc.cpu
     self.cpu = cpu
     self.VABLERTI = cpu.ts.get_VABLERTI()
     self.null_vable_rti = cpu.ts.nullptr(deref(self.VABLERTI))
     self.BoxArray = cpu.ts.BoxRef
     #
     assert len(jitdriver.virtualizables) == 1    # for now
     [vname] = jitdriver.virtualizables
     index = len(jitdriver.greens) + jitdriver.reds.index(vname)
     self.index_of_virtualizable = index
     VTYPEPTR = warmrunnerdesc.JIT_ENTER_FUNCTYPE.ARGS[index]
     while 'virtualizable2_accessor' not in deref(VTYPEPTR)._hints:
         VTYPEPTR = cpu.ts.get_superclass(VTYPEPTR)
     self.VTYPEPTR = VTYPEPTR
     self.VTYPE = VTYPE = deref(VTYPEPTR)
     self.null_vable = cpu.ts.nullptr(VTYPE)
     #
     accessor = VTYPE._hints['virtualizable2_accessor']
     all_fields = accessor.fields
     static_fields = []
     array_fields = []
     for name, suffix in all_fields.iteritems():
         if suffix == '[*]':
             array_fields.append(name)
         else:
             static_fields.append(name)
     self.static_fields = static_fields
     self.array_fields = array_fields
     #
     FIELDTYPES = [fieldType(VTYPE, name) for name in static_fields]
     ARRAYITEMTYPES = []
     for name in array_fields:
         ARRAYPTR = fieldType(VTYPE, name)
         ARRAY = deref(ARRAYPTR)
         assert isinstance(ARRAYPTR, (lltype.Ptr, ootype.Array))
         assert isinstance(ARRAY, (lltype.GcArray, ootype.Array))
         ARRAYITEMTYPES.append(arrayItem(ARRAY))
     self.array_descrs = [cpu.arraydescrof(deref(fieldType(VTYPE, name)))
                          for name in array_fields]
     #
     self.num_static_extra_boxes = len(static_fields)
     self.num_arrays = len(array_fields)
     self.static_field_to_extra_box = dict(
         [(name, i) for (i, name) in enumerate(static_fields)])
     self.array_field_counter = dict(
         [(name, i) for (i, name) in enumerate(array_fields)])
     self.static_extra_types = [history.getkind(TYPE)
                                for TYPE in FIELDTYPES]
     self.arrayitem_extra_types = [history.getkind(ITEM)
                                   for ITEM in ARRAYITEMTYPES]
     self.static_field_descrs = [cpu.fielddescrof(VTYPE, name)
                                 for name in static_fields]
     self.array_field_descrs = [cpu.fielddescrof(VTYPE, name)
                                for name in array_fields]
     #
     getlength = cpu.ts.getlength
     getarrayitem = cpu.ts.getarrayitem
     setarrayitem = cpu.ts.setarrayitem
     #
     def read_boxes(cpu, virtualizable):
         boxes = []
         for _, fieldname in unroll_static_fields:
             x = getattr(virtualizable, fieldname)
             boxes.append(wrap(cpu, x))
         for _, fieldname in unroll_array_fields:
             lst = getattr(virtualizable, fieldname)
             for i in range(getlength(lst)):
                 boxes.append(wrap(cpu, getarrayitem(lst, i)))
         return boxes
     #
     def write_boxes(virtualizable, boxes):
         i = 0
         for FIELDTYPE, fieldname in unroll_static_fields:
             x = unwrap(FIELDTYPE, boxes[i])
             setattr(virtualizable, fieldname, x)
             i = i + 1
         for ARRAYITEMTYPE, fieldname in unroll_array_fields:
             lst = getattr(virtualizable, fieldname)
             for j in range(getlength(lst)):
                 x = unwrap(ARRAYITEMTYPE, boxes[i])
                 setarrayitem(lst, j, x)
                 i = i + 1
         assert len(boxes) == i + 1
     #
     def check_boxes(virtualizable, boxes):
         # for debugging
         i = 0
         for FIELDTYPE, fieldname in unroll_static_fields:
             x = unwrap(FIELDTYPE, boxes[i])
             assert getattr(virtualizable, fieldname) == x
             i = i + 1
         for ARRAYITEMTYPE, fieldname in unroll_array_fields:
             lst = getattr(virtualizable, fieldname)
             for j in range(getlength(lst)):
                 x = unwrap(ARRAYITEMTYPE, boxes[i])
                 assert getarrayitem(lst, j) == x
                 i = i + 1
#.........这里部分代码省略.........