[pypy-svn] r25211 - in pypy/branch/jit-timeshifter-refactoring: . hintannotator llabstractinterp timeshifter tl
arigo at codespeak.net
arigo at codespeak.net
Sat Apr 1 19:32:25 CEST 2006
Author: arigo
Date: Sat Apr 1 19:32:24 2006
New Revision: 25211
Added:
pypy/branch/jit-timeshifter-refactoring/
- copied from r25209, pypy/dist/pypy/jit/
pypy/branch/jit-timeshifter-refactoring/hintannotator/
- copied from r25210, pypy/dist/pypy/jit/hintannotator/
pypy/branch/jit-timeshifter-refactoring/llabstractinterp/
- copied from r25210, pypy/dist/pypy/jit/llabstractinterp/
pypy/branch/jit-timeshifter-refactoring/timeshifter/
- copied from r25210, pypy/dist/pypy/jit/timeshifter/
pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py
pypy/branch/jit-timeshifter-refactoring/tl/
- copied from r25210, pypy/dist/pypy/jit/tl/
Modified:
pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py
pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py
Log:
(pedronis, arre, arigo)
Start of a refactoring to look a bit more like llabstractinterp.llvalue
and, uncoincidentally, a bit more like Psyco. A bit.
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/rtimeshift.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/rtimeshift.py Sat Apr 1 19:32:24 2006
@@ -27,411 +27,411 @@
return l
-class RedBox(object):
+##class RedBox(object):
- def same_constant(self, other):
- return False
+## 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(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(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,
- gv_Void)
-
- def op_getsubstruct(self, jitstate, fielddesc):
- op_args = lltype.malloc(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
+## 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(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(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,
+## gv_Void)
+
+## def op_getsubstruct(self, jitstate, fielddesc):
+## op_args = lltype.malloc(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]
-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_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_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_getsubstruct(self, jitstate, fielddesc):
+## if self.content_boxes is None:
+## return RedBox.op_getsubstruct(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(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)
-class VirtualRedBox(BigRedBox):
- "A red box that contains (for now) a virtual Struct."
+## 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 __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(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 _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 _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(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 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(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 _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 _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 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 _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)
+##def ll_getvalue(box, T):
+## return box.ll_getvalue(T)
-class IntRedBox(ConstRedBox):
- "A red box that contains a constant integer-like value."
+##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))
+## 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."
+##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))
+## 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."
+##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))
+## def same_constant(self, other):
+## return (isinstance(other, AddrRedBox) and
+## self.ll_getvalue(llmemory.Address) == other.ll_getvalue(llmemory.Address))
# ____________________________________________________________
Added: pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py
==============================================================================
--- (empty file)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/rvalue.py Sat Apr 1 19:32:24 2006
@@ -0,0 +1,264 @@
+from pypy.rpython import rgenop
+from pypy.rpython.lltypesystem import lltype
+
+
+class AbstractRedBox(object):
+
+ def __init__(self, genvar=rgenop.nullvar):
+ self.genvar = genvar # nullvar or a genvar
+
+ def __repr__(self):
+ if not self.genvar:
+ return '<dummy>'
+ else:
+ return '<%r>' % (rgenop.reveal(self.genvar),)
+
+ def is_constant(self):
+ return bool(self.genvar) and rgenop.isconst(self.genvar)
+
+ def getgenvar(self, jitstate):
+ return self.genvar
+
+ def ll_fromvalue(value):
+ "Make a constant RedBox from a low-level value."
+ T = lltype.typeOf(value)
+ gv = rgenop.genconst(value)
+ if isinstance(T, lltype.Ptr):
+ return PtrRedBox(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):
+ "Return the content of a known-to-be-constant RedBox."
+ # 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(AbstractRedBox):
+ "A red box that contains a constant integer-like value."
+
+ def freeze(self, memo):
+ try:
+ return memo[self]
+ except KeyError:
+ if self.is_constant():
+ result = FrozenIntConst(self.genvar)
+ else:
+ result = FrozenIntVar()
+ memo[self] = result
+ return result
+
+
+class DoubleRedBox(AbstractRedBox):
+ "A red box that contains a constant double-precision floating point value."
+
+ def freeze(self, memo):
+ try:
+ return memo[self]
+ except KeyError:
+ if self.is_constant():
+ result = FrozenDoubleConst(self.genvar)
+ else:
+ result = FrozenDoubleVar()
+ memo[self] = result
+ return result
+
+
+class PtrRedBox(AbstractRedBox):
+
+ def __init__(self, genvar=rgenop.nullvar, content=None):
+ AbstractRedBox.__init__(self, genvar)
+ self.content = content # None or an AbstractContainer
+
+ def __repr__(self):
+ if not self.genvar and self.content is not None:
+ return '<virtual %s>' % (self.content,)
+ else:
+ return AbstractRedBox.__repr__(self)
+
+ def freeze(self, memo):
+ try:
+ return memo[self]
+ except KeyError:
+ if self.genvar:
+ if self.is_constant():
+ result = FrozenPtrConst(self.genvar)
+ else:
+ result = FrozenPtrVar()
+ memo[self] = result
+ else:
+ result = FrozenPtrVirtual()
+ memo[self] = result
+ result.fz_content = self.content.freeze(memo)
+ return result
+
+ def getgenvar(self, jitstate):
+ if not self.genvar:
+ self.genvar = self.content.build_runtime_container(jitstate)
+ return self.genvar
+
+# ____________________________________________________________
+
+class FrozenValue(object):
+ """An abstract value frozen in a saved state.
+ """
+
+
+class FrozenIntConst(FrozenValue):
+
+ def __init__(self, gv_const):
+ self.gv_const = gv_const
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ box = memo[self] = IntRedBox(self.gv_const)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if (box.is_constant() and
+ rgenop.revealconst(lltype.Signed, self.gv_const) ==
+ rgenop.revealconst(lltype.Signed, box.genvar)):
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenIntVar(FrozenValue):
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ gv_value = rgenop.geninputarg(block, gv_type)
+ box = memo[self] = IntRedBox(gv_value)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if self not in memo:
+ memo[self] = box
+ outgoingvars.append(box)
+ return True
+ elif memo[self] is box:
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenDoubleConst(FrozenValue):
+
+ def __init__(self, gv_const):
+ self.gv_const = gv_const
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ box = memo[self] = DoubleRedBox(self.gv_const)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if (box.is_constant() and
+ rgenop.revealconst(lltype.Double, self.gv_const) ==
+ rgenop.revealconst(lltype.Double, box.genvar)):
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenDoubleVar(FrozenValue):
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ gv_value = rgenop.geninputarg(block, gv_type)
+ box = memo[self] = DoubleRedBox(gv_value)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if self not in memo:
+ memo[self] = box
+ outgoingvars.append(box)
+ return True
+ elif memo[self] is box:
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenPtrConst(FrozenValue):
+
+ def __init__(self, gv_const):
+ self.gv_const = gv_const
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ box = memo[self] = PtrRedBox(self.gv_const)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if (box.is_constant() and
+ rgenop.revealconst(lltype.Address, self.gv_const) ==
+ rgenop.revealconst(lltype.Address, box.genvar)):
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenPtrVar(FrozenValue):
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ gv_value = rgenop.geninputarg(block, gv_type)
+ box = memo[self] = PtrRedBox(gv_value)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ if self not in memo:
+ memo[self] = box
+ outgoingvars.append(box)
+ return True
+ elif memo[self] is box:
+ return True
+ else:
+ outgoingvars.append(box)
+ return False
+
+
+class FrozenPtrVirtual(FrozenValue):
+
+ def unfreeze(self, memo, block, gv_type):
+ try:
+ return memo[self]
+ except KeyError:
+ box = memo[self] = PtrRedBox()
+ box.content = self.fz_content.unfreeze(memo, block)
+ return box
+
+ def exactmatch(self, box, outgoingvars, memo):
+ assert isinstance(box, PtrRedBox)
+ if box.content is None:
+ outgoingvars.append(box)
+ return False
+ else:
+ return self.fz_content.exactmatch(box.content, outgoingvars, memo)
Modified: pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py
==============================================================================
--- pypy/dist/pypy/jit/timeshifter/timeshift.py (original)
+++ pypy/branch/jit-timeshifter-refactoring/timeshifter/timeshift.py Sat Apr 1 19:32:24 2006
@@ -3,8 +3,7 @@
from pypy.objspace.flow import model as flowmodel
from pypy.annotation import model as annmodel
from pypy.annotation import listdef, dictdef
-from pypy.jit.timeshifter.rtimeshift import VARLIST, RedBox, VarRedBox
-from pypy.jit.timeshifter.rtimeshift import ConstRedBox, JITState
+from pypy.jit.timeshifter.rtimeshift import VARLIST, JITState
from pypy.jit.timeshifter.rtimeshift import make_types_const
from pypy.rpython import rmodel, rlist, rdict, rgenop, annlowlevel
from pypy.rpython.lltypesystem import rtuple
More information about the Pypy-commit
mailing list