[pypy-commit] pypy default: refactoring: split up NotVirtualStateInfo into the int version and the generic
cfbolz
pypy.commits at gmail.com
Mon Jun 20 09:46:41 EDT 2016
Author: Carl Friedrich Bolz <cfbolz at gmx.de>
Branch:
Changeset: r85245:d59182c63df0
Date: 2016-06-20 14:14 +0200
http://bitbucket.org/pypy/pypy/changeset/d59182c63df0/
Log: refactoring: split up NotVirtualStateInfo into the int version and
the generic one (to be refined further)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
@@ -2,7 +2,7 @@
import py
from rpython.jit.metainterp.optimizeopt.virtualstate import VirtualStateInfo,\
VStructStateInfo, LEVEL_CONSTANT,\
- VArrayStateInfo, NotVirtualStateInfo, VirtualState,\
+ VArrayStateInfo, not_virtual, VirtualState,\
GenerateGuardState, VirtualStatesCantMatch, VArrayStructStateInfo
from rpython.jit.metainterp.history import ConstInt, ConstPtr, TargetToken
from rpython.jit.metainterp.resoperation import InputArgInt, InputArgRef,\
@@ -31,10 +31,10 @@
def setup_class(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- self.knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ self.knownclass_info = not_virtual(self.cpu, 'r', value)
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- self.knownclass_info2 = NotVirtualStateInfo(self.cpu, 'r', value)
+ self.knownclass_info2 = not_virtual(self.cpu, 'r', value)
def guards(self, info1, info2, box, runtime_box, expected, inputargs=None):
if inputargs is None:
@@ -80,7 +80,7 @@
def test_make_inputargs(self):
optimizer = FakeOptimizer(self.cpu)
args = [InputArgInt()]
- info0 = NotVirtualStateInfo(self.cpu, args[0].type, None)
+ info0 = not_virtual(self.cpu, args[0].type, None)
vs = VirtualState([info0])
assert vs.make_inputargs(args, optimizer) == args
info0.level = LEVEL_CONSTANT
@@ -108,8 +108,8 @@
assert info1 in state.bad and info2 in state.bad
for BoxType in (InputArgInt, InputArgFloat, InputArgRef):
- info1 = NotVirtualStateInfo(self.cpu, BoxType.type, None)
- info2 = NotVirtualStateInfo(self.cpu, BoxType.type, None)
+ info1 = not_virtual(self.cpu, BoxType.type, None)
+ info2 = not_virtual(self.cpu, BoxType.type, None)
postest(info1, info2)
info1, info2 = VArrayStateInfo(42), VArrayStateInfo(42)
@@ -126,9 +126,9 @@
def test_NotVirtualStateInfo_generalization(self):
def isgeneral(tp1, info1, tp2, info2):
- info1 = NotVirtualStateInfo(self.cpu, tp1, info1)
+ info1 = not_virtual(self.cpu, tp1, info1)
info1.position = 0
- info2 = NotVirtualStateInfo(self.cpu, tp2, info2)
+ info2 = not_virtual(self.cpu, tp2, info2)
info2.position = 0
return VirtualState([info1]).generalization_of(VirtualState([info2]), FakeOptimizer(self.cpu))
@@ -166,8 +166,8 @@
assert not isgeneral('r', value1, 'r', value2)
def test_field_matching_generalization(self):
- const1 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(1))
- const2 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(2))
+ const1 = not_virtual(self.cpu, 'i', ConstIntBound(1))
+ const2 = not_virtual(self.cpu, 'i', ConstIntBound(2))
const1.position = const2.position = 1
self.check_invalid(const1, const2)
self.check_invalid(const2, const1)
@@ -192,16 +192,16 @@
def test_known_class_generalization(self):
knownclass1 = info.InstancePtrInfo(None, ConstPtr(self.myptr))
- info1 = NotVirtualStateInfo(self.cpu, 'r', knownclass1)
+ info1 = not_virtual(self.cpu, 'r', knownclass1)
info1.position = 0
knownclass2 = info.InstancePtrInfo(None, ConstPtr(self.myptr))
- info2 = NotVirtualStateInfo(self.cpu, 'r', knownclass2)
+ info2 = not_virtual(self.cpu, 'r', knownclass2)
info2.position = 0
self.check_no_guards(info1, info2)
self.check_no_guards(info2, info1)
knownclass3 = info.InstancePtrInfo(None, ConstPtr(self.myptr2))
- info3 = NotVirtualStateInfo(self.cpu, 'r', knownclass3)
+ info3 = not_virtual(self.cpu, 'r', knownclass3)
info3.position = 0
self.check_invalid(info1, info3)
self.check_invalid(info2, info3)
@@ -222,26 +222,26 @@
#unknown_val = PtrOptValue(self.nodebox)
#unknownnull_val = PtrOptValue(BoxPtr(self.nullptr))
opt = FakeOptimizer(self.cpu)
- unknown_info = NotVirtualStateInfo(self.cpu, 'r', None)
+ unknown_info = not_virtual(self.cpu, 'r', None)
- nonnull_info = NotVirtualStateInfo(self.cpu, 'r', info.NonNullPtrInfo())
+ nonnull_info = not_virtual(self.cpu, 'r', info.NonNullPtrInfo())
classbox1 = self.cpu.ts.cls_of_box(ConstPtr(self.nodeaddr))
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r',
- info.InstancePtrInfo(None, classbox1))
+ knownclass_info = not_virtual(self.cpu, 'r',
+ info.InstancePtrInfo(None, classbox1))
classbox2 = self.cpu.ts.cls_of_box(ConstPtr(self.node2addr))
- knownclass2_info = NotVirtualStateInfo(self.cpu, 'r',
- info.InstancePtrInfo(None, classbox2))
+ knownclass2_info = not_virtual(self.cpu, 'r',
+ info.InstancePtrInfo(None, classbox2))
- constant_info = NotVirtualStateInfo(self.cpu, 'i',
- ConstIntBound(1))
- constant_ptr_info = NotVirtualStateInfo(self.cpu, 'r',
+ constant_info = not_virtual(self.cpu, 'i',
+ ConstIntBound(1))
+ constant_ptr_info = not_virtual(self.cpu, 'r',
info.ConstPtrInfo(ConstPtr(self.nodeaddr)))
constclass_val = info.ConstPtrInfo(ConstPtr(self.nodeaddr))
- constclass_info = NotVirtualStateInfo(self.cpu, 'r', constclass_val)
- constclass2_info = NotVirtualStateInfo(self.cpu, 'r',
+ constclass_info = not_virtual(self.cpu, 'r', constclass_val)
+ constclass2_info = not_virtual(self.cpu, 'r',
info.ConstPtrInfo(ConstPtr(self.node2addr)))
- constantnull_info = NotVirtualStateInfo(self.cpu, 'r',
+ constantnull_info = not_virtual(self.cpu, 'r',
info.ConstPtrInfo(ConstPtr(self.nullptr)))
# unknown unknown
@@ -392,8 +392,8 @@
value1 = IntUnbounded()
value1.make_ge(IntBound(0, 10))
value1.make_le(IntBound(20, 30))
- info1 = NotVirtualStateInfo(self.cpu, 'i', value1)
- info2 = NotVirtualStateInfo(self.cpu, 'i', IntUnbounded())
+ info1 = not_virtual(self.cpu, 'i', value1)
+ info2 = not_virtual(self.cpu, 'i', IntUnbounded())
expected = """
[i0]
i1 = int_ge(i0, 0)
@@ -408,18 +408,18 @@
value1 = IntUnbounded()
value1.make_ge(IntBound(0, 10))
value1.make_le(IntBound(20, 30))
- info1 = NotVirtualStateInfo(self.cpu, 'i', value1)
- info2 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(10000))
+ info1 = not_virtual(self.cpu, 'i', value1)
+ info2 = not_virtual(self.cpu, 'i', ConstIntBound(10000))
self.check_invalid(info1, info2)
- info1 = NotVirtualStateInfo(self.cpu, 'i', value1)
- info2 = NotVirtualStateInfo(self.cpu, 'i', ConstIntBound(11))
+ info1 = not_virtual(self.cpu, 'i', value1)
+ info2 = not_virtual(self.cpu, 'i', ConstIntBound(11))
self.check_no_guards(info1, info2)
def test_known_class(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value1 = info.InstancePtrInfo(None, classbox)
- info1 = NotVirtualStateInfo(self.cpu, 'r', value1)
- info2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ info1 = not_virtual(self.cpu, 'r', value1)
+ info2 = not_virtual(self.cpu, 'r', None)
expected = """
[p0]
guard_nonnull_class(p0, ConstClass(node_vtable)) []
@@ -456,18 +456,18 @@
def test_equal_inputargs(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
vstate1 = VirtualState([knownclass_info, knownclass_info])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
- unknown_info1 = NotVirtualStateInfo(self.cpu, 'r', None)
+ unknown_info1 = not_virtual(self.cpu, 'r', None)
vstate2 = VirtualState([unknown_info1, unknown_info1])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
assert not vstate1.generalization_of(vstate2, FakeOptimizer(self.cpu))
assert vstate2.generalization_of(vstate1, FakeOptimizer(self.cpu))
- unknown_info1 = NotVirtualStateInfo(self.cpu, 'r', None)
- unknown_info2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ unknown_info1 = not_virtual(self.cpu, 'r', None)
+ unknown_info2 = not_virtual(self.cpu, 'r', None)
vstate3 = VirtualState([unknown_info1, unknown_info2])
assert vstate3.generalization_of(vstate2, FakeOptimizer(self.cpu))
assert vstate3.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -494,9 +494,9 @@
def test_generate_guards_on_virtual_fields_matches_array(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
innervalue1 = info.InstancePtrInfo(None, classbox)
- innerinfo1 = NotVirtualStateInfo(self.cpu, 'r', innervalue1)
+ innerinfo1 = not_virtual(self.cpu, 'r', innervalue1)
innerinfo1.position = 1
- innerinfo2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ innerinfo2 = not_virtual(self.cpu, 'r', None)
innerinfo2.position = 1
descr = ArrayDescr(lltype.GcArray(llmemory.GCREF), self.cpu)
@@ -524,9 +524,9 @@
def test_generate_guards_on_virtual_fields_matches_instance(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
innervalue1 = info.InstancePtrInfo(None, classbox)
- innerinfo1 = NotVirtualStateInfo(self.cpu, 'r', innervalue1)
+ innerinfo1 = not_virtual(self.cpu, 'r', innervalue1)
innerinfo1.position = 1
- innerinfo2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ innerinfo2 = not_virtual(self.cpu, 'r', None)
innerinfo2.position = 1
info1 = VirtualStateInfo(ConstInt(42), [self.nextdescr])
@@ -552,9 +552,9 @@
def test_generate_guards_on_virtual_fields_matches_struct(self):
constclassbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
innervalue1 = info.InstancePtrInfo(None, constclassbox)
- innerinfo1 = NotVirtualStateInfo(self.cpu, 'r', innervalue1)
+ innerinfo1 = not_virtual(self.cpu, 'r', innervalue1)
innerinfo1.position = 1
- innerinfo2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ innerinfo2 = not_virtual(self.cpu, 'r', None)
innerinfo2.position = 1
structdescr = self.nodesize
@@ -583,9 +583,9 @@
def test_generate_guards_on_virtual_fields_matches_arraystruct(self):
constclassbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
innervalue1 = info.InstancePtrInfo(None, constclassbox)
- innerinfo1 = NotVirtualStateInfo(self.cpu, 'r', innervalue1)
+ innerinfo1 = not_virtual(self.cpu, 'r', innervalue1)
innerinfo1.position = 1
- innerinfo2 = NotVirtualStateInfo(self.cpu, 'r', None)
+ innerinfo2 = not_virtual(self.cpu, 'r', None)
innerinfo2.position = 1
NODE = lltype.Struct('NODE', ('x', llmemory.GCREF))
@@ -627,7 +627,7 @@
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
info2 = VirtualStateInfo(ConstInt(42), [1, 2])
- unknown_info1 = NotVirtualStateInfo(self.cpu, 'r',
+ unknown_info1 = not_virtual(self.cpu, 'r',
info.InstancePtrInfo())
info2.fieldstate = [unknown_info1, unknown_info1]
vstate2 = VirtualState([info2])
@@ -636,9 +636,9 @@
assert vstate2.generalization_of(vstate1, FakeOptimizer(self.cpu))
info3 = VirtualStateInfo(ConstInt(42), [1, 2])
- unknown_info1 = NotVirtualStateInfo(self.cpu, 'r',
+ unknown_info1 = not_virtual(self.cpu, 'r',
info.InstancePtrInfo())
- unknown_info2 = NotVirtualStateInfo(self.cpu, 'r',
+ unknown_info2 = not_virtual(self.cpu, 'r',
info.InstancePtrInfo())
info3.fieldstate = [unknown_info1, unknown_info2]
vstate3 = VirtualState([info3])
@@ -651,7 +651,7 @@
info1 = VirtualStateInfo(ConstInt(42), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -659,7 +659,7 @@
info2 = VirtualStateInfo(ConstInt(42), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info2.fieldstate = [knownclass_info, knownclass_info]
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -671,7 +671,7 @@
info1 = VirtualStateInfo(ConstInt(42), [10, 20])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -679,7 +679,7 @@
info2 = VirtualStateInfo(ConstInt(42), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info2.fieldstate = [knownclass_info, knownclass_info]
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -691,7 +691,7 @@
info1 = VirtualStateInfo(ConstInt(42), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -699,7 +699,7 @@
info2 = VirtualStateInfo(ConstInt(7), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info2.fieldstate = [knownclass_info, knownclass_info]
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -711,12 +711,12 @@
info1 = VirtualStateInfo(ConstInt(42), [1, 2])
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
- info2 = NotVirtualStateInfo(self.cpu, 'r', value)
+ info2 = not_virtual(self.cpu, 'r', value)
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -727,7 +727,7 @@
info1 = VArrayStateInfo(42)
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -735,7 +735,7 @@
info2 = VArrayStateInfo(42)
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info2.fieldstate = [knownclass_info, knownclass_info]
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -747,7 +747,7 @@
info1 = VArrayStateInfo(42)
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info1.fieldstate = [knownclass_info, knownclass_info]
vstate1 = VirtualState([info1])
assert vstate1.generalization_of(vstate1, FakeOptimizer(self.cpu))
@@ -755,7 +755,7 @@
info2 = VArrayStateInfo(42)
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.node2addr))
value = info.InstancePtrInfo(None, classbox)
- knownclass_info = NotVirtualStateInfo(self.cpu, 'r', value)
+ knownclass_info = not_virtual(self.cpu, 'r', value)
info2.fieldstate = [knownclass_info]
vstate2 = VirtualState([info2])
assert vstate2.generalization_of(vstate2, FakeOptimizer(self.cpu))
@@ -793,7 +793,7 @@
def test_crash_varay_clear(self):
classbox = self.cpu.ts.cls_of_box(InputArgRef(self.nodeaddr))
innervalue1 = info.InstancePtrInfo(None, classbox)
- innerinfo1 = NotVirtualStateInfo(self.cpu, 'r', innervalue1)
+ innerinfo1 = not_virtual(self.cpu, 'r', innervalue1)
innerinfo1.position = 1
innerinfo1.position_in_notvirtuals = 0
diff --git a/rpython/jit/metainterp/optimizeopt/virtualstate.py b/rpython/jit/metainterp/optimizeopt/virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualstate.py
@@ -350,21 +350,25 @@
def debug_header(self, indent):
debug_print(indent + 'VArrayStructStateInfo(%d):' % self.position)
+
+def not_virtual(cpu, type, info):
+ if type == 'i':
+ return NotVirtualStateInfoInt(cpu, type, info)
+ return NotVirtualStateInfo(cpu, type, info)
+
+
class NotVirtualStateInfo(AbstractVirtualStateInfo):
lenbound = None
- intbound = None
level = LEVEL_UNKNOWN
constbox = None
known_class = None
-
+
def __init__(self, cpu, type, info):
if info and info.is_constant():
self.level = LEVEL_CONSTANT
self.constbox = info.getconst()
if type == 'r':
self.known_class = info.get_known_class(cpu)
- elif type == 'i':
- self.intbound = info
elif type == 'r':
if info:
self.known_class = info.get_known_class(cpu)
@@ -373,13 +377,6 @@
elif info.is_nonnull():
self.level = LEVEL_NONNULL
self.lenbound = info.getlenbound(None)
- elif type == 'i':
- if isinstance(info, IntBound):
- if info.lower < MININT / 2:
- info.lower = MININT
- if info.upper > MAXINT / 2:
- info.upper = MAXINT
- self.intbound = info
elif type == 'f':
if info and info.is_constant():
self.level = LEVEL_CONSTANT
@@ -412,11 +409,9 @@
raise VirtualStatesCantMatch("length bound does not match")
if self.level == LEVEL_UNKNOWN:
- # confusingly enough, this is done also for pointers
- # which have the full range as the "bound", so it always works
- return self._generate_guards_intbounds(other, box, runtime_box,
- extra_guards,
- state.optimizer)
+ return self._generate_guards_unkown(other, box, runtime_box,
+ extra_guards,
+ state.optimizer)
# the following conditions often peek into the runtime value that the
# box had when tracing. This value is only used as an educated guess.
@@ -485,19 +480,9 @@
raise VirtualStatesCantMatch("other not constant")
assert 0, "unreachable"
- def _generate_guards_intbounds(self, other, box, runtime_box, extra_guards,
- optimizer):
- if self.intbound is None:
- return
- if self.intbound.contains_bound(other.intbound):
- return
- if (runtime_box is not None and
- self.intbound.contains(runtime_box.getint())):
- # this may generate a few more guards than needed, but they are
- # optimized away when emitting them
- self.intbound.make_guards(box, extra_guards, optimizer)
- return
- raise VirtualStatesCantMatch("intbounds don't match")
+ def _generate_guards_unkown(self, other, box, runtime_box, extra_guards,
+ optimizer):
+ return
def enum_forced_boxes(self, boxes, box, optimizer, force_boxes=False):
if self.level == LEVEL_CONSTANT:
@@ -553,8 +538,46 @@
if self.lenbound:
lb = ', ' + self.lenbound.bound.__repr__()
- debug_print(indent + mark + 'NotVirtualInfo(%d' % self.position +
- ', ' + l + ', ' + self.intbound.__repr__() + lb + ')')
+ result = indent + mark + 'NotVirtualStateInfo(%d' % self.position + ', ' + l
+ extra = self._extra_repr()
+ if extra:
+ result += ', ' + extra
+ result += lb + ')'
+ debug_print(result)
+
+class NotVirtualStateInfoInt(NotVirtualStateInfo):
+ intbound = None
+
+ def __init__(self, cpu, type, info):
+ NotVirtualStateInfo.__init__(self, cpu, type, info)
+ assert type == 'i'
+ if isinstance(info, IntBound):
+ if info.lower < MININT / 2:
+ info.lower = MININT
+ if info.upper > MAXINT / 2:
+ info.upper = MAXINT
+ self.intbound = info
+
+ def _generate_guards_unkown(self, other, box, runtime_box, extra_guards,
+ optimizer):
+ other_intbound = None
+ if isinstance(other, NotVirtualStateInfoInt):
+ other_intbound = other.intbound
+ if self.intbound is None:
+ return
+ if self.intbound.contains_bound(other_intbound):
+ return
+ if (runtime_box is not None and
+ self.intbound.contains(runtime_box.getint())):
+ # this may generate a few more guards than needed, but they are
+ # optimized away when emitting them
+ self.intbound.make_guards(box, extra_guards, optimizer)
+ return
+ raise VirtualStatesCantMatch("intbounds don't match")
+
+ def _extra_repr(self):
+ return self.intbound.__repr__()
+
class VirtualState(object):
@@ -678,8 +701,8 @@
return VirtualState(state)
def visit_not_virtual(self, box):
- return NotVirtualStateInfo(self.optimizer.cpu, box.type,
- self.optimizer.getinfo(box))
+ return not_virtual(self.optimizer.cpu, box.type,
+ self.optimizer.getinfo(box))
def visit_virtual(self, descr, fielddescrs):
known_class = ConstInt(descr.get_vtable())
More information about the pypy-commit
mailing list