[pypy-svn] r29566 - in pypy/dist/pypy: jit/timeshifter jit/timeshifter/test rpython
pedronis at codespeak.net
pedronis at codespeak.net
Sat Jul 1 17:29:15 CEST 2006
Author: pedronis
Date: Sat Jul 1 17:29:12 2006
New Revision: 29566
Modified:
pypy/dist/pypy/jit/timeshifter/oop.py
pypy/dist/pypy/jit/timeshifter/rcontainer.py
pypy/dist/pypy/jit/timeshifter/rtimeshift.py
pypy/dist/pypy/jit/timeshifter/rtyper.py
pypy/dist/pypy/jit/timeshifter/test/test_timeshift.py
pypy/dist/pypy/jit/timeshifter/timeshift.py
pypy/dist/pypy/jit/timeshifter/vlist.py
pypy/dist/pypy/rpython/annlowlevel.py
pypy/dist/pypy/rpython/rgenop.py
Log:
intermediate check-in of a refactoring in preperation of handling
Modified: pypy/dist/pypy/jit/timeshifter/oop.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/oop.py (original)
+++ pypy/dist/pypy/jit/timeshifter/oop.py Sat Jul 1 17:29:12 2006
@@ -61,7 +61,7 @@
if pos > 0:
gv_arg = argboxes[i].getgenvar(jitstate)
args_gv[pos] = gv_arg
- gv_result = rgenop.genop(jitstate.curblock,
+ gv_result = jitstate.curbuilder.genop(
'direct_call',
args_gv,
self.gv_result_type)
Modified: pypy/dist/pypy/jit/timeshifter/rcontainer.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/rcontainer.py (original)
+++ pypy/dist/pypy/jit/timeshifter/rcontainer.py Sat Jul 1 17:29:12 2006
@@ -141,18 +141,17 @@
def generate_set(self, jitstate, genvar, box):
gv_sub = genvar
+ genop = jitstate.curbuilder.genop
for i in range(len(self.accessptrtype_gv)-1):
op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
op_args[0] = gv_sub
op_args[1] = self.fieldname_gv[i]
- gv_sub = rgenop.genop(jitstate.curblock, 'getsubstruct',
- op_args, self.accessptrtype_gv[i+1])
+ gv_sub = genop('getsubstruct', op_args, self.accessptrtype_gv[i+1])
op_args = lltype.malloc(rgenop.VARLIST.TO, 3)
op_args[0] = gv_sub
op_args[1] = self.fieldname_gv[-1]
op_args[2] = box.getgenvar(jitstate)
- rgenop.genop(jitstate.curblock, 'setfield', op_args,
- rgenop.gv_Void)
+ genop('setfield', op_args, rgenop.gv_Void)
# ____________________________________________________________
@@ -207,20 +206,19 @@
box.enter_block(newblock, incoming, memo)
def force_runtime_container(self, jitstate):
+ genop = jitstate.curbuilder.genop
typedesc = self.typedesc
boxes = self.content_boxes
self.content_boxes = None
op_args = lltype.malloc(rgenop.VARLIST.TO, 1)
op_args[0] = typedesc.gv_type
- genvar = rgenop.genop(jitstate.curblock, 'malloc', op_args,
- typedesc.gv_ptrtype)
+ genvar = genop('malloc', op_args, typedesc.gv_ptrtype)
# force all the boxes pointing to this VirtualStruct
for box in self.substruct_boxes:
# XXX using getsubstruct would be nicer
op_args = lltype.malloc(rgenop.VARLIST.TO, 1)
op_args[0] = genvar
- box.genvar = rgenop.genop(jitstate.curblock, 'cast_pointer',
- op_args, box.gv_type)
+ box.genvar = genop('cast_pointer', op_args, box.gv_type)
box.content = None
self.substruct_boxes = None
fielddescs = typedesc.fielddescs
Modified: pypy/dist/pypy/jit/timeshifter/rtimeshift.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/rtimeshift.py (original)
+++ pypy/dist/pypy/jit/timeshifter/rtimeshift.py Sat Jul 1 17:29:12 2006
@@ -5,422 +5,6 @@
FOLDABLE_OPS = dict.fromkeys(lloperation.enum_foldable_ops())
-
-##def make_types_const(TYPES):
-## n = len(TYPES)
-## l = lltype.malloc(rgenop.VARLIST.TO, n)
-## for i in range(n):
-## l[i] = rgenop.constTYPE(TYPES[i])
-## return l
-
-
-##class RedBox(object):
-
-## def same_constant(self, other):
-## return False
-
-## def getallvariables(self, jitstate, result_gv, memo):
-## pass
-
-## def copybox(self, newblock, gv_type, memo):
-## try:
-## return memo[self]
-## except KeyError:
-## return self._copybox(newblock, gv_type, memo)
-
-## def match(self, jitstate, newbox, incoming, memo):
-## if self in memo:
-## return memo[self] is newbox
-## if newbox in memo:
-## return memo[newbox] is self
-## memo[self] = newbox
-## memo[newbox] = self
-## return self._match(jitstate, newbox, incoming, memo)
-
-## def union_for_new_block(self, jitstate, newbox, newblock,
-## gv_type, incoming, memo):
-## try:
-## return memo[newbox]
-## except KeyError:
-## return self._union_for_new_block(jitstate, newbox, newblock,
-## gv_type, incoming, memo)
-
-## # generic implementation of some operations
-## def op_getfield(self, jitstate, fielddesc):
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
-## op_args[0] = self.getgenvar(jitstate)
-## op_args[1] = fielddesc.gv_fieldname
-## genvar = rgenop.genop(jitstate.curblock, 'getfield', op_args,
-## fielddesc.gv_resulttype)
-## return VarRedBox(genvar)
-
-## def op_setfield(self, jitstate, fielddesc, valuebox):
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 3)
-## op_args[0] = self.getgenvar(jitstate)
-## op_args[1] = fielddesc.gv_fieldname
-## op_args[2] = valuebox.getgenvar(jitstate)
-## rgenop.genop(jitstate.curblock, 'setfield', op_args,
-## rgenop.gv_Void)
-
-## def op_getsubstruct(self, jitstate, fielddesc):
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
-## op_args[0] = self.getgenvar(jitstate)
-## op_args[1] = fielddesc.gv_fieldname
-## genvar = rgenop.genop(jitstate.curblock, 'getsubstruct', op_args,
-## fielddesc.gv_resulttype)
-## return VarRedBox(genvar)
-
-
-##class VarRedBox(RedBox):
-## "A red box that contains a run-time variable."
-
-## def __init__(self, genvar):
-## self.genvar = genvar
-
-## def getgenvar(self, jitstate):
-## return self.genvar
-
-## def getallvariables(self, jitstate, result_gv, memo):
-## if self not in memo:
-## result_gv.append(self.genvar)
-## memo[self] = None
-
-## def _copybox(self, newblock, gv_type, memo):
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[self] = newbox = VarRedBox(newgenvar)
-## return newbox
-
-## incoming.append(newbox.getgenvar(jitstate))
-## return True
-
-## def _match(self, jitstate, newbox, incoming, memo):
-## incoming.append(newbox.getgenvar(jitstate))
-## return True
-
-## def _union_for_new_block(self, jitstate, newbox, newblock,
-## gv_type, incoming, memo):
-## incoming.append(newbox.getgenvar(jitstate))
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[newbox] = newnewbox = VarRedBox(newgenvar)
-## return newnewbox
-
-
-##VCONTAINER = lltype.GcStruct("vcontainer")
-
-##class ContainerRedBox(RedBox):
-## def __init__(self, envelope, content_addr):
-## self.envelope = envelope
-## self.content_addr = content_addr
-
-## def getgenvar(self, jitstate): # no support at the moment
-## raise RuntimeError("cannot force virtual containers")
-
-## def ll_make_container_box(envelope, content_addr):
-## return ContainerRedBox(envelope, content_addr)
-## ll_make_container_box = staticmethod(ll_make_container_box)
-
-## def ll_make_subcontainer_box(box, content_addr):
-## return ContainerRedBox(box.envelope, content_addr)
-## ll_make_subcontainer_box = staticmethod(ll_make_subcontainer_box)
-
-
-##def ll_getenvelope(box):
-## assert isinstance(box, ContainerRedBox)
-## return box.envelope
-
-##def ll_getcontent(box):
-## assert isinstance(box, ContainerRedBox)
-## return box.content_addr
-
-
-##class BigRedBox(RedBox):
-## "A (big) red box that contains (small) red boxes inside."
-
-## #def __init__(self, content_boxes):
-## # self.content_boxes = content_boxes
-
-## def op_getfield(self, jitstate, fielddesc):
-## if self.content_boxes is None:
-## return RedBox.op_getfield(self, jitstate, fielddesc)
-## else:
-## return self.content_boxes[fielddesc.fieldindex]
-
-## def op_setfield(self, jitstate, fielddesc, valuebox):
-## if self.content_boxes is None:
-## RedBox.op_setfield(self, jitstate, fielddesc, valuebox)
-## else:
-## self.content_boxes[fielddesc.fieldindex] = valuebox
-
-## def op_getsubstruct(self, jitstate, fielddesc):
-## if self.content_boxes is None:
-## return RedBox.op_getsubstruct(self, jitstate, fielddesc)
-## else:
-## return self.content_boxes[fielddesc.fieldindex]
-
-
-##class VirtualRedBox(BigRedBox):
-## "A red box that contains (for now) a virtual Struct."
-
-## def __init__(self, typedesc):
-## self.content_boxes = typedesc.build_content_boxes(self)
-## self.typedesc = typedesc
-## self.genvar = rgenop.nullvar
-
-## def getgenvar(self, jitstate):
-## if not self.genvar:
-## typedesc = self.typedesc
-## boxes = self.content_boxes
-## self.content_boxes = None
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 1)
-## op_args[0] = typedesc.gv_type
-## self.genvar = rgenop.genop(jitstate.curblock, 'malloc', op_args,
-## typedesc.gv_ptrtype)
-## typedesc.materialize_content(jitstate, self.genvar, boxes)
-## return self.genvar
-
-## def is_forced(self):
-## return bool(self.genvar)
-
-## def getallvariables(self, jitstate, result_gv, memo):
-## if self.genvar:
-## if self not in memo:
-## result_gv.append(self.genvar)
-## memo[self] = None
-## else:
-## for smallbox in self.content_boxes:
-## smallbox.getallvariables(jitstate, result_gv, memo)
-
-## def _copybox(self, newblock, gv_type, memo):
-## if self.genvar:
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[self] = newbox = VarRedBox(newgenvar)
-## return newbox
-## bigbox = VirtualRedBox(self.typedesc)
-## memo[self] = bigbox
-## for i in range(len(bigbox.content_boxes)):
-## gv_fldtype = self.typedesc.fielddescs[i].gv_resulttype
-## bigbox.content_boxes[i] = self.content_boxes[i].copybox(newblock,
-## gv_fldtype,
-## memo)
-## return bigbox
-
-## def _match(self, jitstate, newbox, incoming, memo):
-## if self.genvar:
-## incoming.append(newbox.getgenvar(jitstate))
-## return True
-## if not isinstance(newbox, VirtualRedBox):
-## return False
-## for i in range(len(self.content_boxes)):
-## mysmallbox = self.content_boxes[i]
-## newsmallbox = newbox.content_boxes[i]
-## if not mysmallbox.match(jitstate, newsmallbox, incoming, memo):
-## return False
-## else:
-## return True
-
-## def inlined_structs_are_compatible(self, newbox):
-## return (isinstance(newbox, VirtualRedBox) and not newbox.genvar and
-## self.typedesc.compare_content_boxes(self.content_boxes,
-## newbox.content_boxes))
-
-## def _union_for_new_block(self, jitstate, newbox, newblock,
-## gv_type, incoming, memo):
-## if self.genvar or not self.inlined_structs_are_compatible(newbox):
-## incoming.append(newbox.getgenvar(jitstate))
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[newbox] = newnewbox = VarRedBox(newgenvar)
-## return newnewbox
-## bigbox = VirtualRedBox(self.typedesc)
-## memo[newbox] = bigbox
-## for i in range(len(bigbox.content_boxes)):
-## gv_fldtype = self.typedesc.fielddescs[i].gv_resulttype
-## box = self.content_boxes[i]
-## bigbox.content_boxes[i] = box.union_for_new_block(
-## jitstate,
-## newbox.content_boxes[i],
-## newblock,
-## gv_fldtype,
-## incoming,
-## memo)
-## return bigbox
-
-
-##class SubVirtualRedBox(BigRedBox):
-
-## def __init__(self, parentbox, fielddesc):
-## self.parentbox = parentbox
-## self.fielddesc = fielddesc
-## typedesc = fielddesc.inlined_typedesc
-## self.content_boxes = typedesc.build_content_boxes(self)
-
-## def getgenvar(self, jitstate):
-## gv = self.parentbox.getgenvar(jitstate)
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
-## op_args[0] = gv
-## op_args[1] = self.fielddesc.gv_fieldname
-## genvar = rgenop.genop(jitstate.curblock, 'getsubstruct', op_args,
-## self.fielddesc.gv_resulttype)
-## return genvar
-
-## def is_forced(self):
-## return self.parentbox.is_forced()
-
-## def getallvariables(self, jitstate, result_gv, memo):
-## if self.is_forced():
-## if self not in memo:
-## result_gv.append(self.getgenvar(jitstate))
-## memo[self] = None
-## else:
-## for smallbox in self.content_boxes:
-## smallbox.getallvariables(jitstate, result_gv, memo)
-
-## def _copybox(self, newblock, gv_type, memo):
-## if self.is_forced():
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[self] = newbox = VarRedBox(newgenvar)
-## return newbox
-## bigbox = SubVirtualRedBox(None, self.fielddesc)
-## memo[self] = bigbox
-## gv_parenttype = self.fielddesc.parenttypedesc.gv_ptrtype
-## parentcopybox = self.parentbox.copybox(newblock, gv_parenttype, memo)
-## bigbox.parentbox = parentcopybox
-## typedesc = self.fielddesc.inlined_typedesc
-## for i in range(len(bigbox.content_boxes)):
-## gv_fldtype = typedesc.fielddescs[i].gv_resulttype
-## bigbox.content_boxes[i] = self.content_boxes[i].copybox(newblock,
-## gv_fldtype,
-## memo)
-## return bigbox
-
-## def _match(self, jitstate, newbox, incoming, memo):
-## if self.is_forced():
-## incoming.append(newbox.getgenvar(jitstate))
-## return True
-## if not (isinstance(newbox, SubVirtualRedBox) and
-## self.fielddesc is newbox.fielddesc and
-## self.parentbox.match(jitstate, newbox.parentbox,
-## incoming, memo)):
-## return False
-## for i in range(len(self.content_boxes)):
-## mysmallbox = self.content_boxes[i]
-## newsmallbox = newbox.content_boxes[i]
-## if not mysmallbox.match(jitstate, newsmallbox, incoming, memo):
-## return False
-## else:
-## return True
-
-## def inlined_structs_are_compatible(self, newbox):
-## if (isinstance(newbox, SubVirtualRedBox) and not newbox.is_forced() and
-## self.fielddesc is newbox.fielddesc):
-## return self.parentbox.inlined_structs_are_compatible(
-## newbox.parentbox)
-## else:
-## return False
-
-## def _union_for_new_block(self, jitstate, newbox, newblock,
-## gv_type, incoming, memo):
-## if self.is_forced() or not self.inlined_structs_are_compatible(newbox):
-## incoming.append(newbox.getgenvar(jitstate))
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## memo[newbox] = newnewbox = VarRedBox(newgenvar)
-## return newnewbox
-## assert isinstance(newbox, SubVirtualRedBox)
-## bigbox = SubVirtualRedBox(None, self.fielddesc)
-## memo[newbox] = bigbox
-## gv_parenttype = self.fielddesc.parenttypedesc.gv_ptrtype
-## parentcopybox = self.parentbox.union_for_new_block(jitstate,
-## newbox.parentbox,
-## newblock,
-## gv_parenttype,
-## incoming,
-## memo)
-## bigbox.parentbox = parentcopybox
-## typedesc = self.fielddesc.inlined_typedesc
-## for i in range(len(bigbox.content_boxes)):
-## gv_fldtype = typedesc.fielddescs[i].gv_resulttype
-## box = self.content_boxes[i]
-## bigbox.content_boxes[i] = box.union_for_new_block(
-## jitstate,
-## newbox.content_boxes[i],
-## newblock,
-## gv_fldtype,
-## incoming,
-## memo)
-## return bigbox
-
-
-##class ConstRedBox(RedBox):
-## "A red box that contains a run-time constant."
-
-## def __init__(self, genvar):
-## self.genvar = genvar
-
-## def getgenvar(self, jitstate):
-## return self.genvar
-
-## def copybox(self, newblock, gv_type, memo):
-## return self
-
-## def match(self, jitstate, newbox, incoming, memo):
-## return self.same_constant(newbox)
-
-## def _union_for_new_block(self, jitstate, newbox, newblock,
-## gv_type, incoming, memo):
-## if self.same_constant(newbox):
-## newnewbox = newbox
-## else:
-## incoming.append(newbox.getgenvar(jitstate))
-## newgenvar = rgenop.geninputarg(newblock, gv_type)
-## newnewbox = VarRedBox(newgenvar)
-## memo[newbox] = newnewbox
-## return newnewbox
-
-## def ll_fromvalue(value):
-## T = lltype.typeOf(value)
-## gv = rgenop.genconst(value)
-## if isinstance(T, lltype.Ptr):
-## return AddrRedBox(gv)
-## elif T is lltype.Float:
-## return DoubleRedBox(gv)
-## else:
-## assert isinstance(T, lltype.Primitive)
-## assert T is not lltype.Void, "cannot make red boxes of voids"
-## # XXX what about long longs?
-## return IntRedBox(gv)
-## ll_fromvalue = staticmethod(ll_fromvalue)
-
-## def ll_getvalue(self, T):
-## # note: this is specialized by low-level type T, as a low-level helper
-## return rgenop.revealconst(T, self.genvar)
-
-##def ll_getvalue(box, T):
-## return box.ll_getvalue(T)
-
-
-##class IntRedBox(ConstRedBox):
-## "A red box that contains a constant integer-like value."
-
-## def same_constant(self, other):
-## return (isinstance(other, IntRedBox) and
-## self.ll_getvalue(lltype.Signed) == other.ll_getvalue(lltype.Signed))
-
-
-##class DoubleRedBox(ConstRedBox):
-## "A red box that contains a constant double-precision floating point value."
-
-## def same_constant(self, other):
-## return (isinstance(other, DoubleRedBox) and
-## self.ll_getvalue(lltype.Float) == other.ll_getvalue(lltype.Float))
-
-
-##class AddrRedBox(ConstRedBox):
-## "A red box that contains a constant address."
-
-## def same_constant(self, other):
-## return (isinstance(other, AddrRedBox) and
-## self.ll_getvalue(llmemory.Address) == other.ll_getvalue(llmemory.Address))
-
-
# ____________________________________________________________
# emit ops
@@ -479,8 +63,8 @@
return rvalue.ll_fromvalue(res)
op_args = lltype.malloc(rgenop.VARLIST.TO, 1)
op_args[0] = argbox.getgenvar(jitstate)
- genvar = rgenop.genop(jitstate.curblock, opdesc.opname, op_args,
- opdesc.gv_RESULT)
+ genvar = jitstate.curbuilder.genop(opdesc.opname, op_args,
+ opdesc.gv_RESULT)
return opdesc.redboxcls(opdesc.gv_RESULT, genvar)
def ll_generate_operation2(opdesc, jitstate, argbox0, argbox1):
@@ -497,157 +81,10 @@
op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
op_args[0] = argbox0.getgenvar(jitstate)
op_args[1] = argbox1.getgenvar(jitstate)
- genvar = rgenop.genop(jitstate.curblock, opdesc.opname, op_args,
- opdesc.gv_RESULT)
+ genvar = jitstate.curbuilder.genop(opdesc.opname, op_args,
+ opdesc.gv_RESULT)
return opdesc.redboxcls(opdesc.gv_RESULT, genvar)
-## class StructTypeDesc(object):
-## _type_cache = weakref.WeakKeyDictionary()
-
-## def __init__(self, TYPE):
-## self.TYPE = TYPE
-## self.PTRTYPE = lltype.Ptr(TYPE)
-## self.gv_type = rgenop.constTYPE(self.TYPE)
-## self.gv_ptrtype = rgenop.constTYPE(self.PTRTYPE)
-
-## def setup(self):
-## self.fielddescs = [StructFieldDesc.make(self.PTRTYPE, name)
-## for name in self.TYPE._names]
-## defls = []
-## for desc in self.fielddescs:
-## if desc.inlined_typedesc is not None:
-## defaultbox = None
-## else:
-## defaultvalue = desc.RESTYPE._defl()
-## defaultbox = rvalue.ll_fromvalue(defaultvalue)
-## defls.append(defaultbox)
-## self.default_boxes = defls
-
-## def build_content_boxes(self, parentbox):
-## # make a'content_boxes' list based on the typedesc's default_boxes,
-## # building nested SubVirtualRedBoxes for inlined substructs
-## clist = []
-## for i in range(len(self.fielddescs)):
-## fielddesc = self.fielddescs[i]
-## if fielddesc.inlined_typedesc:
-## box = SubVirtualRedBox(parentbox, fielddesc)
-## else:
-## box = self.default_boxes[i]
-## clist.append(box)
-## return clist
-
-## def compare_content_boxes(self, content_boxes_1, content_boxes_2):
-## for i in range(len(self.fielddescs)):
-## fielddesc = self.fielddescs[i]
-## if fielddesc.inlined_typedesc:
-## box1 = content_boxes_1[i]
-## box2 = content_boxes_2[i]
-## assert isinstance(box1, BigRedBox)
-## assert isinstance(box2, BigRedBox)
-## if not fielddesc.inlined_typedesc.compare_content_boxes(
-## box1.content_boxes, box2.content_boxes):
-## return False
-## else:
-## return True
-
-## def materialize_content(self, jitstate, gv, boxes):
-## for i in range(len(boxes)):
-## smallbox = boxes[i]
-## fielddesc = self.fielddescs[i]
-## if fielddesc.inlined_typedesc:
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
-## op_args[0] = gv
-## op_args[1] = fielddesc.gv_fieldname
-## gv_sub = rgenop.genop(jitstate.curblock, 'getsubstruct',
-## op_args, fielddesc.gv_resulttype)
-## assert isinstance(smallbox, SubVirtualRedBox)
-## subboxes = smallbox.content_boxes
-## smallbox.content_boxes = None
-## fielddesc.inlined_typedesc.materialize_content(jitstate,
-## gv_sub,
-## subboxes)
-## else:
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 3)
-## op_args[0] = gv
-## op_args[1] = fielddesc.gv_fieldname
-## op_args[2] = smallbox.getgenvar(jitstate)
-## rgenop.genop(jitstate.curblock, 'setfield', op_args,
-## rgenop.gv_Void)
-
-## def make(T):
-## try:
-## return StructTypeDesc._type_cache[T]
-## except KeyError:
-## desc = StructTypeDesc._type_cache[T] = StructTypeDesc(T)
-## desc.setup()
-## return desc
-## make = staticmethod(make)
-
-## def ll_factory(self):
-## return VirtualRedBox(self)
-
-## def _freeze_(self):
-## return True
-
-## def compact_repr(self): # goes in ll helper names
-## return "Desc_%s" % (self.TYPE._short_name(),)
-
-## class FieldDesc(object):
-## _fielddesc_cache = weakref.WeakKeyDictionary()
-
-## def __init__(self, PTRTYPE, RESTYPE):
-## self.PTRTYPE = PTRTYPE
-## if isinstance(RESTYPE, lltype.ContainerType):
-## RESTYPE = lltype.Ptr(RESTYPE)
-## self.RESTYPE = RESTYPE
-## self.gv_resulttype = rgenop.constTYPE(RESTYPE)
-## self.redboxcls = rvalue.ll_redboxcls(RESTYPE)
-## self.immutable = PTRTYPE.TO._hints.get('immutable', False)
-
-## def _freeze_(self):
-## return True
-
-## def make(cls, PTRTYPE, *args):
-## T = PTRTYPE.TO
-## cache = FieldDesc._fielddesc_cache.setdefault(T, {})
-## try:
-## return cache[args]
-## except KeyError:
-## fdesc = cache[args] = cls(PTRTYPE, *args)
-## fdesc.setup()
-## return fdesc
-## make = classmethod(make)
-
-## class StructFieldDesc(FieldDesc):
-## def __init__(self, PTRTYPE, fieldname):
-## assert isinstance(PTRTYPE.TO, lltype.Struct)
-## RES1 = getattr(PTRTYPE.TO, fieldname)
-## FieldDesc.__init__(self, PTRTYPE, RES1)
-## self.fieldname = fieldname
-## self.gv_fieldname = rgenop.constFieldName(fieldname)
-## self.fieldindex = operator.indexOf(PTRTYPE.TO._names, fieldname)
-## if isinstance(RES1, lltype.Struct):
-## # inlined substructure
-## self.inlined_typedesc = StructTypeDesc.make(RES1)
-## ## elif isinstance(RES1, lltype.Array):
-## ## # inlined array XXX in-progress
-## ## self.inlined_typedesc = ArrayTypeDesc.make(RES1)
-## else:
-## self.inlined_typedesc = None
-
-## def setup(self):
-## self.parenttypedesc = StructTypeDesc.make(self.PTRTYPE.TO)
-
-## def compact_repr(self): # goes in ll helper names
-## return "Fld_%s_in_%s" % (self.fieldname, self.PTRTYPE._short_name())
-
-## class ArrayFieldDesc(FieldDesc):
-## def __init__(self, PTRTYPE):
-## assert isinstance(PTRTYPE.TO, lltype.Array)
-## FieldDesc.__init__(self, PTRTYPE, PTRTYPE.TO.OF)
-## def setup(self):
-## pass
-
def ll_generate_getfield(jitstate, fielddesc, argbox):
if fielddesc.immutable and argbox.is_constant():
res = getattr(rvalue.ll_getvalue(argbox, fielddesc.PTRTYPE),
@@ -658,8 +95,8 @@
op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
op_args[0] = argbox.getgenvar(jitstate)
op_args[1] = fielddesc.fieldname_gv[-1]
- genvar = rgenop.genop(jitstate.curblock, 'getfield', op_args,
- fielddesc.gv_resulttype)
+ genvar = jitstate.curbuilder.genop('getfield', op_args,
+ fielddesc.gv_resulttype)
return fielddesc.redboxcls(fielddesc.gv_resulttype, genvar)
else:
return argbox.content.op_getfield(jitstate, fielddesc)
@@ -671,8 +108,8 @@
op_args[0] = destbox.getgenvar(jitstate)
op_args[1] = fielddesc.fieldname_gv[-1]
op_args[2] = valuebox.getgenvar(jitstate)
- rgenop.genop(jitstate.curblock, 'setfield', op_args,
- rgenop.gv_Void)
+ jitstate.curbuilder.genop('setfield', op_args,
+ rgenop.gv_Void)
else:
destbox.content.op_setfield(jitstate, fielddesc, valuebox)
@@ -686,8 +123,8 @@
op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
op_args[0] = argbox.getgenvar(jitstate)
op_args[1] = fielddesc.gv_fieldname
- genvar = rgenop.genop(jitstate.curblock, 'getsubstruct', op_args,
- fielddesc.gv_resulttype)
+ genvar = jitstate.curbuilder.genop('getsubstruct', op_args,
+ fielddesc.gv_resulttype)
return fielddesc.redboxcls(fielddesc.gv_resulttype, genvar)
else:
return argbox.content.op_getsubstruct(jitstate, fielddesc)
@@ -701,20 +138,15 @@
op_args = lltype.malloc(rgenop.VARLIST.TO, 2)
op_args[0] = argbox.getgenvar(jitstate)
op_args[1] = indexbox.getgenvar(jitstate)
- genvar = rgenop.genop(jitstate.curblock, 'getarrayitem', op_args,
- fielddesc.gv_resulttype)
+ genvar = jitstate.curbuilder.genop('getarrayitem', op_args,
+ fielddesc.gv_resulttype)
return fielddesc.redboxcls(fielddesc.gv_resulttype, genvar)
-##def ll_generate_malloc(jitstate, gv_type, gv_resulttype):
-## op_args = lltype.malloc(rgenop.VARLIST.TO, 1)
-## op_args[0] = gv_type
-## genvar = rgenop.genop(jitstate.curblock, 'malloc', op_args,
-## gv_resulttype)
-## return VarRedBox(genvar)
-
# ____________________________________________________________
# other jitstate/graph level operations
+def enter_graph(builder):
+ return builder.build_jitstate()
def retrieve_jitstate_for_merge(states_dic, jitstate, key, redboxes):
if key not in states_dic:
@@ -730,9 +162,7 @@
for box in outgoingvarboxes:
linkargs.append(box.getgenvar(None))
box.genvar = rgenop.geninputarg(newblock, box.gv_type)
- rgenop.closelink(jitstate.curoutgoinglink, linkargs, newblock)
- jitstate.curblock = newblock
- jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
+ jitstate.curbuilder.enter_block(linkargs, newblock)
states_dic[key] = frozens, newblock
return jitstate
@@ -750,8 +180,8 @@
linkargs = []
for box in outgoingvarboxes:
linkargs.append(box.getgenvar(jitstate))
- link = rgenop.closeblock1(jitstate.curblock)
- rgenop.closelink(link, linkargs, oldblock)
+ jitstate.curbuilder.leave_block()
+ jitstate.curbuilder.finish_and_goto(linkargs, oldblock)
return None
# Make a more general block
@@ -768,33 +198,12 @@
if replace_memo.boxes:
for i in range(len(redboxes)):
redboxes[i] = redboxes[i].replace(replace_memo)
- link = rgenop.closeblock1(jitstate.curblock)
- rgenop.closelink(link, linkargs, newblock)
- jitstate.curblock = newblock
- #jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
+ jitstate.curbuilder.leave_block()
+ jitstate.curbuilder.enter_block(linkargs, newblock)
memo = rvalue.freeze_memo()
frozens = [redbox.freeze(memo) for redbox in redboxes]
states_dic[key] = frozens, newblock
return jitstate
-
-## newblock = rgenop.newblock()
-## incoming = []
-## memo = {}
-## for i in range(len(redboxes)):
-## oldbox = oldboxes[i]
-## newbox = redboxes[i]
-## redboxes[i] = oldbox.union_for_new_block(jitstate, newbox, newblock,
-## types_gv[i], incoming, memo)
-## ## if not oldbox.same_constant(newbox):
-## ## incoming.append(newbox.getgenvar(jitstate))
-## ## newgenvar = rgenop.geninputarg(newblock, TYPES[i])
-## ## redboxes[i] = VarRedBox(newgenvar)
-## link = rgenop.closeblock1(jitstate.curblock)
-## rgenop.closelink(link, incoming, newblock)
-## jitstate.curblock = newblock
-## #jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
-## states_dic[key] = redboxes, newblock
-## return jitstate
retrieve_jitstate_for_merge._annspecialcase_ = "specialize:arglltype(2)"
def enter_block(jitstate, redboxes):
@@ -803,9 +212,7 @@
memo = rvalue.enter_block_memo()
for i in range(len(redboxes)):
redboxes[i].enter_block(newblock, incoming, memo)
- rgenop.closelink(jitstate.curoutgoinglink, incoming, newblock)
- jitstate.curblock = newblock
- jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
+ jitstate.curbuilder.enter_block(incoming, newblock)
return jitstate
def dyn_enter_block(jitstate, redboxes):
@@ -814,49 +221,42 @@
memo = rvalue.enter_block_memo()
for redbox in redboxes:
redbox.enter_block(newblock, incoming, memo)
- rgenop.closelink(jitstate.curoutgoinglink, incoming, newblock)
- jitstate.curblock = newblock
- jitstate.curoutgoinglink = lltype.nullptr(rgenop.LINK.TO)
+ jitstate.curbuilder.enter_block(incoming, newblock)
return jitstate
def leave_block(jitstate):
- jitstate.curoutgoinglink = rgenop.closeblock1(jitstate.curblock)
+ jitstate.curbuilder.leave_block()
return jitstate
def leave_block_split(jitstate, switchredbox, exitindex, redboxes):
if switchredbox.is_constant():
- jitstate.curoutgoinglink = rgenop.closeblock1(jitstate.curblock)
+ jitstate.curbuilder.leave_block()
return rvalue.ll_getvalue(switchredbox, lltype.Bool)
else:
exitgvar = switchredbox.getgenvar(jitstate)
- linkpair = rgenop.closeblock2(jitstate.curblock, exitgvar)
- false_link, true_link = linkpair.item0, linkpair.item1
- later_jitstate = jitstate.copystate()
- jitstate.curoutgoinglink = true_link
- later_jitstate.curoutgoinglink = false_link
+ later_builder = jitstate.curbuilder.leave_block_split(exitgvar)
memo = rvalue.copy_memo()
redboxcopies = [redbox.copy(memo) for redbox in redboxes]
- jitstate.split_queue.append((exitindex, later_jitstate, redboxcopies))
+ jitstate.split_queue.append((exitindex, later_builder, redboxcopies))
return True
def schedule_return(jitstate, redbox):
- jitstate.return_queue.append((jitstate.curoutgoinglink, redbox))
+ jitstate.return_queue.append((jitstate.curbuilder, redbox))
novars = lltype.malloc(rgenop.VARLIST.TO, 0)
def dispatch_next(jitstate, outredboxes, gv_return_type):
split_queue = jitstate.split_queue
if split_queue:
- exitindex, later_jitstate, redboxes = split_queue.pop()
- jitstate.curblock = later_jitstate.curblock
- jitstate.curoutgoinglink = later_jitstate.curoutgoinglink
- jitstate.curvalue = later_jitstate.curvalue
+ exitindex, later_builder, redboxes = split_queue.pop()
+ jitstate.curbuilder = later_builder
for box in redboxes:
outredboxes.append(box)
return exitindex
return_queue = jitstate.return_queue
first_redbox = return_queue[0][1]
- finalblock = rgenop.newblock()
+ finalbuilder = ResidualGraphBuilder(rgenop.newblock())
+ finalblock = finalbuilder.block
## jitstate.curblock = finalblock
## if isinstance(first_redbox, ConstRedBox):
## for link, redbox in return_queue:
@@ -871,19 +271,19 @@
## return -1
finalvar = rgenop.geninputarg(finalblock, gv_return_type)
- for link, redbox in return_queue:
+ for builder, redbox in return_queue:
newblock = rgenop.newblock()
incoming = []
memo = rvalue.enter_block_memo()
redbox.enter_block(newblock, incoming, memo)
- jitstate.curblock = newblock
+ jitstate.curbuilder = builder
+ builder.enter_block(incoming, newblock)
gv_retval = redbox.getgenvar(jitstate)
- rgenop.closelink(link, incoming, newblock)
- newlink = rgenop.closeblock1(newblock)
- rgenop.closelink(newlink, [gv_retval], finalblock)
- finallink = rgenop.closeblock1(finalblock)
- jitstate.curoutgoinglink = finallink
- jitstate.curvalue = finalvar
+ builder.leave_block()
+ builder.finish_and_goto([gv_retval], finalblock)
+ finalbuilder.leave_block()
+ finalbuilder.value = finalvar
+ jitstate.curbuilder = finalbuilder
return -1
def ll_gvar_from_redbox(jitstate, redbox):
@@ -894,34 +294,42 @@
# ____________________________________________________________
-class JITState(object):
- # XXX obscure interface
-
- def setup(self):
- self.return_queue = []
- self.split_queue = []
- self.curblock = rgenop.newblock()
- self.curvalue = rgenop.nullvar
-
- def end_setup(self):
- self.curoutgoinglink = rgenop.closeblock1(self.curblock)
+class ResidualGraphBuilder(rgenop.LowLevelOpBuilder):
+ def __init__(self, block=rgenop.nullblock, link=rgenop.nulllink):
+ rgenop.LowLevelOpBuilder.__init__(self, block)
+ self.outgoinglink = link
+ self.value = rgenop.nullvar
+
+ def build_jitstate(self):
+ return JITState(self)
+
+ def enter_block(self, linkargs, newblock):
+ rgenop.closelink(self.outgoinglink, linkargs, newblock)
+ self.block = newblock
+ self.outgoinglink = rgenop.nulllink
+
+ def leave_block(self):
+ self.outgoinglink = rgenop.closeblock1(self.block)
- def close(self, return_gvar):
- rgenop.closereturnlink(self.curoutgoinglink, return_gvar)
+ def leave_block_split(self, exitgvar):
+ linkpair = rgenop.closeblock2(self.block, exitgvar)
+ false_link, true_link = linkpair.item0, linkpair.item1
+ later_builder = ResidualGraphBuilder(link=false_link)
+ self.outgoinglink = true_link
+ return later_builder
+
+ def finish_and_goto(self, linkargs, targetblock):
+ rgenop.closelink(self.outgoinglink, linkargs, targetblock)
+ self.outgoinglink = rgenop.nulllink
+
+ def finish_and_return(self):
+ rgenop.closereturnlink(self.outgoinglink, self.value)
+
+ def clone(self):
+ XXX
- def copystate(self):
- other = JITState()
- other.return_queue = self.return_queue
- other.split_queue = self.split_queue
- other.curblock = self.curblock
- other.curoutgoinglink = self.curoutgoinglink
- other.curvalue = self.curvalue
- return other
-
-def ll_build_jitstate():
- jitstate = JITState()
- jitstate.setup()
- return jitstate
+def ll_make_builder():
+ return ResidualGraphBuilder(rgenop.newblock())
def ll_int_box(gv_type, gv):
return rvalue.IntRedBox(gv_type, gv)
@@ -932,13 +340,22 @@
def ll_addr_box(gv_type, gv):
return rvalue.PtrRedBox(gv_type, gv)
-def ll_geninputarg(jitstate, gv_TYPE):
- return rgenop.geninputarg(jitstate.curblock, gv_TYPE)
-
-def ll_end_setup_jitstate(jitstate):
- jitstate.end_setup()
- return jitstate.curblock
+def ll_geninputarg(builder, gv_TYPE):
+ return rgenop.geninputarg(builder.block, gv_TYPE)
+def ll_end_setup_builder(builder):
+ builder.leave_block()
+ return builder.block
+
def ll_close_jitstate(jitstate):
- result_genvar = jitstate.curvalue
- jitstate.close(result_genvar)
+ jitstate.curbuilder.finish_and_return()
+
+class JITState(object):
+ # XXX obscure interface
+
+ def __init__(self, builder):
+ self.return_queue = []
+ self.split_queue = []
+ self.curbuilder = builder
+
+
Modified: pypy/dist/pypy/jit/timeshifter/rtyper.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/rtyper.py (original)
+++ pypy/dist/pypy/jit/timeshifter/rtyper.py Sat Jul 1 17:29:12 2006
@@ -6,14 +6,14 @@
from pypy.rpython.rtyper import RPythonTyper, LowLevelOpList, TyperError
from pypy.rpython.rmodel import Repr, inputconst
from pypy.rpython.lltypesystem.rstr import string_repr
-from pypy.rpython.typesystem import TypeSystem
+from pypy.rpython.typesystem import LowLevelTypeSystem
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython import rgenop
from pypy.jit.hintannotator import model as hintmodel
from pypy.jit.hintannotator import container as hintcontainer
from pypy.jit.timeshifter import rtimeshift, rvalue, rcontainer
-class HintTypeSystem(TypeSystem):
+class HintTypeSystem(LowLevelTypeSystem):
name = "hinttypesystem"
offers_exceptiondata = False
@@ -218,7 +218,20 @@
v = hop.genop('direct_call', hop.args_v, hop.r_result.lowleveltype)
return v
else:
- raise NotImplementedError("direct_call")
+ bk = self.annotator.bookkeeper
+ hop.r_s_popfirstarg()
+ args_hs = hop.args_s[:]
+ # fixed is always false here
+ graph = bk.get_graph_for_call(fnobj.graph, False, args_hs)
+ args_r = [self.getrepr(hs) for hs in args_hs]
+ args_v = hop.inputargs(*args_r)
+ fnptr = self.getcallable(graph)
+ self.timeshifter.schedule_graph(graph)
+ v_jitstate = hop.llops.getjitstate()
+ args_v.insert(0, v_jitstate)
+ args_v.insert(0, hop.llops.genconst(fnptr))
+ v = hop.genop('direct_call', args_v, hop.r_result.lowleveltype)
+ return v
def handle_highlevel_operation(self, fnobj, hop):
from pypy.jit.timeshifter.oop import OopSpecDesc, Index
Modified: pypy/dist/pypy/jit/timeshifter/test/test_timeshift.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/test/test_timeshift.py (original)
+++ pypy/dist/pypy/jit/timeshifter/test/test_timeshift.py Sat Jul 1 17:29:12 2006
@@ -79,9 +79,8 @@
# run the time-shifted graph-producing graphs
graph1 = ha.translator.graphs[0]
llinterp = LLInterpreter(rtyper)
- llinterp.eval_graph(htshift.ll_clearcaches, [])
- jitstate = llinterp.eval_graph(htshift.ll_build_jitstate_graph, [])
- graph1args = [jitstate]
+ builder = llinterp.eval_graph(htshift.ll_make_builder_graph, [])
+ graph1args = [builder]
residual_graph_args = []
assert len(graph1.getargs()) == 1 + len(values)
for i, (v, llvalue) in enumerate(zip(graph1.getargs()[1:], values)):
@@ -95,7 +94,7 @@
assert residual_v == [llvalue], "XXX for now"
TYPE = htshift.originalconcretetype(v)
gv_type = rgenop.constTYPE(TYPE)
- gvar = llinterp.eval_graph(htshift.ll_geninputarg_graph, [jitstate,
+ gvar = llinterp.eval_graph(htshift.ll_geninputarg_graph, [builder,
gv_type])
if i in opt_consts: # XXX what should happen here interface wise is unclear
gvar = rgenop.genconst(llvalue)
@@ -108,13 +107,13 @@
box = llinterp.eval_graph(ll_box_graph, [gv_type, gvar])
graph1args.append(box)
residual_graph_args.append(llvalue)
- startblock = llinterp.eval_graph(htshift.ll_end_setup_jitstate_graph, [jitstate])
+ startblock = llinterp.eval_graph(htshift.ll_end_setup_builder_graph, [builder])
- newjitstate = llinterp.eval_graph(graph1, graph1args)
- # now try to run the blocks produced by the jitstate
+ jitstate = llinterp.eval_graph(graph1, graph1args)
r = htshift.hrtyper.getrepr(hs)
llinterp.eval_graph(htshift.ll_close_jitstate_graph, [jitstate])
+ # now try to run the blocks produced by the builder
residual_graph = rgenop.buildgraph(startblock)
insns = summary(residual_graph)
res = rgenop.testgengraph(residual_graph, residual_graph_args,
@@ -559,3 +558,12 @@
insns, res = timeshift(ll_function, [1], [], policy=P_NOVIRTUAL)
assert res == 1 + 2
assert insns == {'int_is_true': 1, 'int_add': 1}
+
+def test_call_simple():
+ def ll_add_one(x):
+ return x + 1
+ def ll_function(y):
+ return ll_add_one(y)
+ insns, res = timeshift(ll_function, [5], [], policy=P_NOVIRTUAL)
+ assert res == 6
+ assert insns == {'int_add': 1}
Modified: pypy/dist/pypy/jit/timeshifter/timeshift.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/timeshift.py (original)
+++ pypy/dist/pypy/jit/timeshifter/timeshift.py Sat Jul 1 17:29:12 2006
@@ -4,7 +4,7 @@
from pypy.annotation import model as annmodel
from pypy.annotation import listdef, dictdef
from pypy.jit.timeshifter import rvalue, oop
-from pypy.jit.timeshifter.rtimeshift import JITState
+from pypy.jit.timeshifter.rtimeshift import JITState, ResidualGraphBuilder
from pypy.rpython import rmodel, rgenop, annlowlevel
from pypy.rpython.lltypesystem import rtuple, rlist, rdict
from pypy.jit.timeshifter import rtimeshift
@@ -24,6 +24,7 @@
self.annhelper = annlowlevel.MixLevelHelperAnnotator(rtyper)
+ self.s_ResidualGraphBuilder, self.r_ResidualGraphBuilder = self.s_r_instanceof(ResidualGraphBuilder)
self.s_JITState, self.r_JITState = self.s_r_instanceof(JITState)
self.s_RedBox, self.r_RedBox = self.s_r_instanceof(rvalue.RedBox)
self.s_OopSpecDesc, self.r_OopSpecDesc = self.s_r_instanceof(
@@ -45,9 +46,9 @@
self.r_box_accum = getrepr(self.s_box_accum)
self.r_box_accum.setup()
- self.ll_build_jitstate_graph = self.annhelper.getgraph(
- rtimeshift.ll_build_jitstate,
- [], self.s_JITState)
+ self.ll_make_builder_graph = self.annhelper.getgraph(
+ rtimeshift.ll_make_builder,
+ [], self.s_ResidualGraphBuilder)
self.ll_int_box_graph = self.annhelper.getgraph(
rtimeshift.ll_int_box,
[rgenop.s_ConstOrVar, rgenop.s_ConstOrVar],
@@ -62,12 +63,13 @@
self.s_RedBox)
self.ll_geninputarg_graph = self.annhelper.getgraph(
rtimeshift.ll_geninputarg,
- [self.s_JITState, annmodel.SomePtr(rgenop.CONSTORVAR)],
+ [self.s_ResidualGraphBuilder, annmodel.SomePtr(rgenop.CONSTORVAR)],
rgenop.s_ConstOrVar)
- self.ll_end_setup_jitstate_graph = self.annhelper.getgraph(
- rtimeshift.ll_end_setup_jitstate,
- [self.s_JITState],
+ self.ll_end_setup_builder_graph = self.annhelper.getgraph(
+ rtimeshift.ll_end_setup_builder,
+ [self.s_ResidualGraphBuilder],
annmodel.SomePtr(rgenop.BLOCK))
+
self.ll_close_jitstate_graph = self.annhelper.getgraph(
rtimeshift.ll_close_jitstate,
[self.s_JITState],
@@ -124,16 +126,22 @@
self.dispatch_to.append((self.latestexitindex, from_dispatch))
return self.latestexitindex
+ def schedule_graph(self, graph):
+ if graph not in self.already_scheduled_graphs:
+ self.already_scheduled_graphs[graph] = True
+ self.graphs_to_timeshift.append(graph)
+
def timeshift(self):
- # XXX in-progress:
- ##for graph in self.hannotator.translator.graphs:
- ## self.timeshift_graph(graph)
-
- # instead:
- graph = self.hannotator.translator.graphs[0]
- self.timeshift_graph(graph)
+ self.already_scheduled_graphs = {}
+ self.graphs_to_timeshift = []
+
+ self.schedule_graph(self.hannotator.translator.graphs[0])
+
+ while self.graphs_to_timeshift:
+ graph = self.graphs_to_timeshift.pop()
+ self.timeshift_graph(graph)
- # Annotate and rType the helpers found during timeshifting
+ # Annotate and rtype the helpers found during timeshifting
self.annhelper.finish()
def timeshift_graph(self, graph):
@@ -186,9 +194,27 @@
source.append(" pass")
exec py.code.Source('\n'.join(source)).compile() in miniglobals
clearcaches = miniglobals['clearcaches']
- self.ll_clearcaches = self.annhelper.getgraph(clearcaches, [],
- annmodel.s_None)
+ self.c_ll_clearcaches_ptr = self.annhelper.constfunc(clearcaches, [],
+ annmodel.s_None)
+ self.insert_start_setup()
+
+ def insert_start_setup(self):
+ newstartblock = self.insert_before_block(self.graph.startblock, None, closeblock=True)
+ v_builder = flowmodel.Variable('builder')
+ v_builder.concretetype = self.r_ResidualGraphBuilder.lowleveltype
+ v_jitstate = newstartblock.inputargs[0]
+ newstartblock.inputargs[0] = v_builder
+ llops = HintLowLevelOpList(self, None)
+
+ llops.genop('direct_call', [self.c_ll_clearcaches_ptr])
+ v_jitstate1 = llops.genmixlevelhelpercall(rtimeshift.enter_graph,
+ [self.s_ResidualGraphBuilder],
+ [v_builder],
+ self.s_JITState)
+ llops.append(flowmodel.SpaceOperation('same_as', [v_jitstate1], v_jitstate))
+ newstartblock.operations = list(llops)
+
def insert_jitstate_arg(self, block):
# pass 'jitstate' as an extra argument around the whole graph
if block.operations != ():
Modified: pypy/dist/pypy/jit/timeshifter/vlist.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/vlist.py (original)
+++ pypy/dist/pypy/jit/timeshifter/vlist.py Sat Jul 1 17:29:12 2006
@@ -75,7 +75,7 @@
typedesc = self.typedesc
boxes = self.item_boxes
self.item_boxes = None
- llops = rgenop.LowLevelOpBuilder(jitstate.curblock)
+ llops = jitstate.curbuilder
gv_list = typedesc.build_newlist(llops, len(boxes))
self.ownbox.genvar = gv_list
self.ownbox.content = None
Modified: pypy/dist/pypy/rpython/annlowlevel.py
==============================================================================
--- pypy/dist/pypy/rpython/annlowlevel.py (original)
+++ pypy/dist/pypy/rpython/annlowlevel.py Sat Jul 1 17:29:12 2006
@@ -99,6 +99,8 @@
funcdesc2 = bk.getdesc(x)
return pol.default_specialize(funcdesc2, args_s)
+ specialize__ll = default_specialize
+
def annotate_lowlevel_helper(annotator, ll_function, args_s, policy=None):
if policy is None:
policy= LowLevelAnnotatorPolicy()
Modified: pypy/dist/pypy/rpython/rgenop.py
==============================================================================
--- pypy/dist/pypy/rpython/rgenop.py (original)
+++ pypy/dist/pypy/rpython/rgenop.py Sat Jul 1 17:29:12 2006
@@ -52,12 +52,15 @@
return res
# is opname a runtime value?
-def genop(blockcontainer, opname, vars, gv_RESULT_TYPE):
+def genop(blockcontainer, opname, vars, resulttype):
if not isinstance(opname, str):
opname = LLSupport.from_rstr(opname)
block = from_opaque_object(blockcontainer.obj)
assert block.exits == [], "block already closed"
- RESULT_TYPE = from_opaque_object(gv_RESULT_TYPE).value
+ if isinstance(resulttype, lltype.LowLevelType):
+ RESULT_TYPE = resultype
+ else:
+ RESULT_TYPE = from_opaque_object(resulttype).value
opvars = _inputvars(vars)
v = flowmodel.Variable()
v.concretetype = RESULT_TYPE
@@ -242,6 +245,8 @@
# support constants and types
nullvar = lltype.nullptr(CONSTORVAR.TO)
+nullblock = lltype.nullptr(BLOCK.TO)
+nulllink = lltype.nullptr(LINK.TO)
gv_Void = constTYPE(lltype.Void)
# VARLIST
@@ -322,7 +327,7 @@
genconst = staticmethod(genconst)
genvoidconst = staticmethod(placeholder)
- def genop(self, opname, args_gv, RESULTTYPE=lltype.Void):
- gv_result_type = constTYPE(RESULTTYPE)
- return genop(self.block, opname, args_gv, gv_result_type)
- genop._annspecialcase_ = 'specialize:arg(3)'
+ def genop(self, opname, args_gv, resulttype=lltype.Void):
+ #gv_result_type = constTYPE(RESULTTYPE)
+ return genop(self.block, opname, args_gv, resulttype)
+ genop._annspecialcase_ = "specialize:ll"
More information about the Pypy-commit
mailing list