/rpython/jit/backend/llsupport/test/test_rewrite.py
Python | 1431 lines | 1398 code | 18 blank | 15 comment | 14 complexity | 4099a8a8ffdf7a27f48dd6c6b3b5259c MD5 | raw file
Possible License(s): AGPL-3.0, BSD-3-Clause, Apache-2.0
Large files files are truncated, but you can click here to view the full file
- import py
- from rpython.jit.backend.llsupport.descr import get_size_descr,\
- get_field_descr, get_array_descr, ArrayDescr, FieldDescr,\
- SizeDescr, get_interiorfield_descr
- from rpython.jit.backend.llsupport.gc import GcLLDescr_boehm,\
- GcLLDescr_framework
- from rpython.jit.backend.llsupport import jitframe
- from rpython.jit.metainterp.gc import get_description
- from rpython.jit.tool.oparser import parse
- from rpython.jit.metainterp.optimizeopt.util import equaloplists
- from rpython.jit.metainterp.history import JitCellToken, FLOAT
- from rpython.jit.metainterp.history import AbstractFailDescr
- from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
- from rpython.rtyper import rclass
- from rpython.jit.backend.llsupport.symbolic import (WORD,
- get_array_token)
- class Evaluator(object):
- def __init__(self, scope):
- self.scope = scope
- def __getitem__(self, key):
- return eval(key, self.scope)
- class FakeLoopToken(object):
- pass
- o_vtable = lltype.malloc(rclass.OBJECT_VTABLE, immortal=True)
- class RewriteTests(object):
- def check_rewrite(self, frm_operations, to_operations, **namespace):
- def setfield(baseptr, newvalue, descr):
- assert isinstance(baseptr, str)
- assert isinstance(newvalue, (str, int))
- assert not isinstance(descr, (str, int))
- return 'gc_store(%s, %d, %s, %d)' % (baseptr, descr.offset,
- newvalue, descr.field_size)
- def zero_array(baseptr, start, length, descr_name, descr):
- assert isinstance(baseptr, str)
- assert isinstance(start, (str, int))
- assert isinstance(length, (str, int))
- assert isinstance(descr_name, str)
- assert not isinstance(descr, (str,int))
- itemsize = descr.itemsize
- start = start * itemsize
- length_scale = 1
- if isinstance(length, str):
- length_scale = itemsize
- else:
- length = length * itemsize
- return 'zero_array(%s, %s, %s, 1, %d, descr=%s)' % \
- (baseptr, start, length, length_scale, descr_name)
- def setarrayitem(baseptr, index, newvalue, descr):
- assert isinstance(baseptr, str)
- assert isinstance(index, (str, int))
- assert isinstance(newvalue, (str, int))
- assert not isinstance(descr, (str, int))
- if isinstance(index, int):
- offset = descr.basesize + index * descr.itemsize
- return 'gc_store(%s, %d, %s, %d)' % (baseptr, offset,
- newvalue, descr.itemsize)
- else:
- return 'gc_store_indexed(%s, %s, %s, %d, %d, %s)' % (
- baseptr, index, newvalue,
- descr.itemsize, descr.basesize, descr.itemsize)
- #
- WORD = globals()['WORD']
- S = lltype.GcStruct('S', ('x', lltype.Signed),
- ('y', lltype.Signed))
- sdescr = get_size_descr(self.gc_ll_descr, S)
- sdescr.tid = 1234
- #
- T = lltype.GcStruct('T', ('y', lltype.Signed),
- ('z', lltype.Ptr(S)),
- ('t', lltype.Signed))
- tdescr = get_size_descr(self.gc_ll_descr, T)
- tdescr.tid = 5678
- tzdescr = get_field_descr(self.gc_ll_descr, T, 'z')
- myT = lltype.cast_opaque_ptr(llmemory.GCREF,
- lltype.malloc(T, zero=True))
- self.myT = myT
- #
- A = lltype.GcArray(lltype.Signed)
- adescr = get_array_descr(self.gc_ll_descr, A)
- adescr.tid = 4321
- alendescr = adescr.lendescr
- #
- B = lltype.GcArray(lltype.Char)
- bdescr = get_array_descr(self.gc_ll_descr, B)
- bdescr.tid = 8765
- blendescr = bdescr.lendescr
- #
- C = lltype.GcArray(lltype.Ptr(S))
- cdescr = get_array_descr(self.gc_ll_descr, C)
- cdescr.tid = 8111
- clendescr = cdescr.lendescr
- #
- S1 = lltype.GcStruct('S1')
- S1I = lltype.GcArray(('x', lltype.Ptr(S1)),
- ('y', lltype.Ptr(S1)),
- ('z', lltype.Ptr(S1)))
- itzdescr = get_interiorfield_descr(self.gc_ll_descr, S1I, 'z')
- itydescr = get_interiorfield_descr(self.gc_ll_descr, S1I, 'y')
- itxdescr = get_interiorfield_descr(self.gc_ll_descr, S1I, 'x')
- S2I = lltype.GcArray(('x', lltype.Ptr(S1)),
- ('y', lltype.Ptr(S1)),
- ('z', lltype.Ptr(S1)),
- ('t', lltype.Ptr(S1))) # size is a power of two
- s2i_item_size_in_bits = (4 if WORD == 4 else 5)
- ity2descr = get_interiorfield_descr(self.gc_ll_descr, S2I, 'y')
- R1 = lltype.GcStruct('R', ('x', lltype.Signed),
- ('y', lltype.Float),
- ('z', lltype.Ptr(S1)))
- xdescr = get_field_descr(self.gc_ll_descr, R1, 'x')
- ydescr = get_field_descr(self.gc_ll_descr, R1, 'y')
- zdescr = get_field_descr(self.gc_ll_descr, R1, 'z')
- myR1 = lltype.cast_opaque_ptr(llmemory.GCREF,
- lltype.malloc(R1, zero=True))
- myR1b = lltype.cast_opaque_ptr(llmemory.GCREF,
- lltype.malloc(R1, zero=True))
- self.myR1 = myR1
- self.myR1b = myR1b
- #
- E = lltype.GcStruct('Empty')
- edescr = get_size_descr(self.gc_ll_descr, E)
- edescr.tid = 9000
- #
- vtable_descr = self.gc_ll_descr.fielddescr_vtable
- O = lltype.GcStruct('O', ('parent', rclass.OBJECT),
- ('x', lltype.Signed))
- o_descr = self.cpu.sizeof(O, True)
- o_vtable = globals()['o_vtable']
- #
- tiddescr = self.gc_ll_descr.fielddescr_tid
- wbdescr = self.gc_ll_descr.write_barrier_descr
- #
- F = lltype.GcArray(lltype.Float)
- fdescr = get_array_descr(self.gc_ll_descr, F)
- SF = lltype.GcArray(lltype.SingleFloat)
- sfdescr = get_array_descr(self.gc_ll_descr, SF)
- RAW_SF = lltype.Array(lltype.SingleFloat)
- raw_sfdescr = get_array_descr(self.gc_ll_descr, RAW_SF)
- #
- strdescr = self.gc_ll_descr.str_descr
- unicodedescr = self.gc_ll_descr.unicode_descr
- strlendescr = strdescr.lendescr
- unicodelendescr = unicodedescr.lendescr
- strhashdescr = self.gc_ll_descr.str_hash_descr
- unicodehashdescr = self.gc_ll_descr.unicode_hash_descr
- casmdescr = JitCellToken()
- clt = FakeLoopToken()
- clt._ll_initial_locs = [0, 8]
- frame_info = lltype.malloc(jitframe.JITFRAMEINFO, flavor='raw')
- clt.frame_info = frame_info
- frame_info.jfi_frame_depth = 13
- frame_info.jfi_frame_size = 255
- framedescrs = self.gc_ll_descr.getframedescrs(self.cpu)
- framelendescr = framedescrs.arraydescr.lendescr
- jfi_frame_depth = framedescrs.jfi_frame_depth
- jfi_frame_size = framedescrs.jfi_frame_size
- jf_frame_info = framedescrs.jf_frame_info
- jf_savedata = framedescrs.jf_savedata
- jf_force_descr = framedescrs.jf_force_descr
- jf_descr = framedescrs.jf_descr
- jf_guard_exc = framedescrs.jf_guard_exc
- jf_forward = framedescrs.jf_forward
- jf_extra_stack_depth = framedescrs.jf_extra_stack_depth
- signedframedescr = self.cpu.signedframedescr
- floatframedescr = self.cpu.floatframedescr
- casmdescr.compiled_loop_token = clt
- #
- guarddescr = AbstractFailDescr()
- #
- namespace.update(locals())
- #
- for funcname in self.gc_ll_descr._generated_functions:
- namespace[funcname] = self.gc_ll_descr.get_malloc_fn(funcname)
- namespace[funcname + '_descr'] = getattr(self.gc_ll_descr,
- '%s_descr' % funcname)
- #
- ops = parse(frm_operations, namespace=namespace)
- expected = parse(to_operations % Evaluator(namespace),
- namespace=namespace)
- self.gcrefs = []
- operations = self.gc_ll_descr.rewrite_assembler(self.cpu,
- ops.operations,
- self.gcrefs)
- remap = {}
- for a, b in zip(ops.inputargs, expected.inputargs):
- remap[b] = a
- equaloplists(operations, expected.operations, remap=remap)
- lltype.free(frame_info, flavor='raw')
- class FakeTracker(object):
- pass
- class BaseFakeCPU(object):
- JITFRAME_FIXED_SIZE = 0
- load_constant_offset = True
- load_supported_factors = (1,2,4,8)
- translate_support_code = None
- def __init__(self):
- self.tracker = FakeTracker()
- self._cache = {}
- self.signedframedescr = ArrayDescr(3, 8, FieldDescr('len', 0, 0, 0), 0)
- self.floatframedescr = ArrayDescr(5, 8, FieldDescr('len', 0, 0, 0), 0)
- def getarraydescr_for_frame(self, tp):
- if tp == FLOAT:
- return self.floatframedescr
- return self.signedframedescr
- def unpack_arraydescr_size(self, d):
- return 0, d.itemsize, 0
- def unpack_fielddescr(self, d):
- return d.offset
- def arraydescrof(self, ARRAY):
- try:
- return self._cache[ARRAY]
- except KeyError:
- r = ArrayDescr(1, 2, FieldDescr('len', 0, 0, 0), 0)
- self._cache[ARRAY] = r
- return r
- def fielddescrof(self, STRUCT, fname):
- key = (STRUCT, fname)
- try:
- return self._cache[key]
- except KeyError:
- r = FieldDescr(fname, 1, 1, 1)
- self._cache[key] = r
- return r
- class TestBoehm(RewriteTests):
- def setup_method(self, meth):
- class FakeCPU(BaseFakeCPU):
- def sizeof(self, STRUCT, is_object):
- assert is_object
- return SizeDescr(102, gc_fielddescrs=[],
- vtable=o_vtable)
- self.cpu = FakeCPU()
- self.gc_ll_descr = GcLLDescr_boehm(None, None, None)
- def test_new(self):
- self.check_rewrite("""
- []
- p0 = new(descr=sdescr)
- jump()
- """, """
- [p1]
- p0 = call_r(ConstClass(malloc_fixedsize), %(sdescr.size)d,\
- descr=malloc_fixedsize_descr)
- check_memory_error(p0)
- jump()
- """)
- def test_no_collapsing(self):
- self.check_rewrite("""
- []
- p0 = new(descr=sdescr)
- p1 = new(descr=sdescr)
- jump()
- """, """
- []
- p0 = call_r(ConstClass(malloc_fixedsize), %(sdescr.size)d,\
- descr=malloc_fixedsize_descr)
- check_memory_error(p0)
- p1 = call_r(ConstClass(malloc_fixedsize), %(sdescr.size)d,\
- descr=malloc_fixedsize_descr)
- check_memory_error(p1)
- jump()
- """)
- def test_new_array_fixed(self):
- self.check_rewrite("""
- []
- p0 = new_array(10, descr=adescr)
- jump()
- """, """
- []
- p0 = call_r(ConstClass(malloc_array), \
- %(adescr.basesize)d, \
- 10, \
- %(adescr.itemsize)d, \
- %(adescr.lendescr.offset)d, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- ## should ideally be:
- ## p0 = call_r(ConstClass(malloc_fixedsize), \
- ## %(adescr.basesize + 10 * adescr.itemsize)d, \
- ## descr=malloc_fixedsize_descr)
- ## setfield_gc(p0, 10, descr=alendescr)
- def test_new_array_variable(self):
- self.check_rewrite("""
- [i1]
- p0 = new_array(i1, descr=adescr)
- jump()
- """, """
- [i1]
- p0 = call_r(ConstClass(malloc_array), \
- %(adescr.basesize)d, \
- i1, \
- %(adescr.itemsize)d, \
- %(adescr.lendescr.offset)d, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- def test_new_with_vtable(self):
- self.check_rewrite("""
- []
- p0 = new_with_vtable(descr=o_descr)
- jump()
- """, """
- [p1]
- p0 = call_r(ConstClass(malloc_fixedsize), 102, \
- descr=malloc_fixedsize_descr)
- check_memory_error(p0)
- gc_store(p0, 0, ConstClass(o_vtable), %(vtable_descr.field_size)s)
- jump()
- """)
- def test_newstr(self):
- self.check_rewrite("""
- [i1]
- p0 = newstr(i1)
- jump()
- """, """
- [i1]
- p0 = call_r(ConstClass(malloc_array), \
- %(strdescr.basesize)d, \
- i1, \
- %(strdescr.itemsize)d, \
- %(strlendescr.offset)d, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- def test_newunicode(self):
- self.check_rewrite("""
- [i1]
- p0 = newunicode(10)
- jump()
- """, """
- [i1]
- p0 = call_r(ConstClass(malloc_array), \
- %(unicodedescr.basesize)d, \
- 10, \
- %(unicodedescr.itemsize)d, \
- %(unicodelendescr.offset)d, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- ## should ideally be:
- ## p0 = call_r(ConstClass(malloc_fixedsize), \
- ## %(unicodedescr.basesize + \
- ## 10 * unicodedescr.itemsize)d, \
- ## descr=malloc_fixedsize_descr)
- ## setfield_gc(p0, 10, descr=unicodelendescr)
- class TestFramework(RewriteTests):
- def setup_method(self, meth):
- class config_(object):
- class translation(object):
- gc = 'minimark'
- gcrootfinder = 'asmgcc'
- gctransformer = 'framework'
- gcremovetypeptr = False
- gcdescr = get_description(config_)
- self.gc_ll_descr = GcLLDescr_framework(gcdescr, None, None, None,
- really_not_translated=True)
- self.gc_ll_descr.write_barrier_descr.has_write_barrier_from_array = (
- lambda cpu: True)
- self.gc_ll_descr.malloc_zero_filled = False
- #
- class FakeCPU(BaseFakeCPU):
- def sizeof(self, STRUCT, is_object):
- descr = SizeDescr(104, gc_fielddescrs=[])
- descr.tid = 9315
- return descr
- self.cpu = FakeCPU()
- def test_rewrite_assembler_new_to_malloc(self):
- self.check_rewrite("""
- [p1]
- p0 = new(descr=sdescr)
- jump()
- """, """
- [p1]
- p0 = call_malloc_nursery(%(sdescr.size)d)
- gc_store(p0, 0, 1234, 8)
- jump()
- """)
- def test_rewrite_assembler_new3_to_malloc(self):
- self.check_rewrite("""
- []
- p0 = new(descr=sdescr)
- p1 = new(descr=tdescr)
- p2 = new(descr=sdescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery( \
- %(sdescr.size + tdescr.size + sdescr.size)d)
- gc_store(p0, 0, 1234, 8)
- p1 = nursery_ptr_increment(p0, %(sdescr.size)d)
- gc_store(p1, 0, 5678, 8)
- p2 = nursery_ptr_increment(p1, %(tdescr.size)d)
- gc_store(p2, 0, 1234, 8)
- %(setfield('p1', 0, tdescr.gc_fielddescrs[0]))s
- jump()
- """)
- def test_rewrite_assembler_new_array_fixed_to_malloc(self):
- self.check_rewrite("""
- []
- p0 = new_array(10, descr=adescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery( \
- %(adescr.basesize + 10 * adescr.itemsize)d)
- gc_store(p0, 0, 4321, %(tiddescr.field_size)s)
- gc_store(p0, 0, 10, %(alendescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_new_and_new_array_fixed_to_malloc(self):
- self.check_rewrite("""
- []
- p0 = new(descr=sdescr)
- p1 = new_array(10, descr=adescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery( \
- %(sdescr.size + \
- adescr.basesize + 10 * adescr.itemsize)d)
- gc_store(p0, 0, 1234, %(tiddescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(sdescr.size)d)
- gc_store(p1, 0, 4321, %(tiddescr.field_size)s)
- gc_store(p1, 0, 10, %(alendescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_round_up(self):
- self.check_rewrite("""
- []
- p0 = new_array(6, descr=bdescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery(%(bdescr.basesize + 8)d)
- gc_store(p0, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p0, 0, 6, %(blendescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_round_up_always(self):
- self.check_rewrite("""
- []
- p0 = new_array(5, descr=bdescr)
- p1 = new_array(5, descr=bdescr)
- p2 = new_array(5, descr=bdescr)
- p3 = new_array(5, descr=bdescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery(%(4 * (bdescr.basesize + 8))d)
- gc_store(p0, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(blendescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(bdescr.basesize + 8)d)
- gc_store(p1, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p1, 0, 5, %(blendescr.field_size)s)
- p2 = nursery_ptr_increment(p1, %(bdescr.basesize + 8)d)
- gc_store(p2, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p2, 0, 5, %(blendescr.field_size)s)
- p3 = nursery_ptr_increment(p2, %(bdescr.basesize + 8)d)
- gc_store(p3, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p3, 0, 5, %(blendescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_minimal_size(self):
- self.check_rewrite("""
- []
- p0 = new(descr=edescr)
- p1 = new(descr=edescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery(%(4*WORD)d)
- gc_store(p0, 0, 9000, %(tiddescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(2*WORD)d)
- gc_store(p1, 0, 9000, %(tiddescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_variable_size(self):
- self.check_rewrite("""
- [i0]
- p0 = new_array(i0, descr=bdescr)
- jump(i0)
- """, """
- [i0]
- p0 = call_malloc_nursery_varsize(0, 1, i0, descr=bdescr)
- gc_store(p0, 0, i0, %(bdescr.basesize)s)
- jump(i0)
- """)
- def test_rewrite_new_string(self):
- self.check_rewrite("""
- [i0]
- p0 = newstr(i0)
- jump(i0)
- """, """
- [i0]
- p0 = call_malloc_nursery_varsize(1, 1, i0, descr=strdescr)
- gc_store(p0, %(strlendescr.offset)s, i0, %(strlendescr.field_size)s)
- gc_store(p0, 0, 0, %(strlendescr.field_size)s)
- jump(i0)
- """)
- def test_rewrite_assembler_nonstandard_array(self):
- # a non-standard array is a bit hard to get; e.g. GcArray(Float)
- # is like that on Win32, but not on Linux. Build one manually...
- NONSTD = lltype.GcArray(lltype.Float)
- nonstd_descr = get_array_descr(self.gc_ll_descr, NONSTD)
- nonstd_descr.tid = 6464
- nonstd_descr.basesize = 64 # <= hacked
- nonstd_descr.itemsize = 8
- nonstd_descr_gcref = 123
- # REVIEW: added descr=nonstd_descr to setarrayitem
- # is it even valid to have a setarrayitem WITHOUT a descr?
- self.check_rewrite("""
- [i0, p1]
- p0 = new_array(i0, descr=nonstd_descr)
- setarrayitem_gc(p0, i0, p1, descr=nonstd_descr)
- jump(i0)
- """, """
- [i0, p1]
- p0 = call_r(ConstClass(malloc_array_nonstandard), \
- 64, 8, \
- %(nonstd_descr.lendescr.offset)d, \
- 6464, i0, \
- descr=malloc_array_nonstandard_descr)
- check_memory_error(p0)
- cond_call_gc_wb_array(p0, i0, descr=wbdescr)
- gc_store_indexed(p0, i0, p1, 8, 64, 8)
- jump(i0)
- """, nonstd_descr=nonstd_descr)
- def test_rewrite_assembler_maximal_size_1(self):
- self.gc_ll_descr.max_size_of_young_obj = 100
- self.check_rewrite("""
- []
- p0 = new_array(103, descr=bdescr)
- jump()
- """, """
- []
- p0 = call_r(ConstClass(malloc_array), 1, \
- %(bdescr.tid)d, 103, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- def test_rewrite_assembler_maximal_size_2(self):
- self.gc_ll_descr.max_size_of_young_obj = 300
- self.check_rewrite("""
- []
- p0 = new_array(101, descr=bdescr)
- p1 = new_array(102, descr=bdescr) # two new_arrays can be combined
- p2 = new_array(103, descr=bdescr) # but not all three
- jump()
- """, """
- []
- p0 = call_malloc_nursery( \
- %(2 * (bdescr.basesize + 104))d)
- gc_store(p0, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p0, 0, 101, %(blendescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(bdescr.basesize + 104)d)
- gc_store(p1, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p1, 0, 102, %(blendescr.field_size)s)
- p2 = call_malloc_nursery( \
- %(bdescr.basesize + 104)d)
- gc_store(p2, 0, 8765, %(tiddescr.field_size)s)
- gc_store(p2, 0, 103, %(blendescr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_huge_size(self):
- # "huge" is defined as "larger than 0xffffff bytes, or 16MB"
- self.check_rewrite("""
- []
- p0 = new_array(20000000, descr=bdescr)
- jump()
- """, """
- []
- p0 = call_r(ConstClass(malloc_array), 1, \
- %(bdescr.tid)d, 20000000, \
- descr=malloc_array_descr)
- check_memory_error(p0)
- jump()
- """)
- def test_new_with_vtable(self):
- self.check_rewrite("""
- []
- p0 = new_with_vtable(descr=o_descr)
- jump()
- """, """
- [p1]
- p0 = call_malloc_nursery(104) # rounded up
- gc_store(p0, 0, 9315, %(tiddescr.field_size)s)
- gc_store(p0, 0, 0, %(vtable_descr.field_size)s)
- jump()
- """)
- def test_new_with_vtable_too_big(self):
- self.gc_ll_descr.max_size_of_young_obj = 100
- self.check_rewrite("""
- []
- p0 = new_with_vtable(descr=o_descr)
- jump()
- """, """
- [p1]
- p0 = call_r(ConstClass(malloc_big_fixedsize), 104, 9315, \
- descr=malloc_big_fixedsize_descr)
- check_memory_error(p0)
- gc_store(p0, 0, 0, %(vtable_descr.field_size)s)
- jump()
- """)
- def test_rewrite_assembler_newstr_newunicode(self):
- # note: strdescr.basesize already contains the extra final character,
- # so that's why newstr(14) is rounded up to 'basesize+15' and not
- # 'basesize+16'.
- self.check_rewrite("""
- [i2]
- p0 = newstr(14)
- p1 = newunicode(10)
- p2 = newunicode(i2)
- p3 = newstr(i2)
- jump()
- """, """
- [i2]
- p0 = call_malloc_nursery( \
- %(strdescr.basesize + 15 * strdescr.itemsize + \
- unicodedescr.basesize + 10 * unicodedescr.itemsize)d)
- gc_store(p0, 0, %(strdescr.tid)d, %(tiddescr.field_size)s)
- gc_store(p0, %(strlendescr.offset)s, 14, %(strlendescr.field_size)s)
- gc_store(p0, 0, 0, %(strhashdescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(strdescr.basesize + 15 * strdescr.itemsize)d)
- gc_store(p1, 0, %(unicodedescr.tid)d, %(tiddescr.field_size)s)
- gc_store(p1, %(unicodelendescr.offset)s, 10, %(unicodelendescr.field_size)s)
- gc_store(p1, 0, 0, %(unicodehashdescr.field_size)s)
- p2 = call_malloc_nursery_varsize(2, %(unicodedescr.itemsize)d, i2,\
- descr=unicodedescr)
- gc_store(p2, %(unicodelendescr.offset)s, i2, %(unicodelendescr.field_size)s)
- gc_store(p2, 0, 0, %(unicodehashdescr.field_size)s)
- p3 = call_malloc_nursery_varsize(1, 1, i2, \
- descr=strdescr)
- gc_store(p3, %(strlendescr.offset)s, i2, %(strlendescr.field_size)s)
- gc_store(p3, 0, 0, %(strhashdescr.field_size)s)
- jump()
- """)
- def test_write_barrier_before_setfield_gc(self):
- self.check_rewrite("""
- [p1, p2]
- setfield_gc(p1, p2, descr=tzdescr)
- jump()
- """, """
- [p1, p2]
- cond_call_gc_wb(p1, descr=wbdescr)
- gc_store(p1, %(tzdescr.offset)s, p2, %(tzdescr.field_size)s)
- jump()
- """)
- def test_write_barrier_before_array_without_from_array(self):
- self.gc_ll_descr.write_barrier_descr.has_write_barrier_from_array = (
- lambda cpu: False)
- self.check_rewrite("""
- [p1, i2, p3]
- setarrayitem_gc(p1, i2, p3, descr=cdescr)
- jump()
- """, """
- [p1, i2, p3]
- cond_call_gc_wb(p1, descr=wbdescr)
- %(setarrayitem('p1', 'i2', 'p3', cdescr))s
- jump()
- """)
- def test_write_barrier_before_short_array(self):
- self.gc_ll_descr.max_size_of_young_obj = 2000
- self.check_rewrite("""
- [i2, p3]
- p1 = new_array_clear(129, descr=cdescr)
- call_n(123456)
- setarrayitem_gc(p1, i2, p3, descr=cdescr)
- jump()
- """, """
- [i2, p3]
- p1 = call_malloc_nursery( \
- %(cdescr.basesize + 129 * cdescr.itemsize)d)
- gc_store(p1, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p1, 0, 129, %(clendescr.field_size)s)
- %(zero_array('p1', 0, 129, 'cdescr', cdescr))s
- call_n(123456)
- cond_call_gc_wb(p1, descr=wbdescr)
- %(setarrayitem('p1', 'i2', 'p3', cdescr))s
- jump()
- """)
- def test_write_barrier_before_long_array(self):
- # the limit of "being too long" is fixed, arbitrarily, at 130
- self.gc_ll_descr.max_size_of_young_obj = 2000
- self.check_rewrite("""
- [i2, p3]
- p1 = new_array_clear(130, descr=cdescr)
- call_n(123456)
- setarrayitem_gc(p1, i2, p3, descr=cdescr)
- jump()
- """, """
- [i2, p3]
- p1 = call_malloc_nursery( \
- %(cdescr.basesize + 130 * cdescr.itemsize)d)
- gc_store(p1, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p1, 0, 130, %(clendescr.field_size)s)
- %(zero_array('p1', 0, 130, 'cdescr', cdescr))s
- call_n(123456)
- cond_call_gc_wb_array(p1, i2, descr=wbdescr)
- %(setarrayitem('p1', 'i2', 'p3', cdescr))s
- jump()
- """)
- def test_write_barrier_before_unknown_array(self):
- self.check_rewrite("""
- [p1, i2, p3]
- setarrayitem_gc(p1, i2, p3, descr=cdescr)
- jump()
- """, """
- [p1, i2, p3]
- cond_call_gc_wb_array(p1, i2, descr=wbdescr)
- %(setarrayitem('p1', 'i2', 'p3', cdescr))s
- jump()
- """)
- def test_label_makes_size_unknown(self):
- self.check_rewrite("""
- [i2, p3]
- p1 = new_array_clear(5, descr=cdescr)
- label(p1, i2, p3)
- setarrayitem_gc(p1, i2, p3, descr=cdescr)
- jump()
- """, """
- [i2, p3]
- p1 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p1, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p1, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p1', 0, 5, 'cdescr', cdescr))s
- label(p1, i2, p3)
- cond_call_gc_wb_array(p1, i2, descr=wbdescr)
- %(setarrayitem('p1', 'i2', 'p3', cdescr))s
- jump()
- """)
- def test_write_barrier_before_setinteriorfield_gc(self):
- S1 = lltype.GcStruct('S1')
- INTERIOR = lltype.GcArray(('z', lltype.Ptr(S1)))
- interiordescr = get_array_descr(self.gc_ll_descr, INTERIOR)
- interiordescr.tid = 1291
- interiorlendescr = interiordescr.lendescr
- interiorzdescr = get_interiorfield_descr(self.gc_ll_descr,
- INTERIOR, 'z')
- scale = interiorzdescr.arraydescr.itemsize
- offset = interiorzdescr.arraydescr.basesize
- offset += interiorzdescr.fielddescr.offset
- size = interiorzdescr.arraydescr.itemsize
- self.check_rewrite("""
- [p1, p2]
- setinteriorfield_gc(p1, 7, p2, descr=interiorzdescr)
- jump(p1, p2)
- """, """
- [p1, p2]
- cond_call_gc_wb_array(p1, 7, descr=wbdescr)
- gc_store(p1, %(offset + 7 * scale)s, p2, %(size)s)
- jump(p1, p2)
- """, interiorzdescr=interiorzdescr, scale=scale,
- offset=offset, size=size)
- def test_initialization_store(self):
- self.check_rewrite("""
- [p1]
- p0 = new(descr=tdescr)
- setfield_gc(p0, p1, descr=tzdescr)
- jump()
- """, """
- [p1]
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tzdescr.offset)s, p1, %(tzdescr.field_size)s)
- jump()
- """)
- def test_initialization_store_2(self):
- self.check_rewrite("""
- []
- p0 = new(descr=tdescr)
- p1 = new(descr=sdescr)
- setfield_gc(p0, p1, descr=tzdescr)
- jump()
- """, """
- []
- p0 = call_malloc_nursery(%(tdescr.size + sdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- p1 = nursery_ptr_increment(p0, %(tdescr.size)d)
- gc_store(p1, 0, 1234, %(tiddescr.field_size)s)
- # <<<no cond_call_gc_wb here>>>
- gc_store(p0, %(tzdescr.offset)s, p1, %(tzdescr.field_size)s)
- jump()
- """)
- def test_initialization_store_array(self):
- self.check_rewrite("""
- [p1, i2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, i2, p1, descr=cdescr)
- jump()
- """, """
- [p1, i2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 0, 5, 'cdescr', cdescr))s
- %(setarrayitem('p0', 'i2', 'p1', cdescr))s
- jump()
- """)
- def test_zero_array_reduced_left(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 1, p1, descr=cdescr)
- setarrayitem_gc(p0, 0, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 2, 3, 'cdescr', cdescr))s
- %(setarrayitem('p0', 1, 'p1', cdescr))s
- %(setarrayitem('p0', 0, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_reduced_right(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 3, p1, descr=cdescr)
- setarrayitem_gc(p0, 4, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 0, 3, 'cdescr', cdescr))s
- %(setarrayitem('p0', 3, 'p1', cdescr))s
- %(setarrayitem('p0', 4, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_not_reduced_at_all(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 3, p1, descr=cdescr)
- setarrayitem_gc(p0, 2, p2, descr=cdescr)
- setarrayitem_gc(p0, 1, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 0, 5, 'cdescr', cdescr))s
- %(setarrayitem('p0', 3, 'p1', cdescr))s
- %(setarrayitem('p0', 2, 'p2', cdescr))s
- %(setarrayitem('p0', 1, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_reduced_completely(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 3, p1, descr=cdescr)
- setarrayitem_gc(p0, 4, p2, descr=cdescr)
- setarrayitem_gc(p0, 0, p1, descr=cdescr)
- setarrayitem_gc(p0, 2, p2, descr=cdescr)
- setarrayitem_gc(p0, 1, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 5, 0, 'cdescr', cdescr))s
- %(setarrayitem('p0', 3, 'p1', cdescr))s
- %(setarrayitem('p0', 4, 'p2', cdescr))s
- %(setarrayitem('p0', 0, 'p1', cdescr))s
- %(setarrayitem('p0', 2, 'p2', cdescr))s
- %(setarrayitem('p0', 1, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_reduced_left_with_call(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 0, p1, descr=cdescr)
- call_n(321321)
- setarrayitem_gc(p0, 1, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 1, 4, 'cdescr', cdescr))s
- %(setarrayitem('p0', 0, 'p1', cdescr))s
- call_n(321321)
- cond_call_gc_wb(p0, descr=wbdescr)
- %(setarrayitem('p0', 1, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_reduced_left_with_label(self):
- self.check_rewrite("""
- [p1, p2]
- p0 = new_array_clear(5, descr=cdescr)
- setarrayitem_gc(p0, 0, p1, descr=cdescr)
- label(p0, p2)
- setarrayitem_gc(p0, 1, p2, descr=cdescr)
- jump()
- """, """
- [p1, p2]
- p0 = call_malloc_nursery( \
- %(cdescr.basesize + 5 * cdescr.itemsize)d)
- gc_store(p0, 0, 8111, %(tiddescr.field_size)s)
- gc_store(p0, 0, 5, %(clendescr.field_size)s)
- %(zero_array('p0', 1, 4, 'cdescr', cdescr))s
- %(setarrayitem('p0', 0, 'p1', cdescr))s
- label(p0, p2)
- cond_call_gc_wb_array(p0, 1, descr=wbdescr)
- %(setarrayitem('p0', 1, 'p2', cdescr))s
- jump()
- """)
- def test_zero_array_varsize(self):
- self.check_rewrite("""
- [p1, p2, i3]
- p0 = new_array_clear(i3, descr=bdescr)
- jump()
- """, """
- [p1, p2, i3]
- p0 = call_malloc_nursery_varsize(0, 1, i3, descr=bdescr)
- gc_store(p0, 0, i3, %(blendescr.field_size)s)
- %(zero_array('p0', 0, 'i3', 'bdescr', bdescr))s
- jump()
- """)
- def test_zero_array_varsize_cannot_reduce(self):
- self.check_rewrite("""
- [p1, p2, i3]
- p0 = new_array_clear(i3, descr=bdescr)
- setarrayitem_gc(p0, 0, p1, descr=bdescr)
- jump()
- """, """
- [p1, p2, i3]
- p0 = call_malloc_nursery_varsize(0, 1, i3, descr=bdescr)
- gc_store(p0, 0, i3, %(blendescr.field_size)s)
- %(zero_array('p0', 0, 'i3', 'bdescr', bdescr))s
- cond_call_gc_wb_array(p0, 0, descr=wbdescr)
- %(setarrayitem('p0', 0, 'p1', bdescr))s
- jump()
- """)
- def test_initialization_store_potentially_large_array(self):
- # the write barrier cannot be omitted, because we might get
- # an array with cards and the GC assumes that the write
- # barrier is always called, even on young (but large) arrays
- self.check_rewrite("""
- [i0, p1, i2]
- p0 = new_array(i0, descr=bdescr)
- setarrayitem_gc(p0, i2, p1, descr=bdescr)
- jump()
- """, """
- [i0, p1, i2]
- p0 = call_malloc_nursery_varsize(0, 1, i0, descr=bdescr)
- gc_store(p0, 0, i0, %(blendescr.field_size)s)
- cond_call_gc_wb_array(p0, i2, descr=wbdescr)
- gc_store_indexed(p0, i2, p1, 1, %(bdescr.basesize)s, 1)
- jump()
- """)
- def test_non_initialization_store(self):
- self.check_rewrite("""
- [i0]
- p0 = new(descr=tdescr)
- p1 = newstr(i0)
- setfield_gc(p0, p1, descr=tzdescr)
- jump()
- """, """
- [i0]
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tdescr.gc_fielddescrs[0].offset)s, 0, %(tdescr.gc_fielddescrs[0].offset)s)
- p1 = call_malloc_nursery_varsize(1, 1, i0, \
- descr=strdescr)
- gc_store(p1, %(strlendescr.offset)s, i0, %(strlendescr.field_size)s)
- gc_store(p1, 0, 0, %(strhashdescr.field_size)s)
- cond_call_gc_wb(p0, descr=wbdescr)
- gc_store(p0, %(tzdescr.offset)s, p1, %(tzdescr.field_size)s)
- jump()
- """)
- def test_non_initialization_store_label(self):
- self.check_rewrite("""
- [p1]
- p0 = new(descr=tdescr)
- label(p0, p1)
- setfield_gc(p0, p1, descr=tzdescr)
- jump()
- """, """
- [p1]
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tdescr.gc_fielddescrs[0].offset)s, 0, %(tdescr.gc_fielddescrs[0].offset)s)
- label(p0, p1)
- cond_call_gc_wb(p0, descr=wbdescr)
- gc_store(p0, %(tzdescr.offset)s, p1, %(tzdescr.field_size)s)
- jump()
- """)
- def test_multiple_writes(self):
- self.check_rewrite("""
- [p0, p1, p2]
- setfield_gc(p0, p1, descr=tzdescr)
- setfield_gc(p0, p2, descr=tzdescr)
- jump(p1, p2, p0)
- """, """
- [p0, p1, p2]
- cond_call_gc_wb(p0, descr=wbdescr)
- gc_store(p0, %(tzdescr.offset)s, p1, %(tzdescr.field_size)s)
- gc_store(p0, %(tzdescr.offset)s, p2, %(tzdescr.field_size)s)
- jump(p1, p2, p0)
- """)
- def test_rewrite_call_assembler(self):
- self.check_rewrite("""
- [i0, f0]
- i2 = call_assembler_i(i0, f0, descr=casmdescr)
- """, """
- [i0, f0]
- i1 = gc_load_i(ConstClass(frame_info), %(jfi_frame_size.offset)s, %(jfi_frame_size.field_size)s)
- p1 = call_malloc_nursery_varsize_frame(i1)
- gc_store(p1, 0, 0, %(tiddescr.field_size)s)
- i2 = gc_load_i(ConstClass(frame_info), %(jfi_frame_depth.offset)s, %(jfi_frame_depth.field_size)s)
- %(setfield('p1', 0, jf_extra_stack_depth))s
- %(setfield('p1', 'NULL', jf_savedata))s
- %(setfield('p1', 'NULL', jf_force_descr))s
- %(setfield('p1', 'NULL', jf_descr))s
- %(setfield('p1', 'NULL', jf_guard_exc))s
- %(setfield('p1', 'NULL', jf_forward))s
- gc_store(p1, 0, i2, %(framelendescr.field_size)s)
- %(setfield('p1', 'ConstClass(frame_info)', jf_frame_info))s
- gc_store(p1, 3, i0, 8)
- gc_store(p1, 13, f0, 8)
- i3 = call_assembler_i(p1, descr=casmdescr)
- """)
- def test_int_add_ovf(self):
- self.check_rewrite("""
- [i0]
- p0 = new(descr=tdescr)
- i1 = int_add_ovf(i0, 123)
- guard_overflow(descr=guarddescr) []
- jump()
- """, """
- [i0]
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tdescr.gc_fielddescrs[0].offset)s, 0, %(tdescr.gc_fielddescrs[0].offset)s)
- i1 = int_add_ovf(i0, 123)
- guard_overflow(descr=guarddescr) []
- jump()
- """)
- def test_int_gt(self):
- self.check_rewrite("""
- [i0]
- p0 = new(descr=tdescr)
- i1 = int_gt(i0, 123)
- guard_false(i1, descr=guarddescr) []
- jump()
- """, """
- [i0]
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tdescr.gc_fielddescrs[0].offset)s, 0, %(tdescr.gc_fielddescrs[0].offset)s)
- i1 = int_gt(i0, 123)
- guard_false(i1, descr=guarddescr) []
- jump()
- """)
- def test_zero_ptr_field_before_getfield(self):
- # This case may need to be fixed in the metainterp/optimizeopt
- # already so that it no longer occurs for rewrite.py. But anyway
- # it's a good idea to make sure rewrite.py is correct on its own.
- self.check_rewrite("""
- []
- p0 = new(descr=tdescr)
- p1 = getfield_gc_r(p0, descr=tzdescr)
- jump(p1)
- """, """
- []
- p0 = call_malloc_nursery(%(tdescr.size)d)
- gc_store(p0, 0, 5678, %(tiddescr.field_size)s)
- gc_store(p0, %(tdescr.gc_fielddescrs[0].offset)s, 0, %(tdescr.gc_fielddescrs[0].offset)s)
- p1 = gc_load_r(p0, %(tzdescr.offset)s, %(tzdescr.field_size)s)
- jump(p1)
- """)
- def test_remove_tested_failarg(self):
- self.check_rewrite("""
- [i5]
- i2 = int_ge(i5, 10)
- guard_true(i2) [i5, i2]
- jump()
- """, """
- [i5]
- i0 = same_as_i(0)
- i2 = int_ge(i5, 10)
- guard_true(i2) [i5, i0]
- jump()
- """)
- self.check_rewrite("""
- [i5]
- i2 = int_ge(i5, 10)
- guard_false(i2) [i5, i2]
- jump()
- """, """
- [i5]
- i0 = same_as_i(1)
- i2 = int_ge(i5, 10)
- guard_false(i2) [i5, i0]
- jump()
- """)
- @py.test.mark.parametrize('support_offset,factors,fromto',[
- # [False, (1,2,4,8), 'setarrayitem_gc(p0,i1,i2,descr=adescr)' '->'
- # 'i3 = int_mul(i1,%(adescr.itemsize)s);'
- # 'i4 = int_add(i3,%(adescr.basesize)s);'
- # 'gc_store(p0,i4,i2,%(adescr.itemsize)s)'],
- [True, (1,2,4,8), 'setarrayitem_gc(p0,i1,i2,descr=adescr)' '->'
- 'gc_store_indexed(p0,i1,i2,%(adescr.itemsize)s,'
- '%(adescr.basesize)s,%(adescr.itemsize)s)'],
- #[False, (1,), 'setarrayitem_gc(p0,i1,i2,descr=adescr)' '->'
- # 'i3 = int_mul(i1,%(adescr.itemsize)s);'
- # 'i4 = int_add(i3,%(adescr.basesize)s);'
- # 'gc_store(p0,i4,i2,%(adescr.itemsize)s)'],
- [True, None, 'i3 = raw_load_i(p0,i1,descr=adescr)' '->'
- 'gc_load_indexed_i(p0,i1,1,%(adescr.basesize)s,-%(adescr.itemsize)s)'],
- [True, None, 'i3 = raw_load_f(p0,i1,descr=fdescr)' '->'
- 'gc_load_indexed_f(p0,i1,1,%(fdescr.basesize)s,%(fdescr.itemsize)s)'],
- [True, None, 'i3 = raw_load_i(p0,i1,descr=sfdescr)' '->'
- 'gc_load_indexed_i(p0,i1,1,%(sfdescr.basesize)s,%(sfdescr.itemsize)s)'],
- [True, (1,2,4,8), 'i3 = raw_store(p0,i1,i2,descr=raw_sfdescr)' '->'
- 'gc_store_indexed(p0,i1,i2,1,%(raw_sfdescr.basesize)s,%(raw_sfdescr.itemsize)s)'],
- # [False, (1,), 'i3 = raw_store(p0,i1,i2,descr=raw_sfdescr)' '->'
- # 'i5 = int_add(i1,%(raw_sfdescr.basesize)s);'
- # 'gc_store(p0,i5,i2,%(raw_sfdescr.itemsize)s)'],
- [True, (1,2,4,8), 'i3 = getfield_gc_f(p0,descr=ydescr)' '->'
- 'i3 = gc_load_f(p0,%(ydescr.offset)s,%(ydescr.field_size)s)'],
- [True, (1,2,4,8), 'setfield_raw(p0,i1,descr=ydescr)' '->'
- 'gc_store(p0,%(ydescr.offset)s,i1,%(ydescr.field_size)s)'],
- [True, (1,2,4,8), 'setfield_gc(p0,p0,descr=zdescr)' '->'
- 'cond_call_gc_wb(p0, descr=wbdescr);'
- 'gc_store(p0,%(zdescr.offset)s,p0,%(zdescr.field_size)s)'],
- [False, (1,), 'i3 = arraylen_gc(p0, descr=adescr)' '->'
- 'i3 = gc_load_i(p0,0,%(adescr.itemsize)s)'],
- #[False, (1,), 'i3 = strlen(p0)' '->'
- # 'i3 = gc_load_i(p0,'
- # '%(strlendescr.offset)s,%(strlendescr.field_size)s)'],
- [True, (1,), 'i3 = strlen(p0)' '->'
- 'i3 = gc_load_i(p0,'
- '%(strlendescr.offset)s,'
- '%(strlendescr.field_size)s)'],
- #[False, (1,), 'i3 = unicodelen(p0)' '->'
- # 'i3 = gc_load_i(p0,'
- # '%(unicodelendescr.offset)s,'
- # '%(unicodelendescr.field_size)s)'],
- [True, (1,), 'i3 = unicodelen(p0)' '->'
- 'i3 = gc_load_i(p0,'
- '%(unicodelendescr.offset)s,'
- '%(unicodelendescr.field_size)s)'],
- ## getitem str/unicode
- [True, (2,4), 'i3 = unicodegetitem(p0,i1)' '->'
- 'i3 = gc_load_indexed_i(p0,i1,'
- '%(unicodedescr.itemsize)d,'
- '%(unicodedescr.basesize)d,'
- '%(unicodedescr.itemsize)d)'],
- #[False, (2,4), 'i3 = unicodegetitem(p0,i1)' '->'
- # 'i4 = int_mul(i1, %(unicodedescr.itemsize)d);'
- # 'i5 = int_add(i4, %(unicodedescr.basesize)d);'
- # 'i3 = gc_load_i(p0,i5,%(unicodedescr.itemsize)d)'],
- [True, (4,), 'i3 = strgetitem(p0,i1)' '->'
- 'i3 = gc_load_indexed_i(p0,i1,1,'
- '%(strdescr.basesize-1)d,1)'],
- #[False, (4,), 'i3 = strgetitem(p0,i1)' '->'
- # 'i5 = int_add(i1, %(strdescr.basesize-1)d);'
- # 'i3 = gc_load_i(p0,i5,1)'],
- ## setitem str/unicode
- [True, (4,), 'i3 = strsetitem(p0,i1,0)' '->'
- 'i3 = gc_store_indexed(p0,i1,0,1,'
- '%(strdescr.basesize-1)d,1)'],
- [True, (2,4), 'i3 = unicodesetitem(p0,i1,0)' '->'
- 'i3 = gc_store_indexed(p0,i1,0,'
- '%(unicodedescr.itemsize)d,'
- '%(unicodedescr.basesiz…
Large files files are truncated, but you can click here to view the full file