def __init__(self,
rtyper,
stats,
opts,
translate_support_code=False,
gcdescr=None):
assert type(opts) is not bool
self.opts = opts
from rpython.jit.backend.llsupport.gc import get_ll_description
AbstractCPU.__init__(self)
self.rtyper = rtyper
self.stats = stats
self.translate_support_code = translate_support_code
if translate_support_code and rtyper is not None:
translator = rtyper.annotator.translator
self.remove_gctypeptr = translator.config.translation.gcremovetypeptr
else:
translator = None
self.gc_ll_descr = get_ll_description(gcdescr, translator, rtyper)
# support_guard_gc_type indicates if a gc type of an object can be read.
# In some states (boehm or x86 untranslated) the type is not known just yet,
# because there are cases where it is not guarded. The precise place where it's not
# is while inlining short preamble.
self.supports_guard_gc_type = self.gc_ll_descr.supports_guard_gc_type
if translator and translator.config.translation.gcremovetypeptr:
self.vtable_offset = None
else:
self.vtable_offset, _ = symbolic.get_field_token(
rclass.OBJECT, 'typeptr', translate_support_code)
self.subclassrange_min_offset, _ = symbolic.get_field_token(
rclass.OBJECT_VTABLE, 'subclassrange_min', translate_support_code)
if translate_support_code:
self._setup_exception_handling_translated()
else:
self._setup_exception_handling_untranslated()
self.asmmemmgr = asmmemmgr.AsmMemoryManager()
if self.HAS_CODEMAP:
self.codemap = codemap.CodemapStorage()
self._setup_frame_realloc(translate_support_code)
ad = self.gc_ll_descr.getframedescrs(self).arraydescr
self.signedarraydescr = ad
# the same as normal JITFRAME, however with an array of pointers
self.refarraydescr = ArrayDescr(ad.basesize, ad.itemsize, ad.lendescr,
FLAG_POINTER)
if WORD == 4:
self.floatarraydescr = ArrayDescr(ad.basesize, ad.itemsize * 2,
ad.lendescr, FLAG_FLOAT)
else:
self.floatarraydescr = ArrayDescr(ad.basesize, ad.itemsize,
ad.lendescr, FLAG_FLOAT)
self.setup()
self._debug_tls_errno_container = lltype.malloc(rffi.CArray(
lltype.Signed),
7,
flavor='raw',
zero=True,
track_allocation=False)
self._debug_tls_errno_container[1] = 1234 # dummy thread ident
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 test_opcount_filling_store(self):
descr = ArrayDescr(0, 8, None, 'F', concrete_type='f')
pack = Pack([
Node(ResOperation(rop.RAW_STORE, [0, 0, arg('f', 4)], descr), 0),
Node(ResOperation(rop.RAW_STORE, [0, 0, arg('f', 4)], descr), 0),
])
assert pack.opcount_filling_vector_register(16) == 2
def test_load_singlefloat():
descr = ArrayDescr(8, 4, None, 'S', concrete_type='f')
args = [rop.InputArgInt(), ConstInt(0)]
baseop = rop.ResOperation(rop.rop.RAW_LOAD_I, args, descr=descr)
baseop.set_forwarded(rop.VectorizationInfo(baseop))
op = rop.VecOperation(rop.rop.VEC_RAW_LOAD_I, args, baseop, 4, descr=descr)
assert (op.type, op.datatype, op.bytesize, op.is_vector()) == ('i', 'i', 4,
True)
def test_vec_store():
descr = ArrayDescr(0, 8, None, 'F', concrete_type='f')
vec = rop.InputArgVector()
args = [rop.InputArgRef(), ConstInt(0), vec]
baseop = rop.ResOperation(rop.rop.RAW_STORE, args, descr=descr)
baseop.set_forwarded(rop.VectorizationInfo(baseop))
op = rop.VecOperation(rop.rop.VEC_RAW_STORE, args, baseop, 2, descr=descr)
assert (op.type, op.datatype, op.bytesize, op.is_vector()) == ('v', 'v', 8,
True)
def test_opcount_filling_guard(self):
descr = ArrayDescr(0, 4, None, 'S')
vec = ResOperation(rop.VEC_RAW_LOAD_I, ['a', 'i'], descr=descr)
vec.count = 4
pack = Pack([
Node(ResOperation(rop.GUARD_TRUE, [vec]), 0),
Node(ResOperation(rop.GUARD_TRUE, [vec]), 1),
Node(ResOperation(rop.GUARD_TRUE, [vec]), 2),
Node(ResOperation(rop.GUARD_TRUE, [vec]), 3),
Node(ResOperation(rop.GUARD_TRUE, [vec]), 4),
Node(ResOperation(rop.GUARD_TRUE, [vec]), 5),
])
assert pack.pack_load(16) == 24 - 16
assert pack.pack_load(8) == 24 - 8
assert pack.pack_load(32) == 24 - 32
assert pack.opcount_filling_vector_register(16) == 4
ops, newops = pack.slice_operations(16)
assert len(ops) == 4
assert len(newops) == 2
assert pack.opcount_filling_vector_register(8) == 2
ops, newops = pack.slice_operations(8)
assert len(ops) == 2
assert len(newops) == 4
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)
