def make_constant(self, constbox):
"""Replace 'self.box' with a Const box."""
assert isinstance(constbox, Const)
self.box = constbox
self.level = LEVEL_CONSTANT
if isinstance(constbox, ConstInt):
val = constbox.getint()
self.intbound = IntBound(val, val)
else:
self.intbound = IntUnbounded()
def __init__(self, value, is_opaque=False):
self.is_opaque = is_opaque
self.known_class = value.get_known_class()
self.level = value.getlevel()
if value.getintbound() is None:
self.intbound = IntUnbounded()
else:
self.intbound = value.getintbound().clone()
if value.is_constant():
self.constbox = value.box
else:
self.constbox = None
self.position_in_notvirtuals = -1
self.lenbound = value.getlenbound()
def __init__(self, box, level=None, known_class=None, intbound=None):
self.box = box
if level is not None:
self.level = level
self.known_class = known_class
if intbound:
self.intbound = intbound
else:
if isinstance(box, BoxInt):
self.intbound = IntBound(MININT, MAXINT)
else:
self.intbound = IntUnbounded()
if isinstance(box, Const):
self.make_constant(box)
def bound(a, b):
if a is None and b is None:
return IntUnbounded()
elif a is None:
return IntUpperBound(b)
elif b is None:
return IntLowerBound(a)
else:
return IntBound(a, b)
def __init__(self, box, level=None, known_class=None, intbound=None):
OptValue.__init__(self, box, level, None, None)
if isinstance(box, Const):
return
if intbound:
self.intbound = intbound
else:
if isinstance(box, BoxInt):
self.intbound = IntBound(MININT, MAXINT)
else:
self.intbound = IntUnbounded()
def __init__(self, value, is_opaque=False):
self.is_opaque = is_opaque
self.known_class = value.known_class
self.level = value.level
if value.intbound is None:
self.intbound = IntUnbounded()
else:
self.intbound = value.intbound.clone()
if value.is_constant():
self.constbox = value.box
else:
self.constbox = None
self.position_in_notvirtuals = -1
self.lenbound = value.lenbound
def getintbound(self, op):
assert op.type == 'i'
op = get_box_replacement(op)
if isinstance(op, ConstInt):
return ConstIntBound(op.getint())
fw = op.get_forwarded()
if fw is not None:
if isinstance(fw, IntBound):
return fw
# rare case: fw might be a RawBufferPtrInfo
return IntUnbounded()
assert op.type == 'i'
intbound = IntBound(MININT, MAXINT)
op.set_forwarded(intbound)
return intbound
class OptValue(object):
__metaclass__ = extendabletype
_attrs_ = ('box', 'known_class', 'last_guard', 'level', 'intbound', 'lenbound')
last_guard = None
level = LEVEL_UNKNOWN
known_class = None
intbound = ImmutableIntUnbounded()
lenbound = None
def __init__(self, box, level=None, known_class=None, intbound=None):
self.box = box
if level is not None:
self.level = level
self.known_class = known_class
if intbound:
self.intbound = intbound
else:
if isinstance(box, BoxInt):
self.intbound = IntBound(MININT, MAXINT)
else:
self.intbound = IntUnbounded()
if isinstance(box, Const):
self.make_constant(box)
# invariant: box is a Const if and only if level == LEVEL_CONSTANT
def make_len_gt(self, mode, descr, val):
if self.lenbound:
assert self.lenbound.mode == mode
assert self.lenbound.descr == descr
self.lenbound.bound.make_gt(IntBound(val, val))
else:
self.lenbound = LenBound(mode, descr, IntLowerBound(val + 1))
def make_guards(self, box):
guards = []
if self.level == LEVEL_CONSTANT:
op = ResOperation(rop.GUARD_VALUE, [box, self.box], None)
guards.append(op)
elif self.level == LEVEL_KNOWNCLASS:
op = ResOperation(rop.GUARD_NONNULL, [box], None)
guards.append(op)
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
guards.append(op)
else:
if self.level == LEVEL_NONNULL:
op = ResOperation(rop.GUARD_NONNULL, [box], None)
guards.append(op)
self.intbound.make_guards(box, guards)
if self.lenbound:
lenbox = BoxInt()
if self.lenbound.mode == MODE_ARRAY:
op = ResOperation(rop.ARRAYLEN_GC, [box], lenbox, self.lenbound.descr)
elif self.lenbound.mode == MODE_STR:
op = ResOperation(rop.STRLEN, [box], lenbox, self.lenbound.descr)
elif self.lenbound.mode == MODE_UNICODE:
op = ResOperation(rop.UNICODELEN, [box], lenbox, self.lenbound.descr)
else:
debug_print("Unknown lenbound mode")
assert False
guards.append(op)
self.lenbound.bound.make_guards(lenbox, guards)
return guards
def import_from(self, other, optimizer):
if self.level == LEVEL_CONSTANT:
assert other.level == LEVEL_CONSTANT
assert other.box.same_constant(self.box)
return
assert self.level <= LEVEL_NONNULL
if other.level == LEVEL_CONSTANT:
self.make_constant(other.get_key_box())
optimizer.turned_constant(self)
elif other.level == LEVEL_KNOWNCLASS:
self.make_constant_class(other.known_class, None)
else:
if other.level == LEVEL_NONNULL:
self.ensure_nonnull()
self.intbound.intersect(other.intbound)
if other.lenbound:
if self.lenbound:
assert other.lenbound.mode == self.lenbound.mode
assert other.lenbound.descr == self.lenbound.descr
self.lenbound.bound.intersect(other.lenbound.bound)
else:
self.lenbound = other.lenbound.clone()
def force_box(self, optforce):
return self.box
def get_key_box(self):
return self.box
def force_at_end_of_preamble(self, already_forced, optforce):
return self
def get_args_for_fail(self, modifier):
pass
def make_virtual_info(self, modifier, fieldnums):
#raise NotImplementedError # should not be called on this level
assert fieldnums is None
return modifier.make_not_virtual(self)
def is_constant(self):
return self.level == LEVEL_CONSTANT
def is_null(self):
if self.is_constant():
box = self.box
assert isinstance(box, Const)
return not box.nonnull()
return False
def same_value(self, other):
if not other:
return False
if self.is_constant() and other.is_constant():
return self.box.same_constant(other.box)
return self is other
def make_constant(self, constbox):
"""Replace 'self.box' with a Const box."""
assert isinstance(constbox, Const)
self.box = constbox
self.level = LEVEL_CONSTANT
if isinstance(constbox, ConstInt):
val = constbox.getint()
self.intbound = IntBound(val, val)
else:
self.intbound = IntUnbounded()
def get_constant_class(self, cpu):
level = self.level
if level == LEVEL_KNOWNCLASS:
return self.known_class
elif level == LEVEL_CONSTANT:
return cpu.ts.cls_of_box(self.box)
else:
return None
def make_constant_class(self, classbox, guardop):
assert self.level < LEVEL_KNOWNCLASS
self.known_class = classbox
self.level = LEVEL_KNOWNCLASS
self.last_guard = guardop
def make_nonnull(self, guardop):
assert self.level < LEVEL_NONNULL
self.level = LEVEL_NONNULL
self.last_guard = guardop
def is_nonnull(self):
level = self.level
if level == LEVEL_NONNULL or level == LEVEL_KNOWNCLASS:
return True
elif level == LEVEL_CONSTANT:
box = self.box
assert isinstance(box, Const)
return box.nonnull()
elif self.intbound:
if self.intbound.known_gt(IntBound(0, 0)) or \
self.intbound.known_lt(IntBound(0, 0)):
return True
else:
return False
else:
return False
def ensure_nonnull(self):
if self.level < LEVEL_NONNULL:
self.level = LEVEL_NONNULL
def is_virtual(self):
# Don't check this with 'isinstance(_, VirtualValue)'!
# Even if it is a VirtualValue, the 'box' can be non-None,
# meaning it has been forced.
return self.box is None
def is_forced_virtual(self):
return False
def getfield(self, ofs, default):
raise NotImplementedError
def setfield(self, ofs, value):
raise NotImplementedError
def getlength(self):
raise NotImplementedError
def getitem(self, index):
raise NotImplementedError
def setitem(self, index, value):
raise NotImplementedError
def getitem_raw(self, offset, length, descr):
raise NotImplementedError
def setitem_raw(self, offset, length, descr, value):
raise NotImplementedError
def getinteriorfield(self, index, ofs, default):
raise NotImplementedError
def setinteriorfield(self, index, ofs, value):
raise NotImplementedError
class NotVirtualStateInfo(AbstractVirtualStateInfo):
def __init__(self, value, is_opaque=False):
self.is_opaque = is_opaque
self.known_class = value.known_class
self.level = value.level
if value.intbound is None:
self.intbound = IntUnbounded()
else:
self.intbound = value.intbound.clone()
if value.is_constant():
self.constbox = value.box
else:
self.constbox = None
self.position_in_notvirtuals = -1
self.lenbound = value.lenbound
def _generate_guards(self, other, value, state):
if value is None or self.is_opaque:
box = None # generating guards for opaque pointers isn't safe
else:
box = value.box
# XXX This will always retrace instead of forcing anything which
# might be what we want sometimes?
if not isinstance(other, NotVirtualStateInfo):
raise VirtualStatesCantMatch(
"The VirtualStates does not match as a "
+ "virtual appears where a pointer is needed "
+ "and it is too late to force it."
)
extra_guards = state.extra_guards
cpu = state.cpu
if self.lenbound and not self.lenbound.generalization_of(other.lenbound):
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, extra_guards)
# the following conditions often peek into the runtime value that the
# box had when tracing. This value is only used as an educated guess.
# It is used here to choose between either emitting a guard and jumping
# to an existing compiled loop or retracing the loop. Both alternatives
# will always generate correct behaviour, but performance will differ.
elif self.level == LEVEL_NONNULL:
if other.level == LEVEL_UNKNOWN:
if box is not None and box.nonnull():
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other not known to be nonnull")
elif other.level == LEVEL_NONNULL:
return
elif other.level == LEVEL_KNOWNCLASS:
return # implies nonnull
else:
assert other.level == LEVEL_CONSTANT
assert other.constbox
if not other.constbox.nonnull():
raise VirtualStatesCantMatch("constant is null")
return
elif self.level == LEVEL_KNOWNCLASS:
if other.level == LEVEL_UNKNOWN:
if box and box.nonnull() and self.known_class.same_constant(cpu.ts.cls_of_box(box)):
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other's class is unknown")
elif other.level == LEVEL_NONNULL:
if box and self.known_class.same_constant(cpu.ts.cls_of_box(box)):
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other's class is unknown")
elif other.level == LEVEL_KNOWNCLASS:
if self.known_class.same_constant(other.known_class):
return
raise VirtualStatesCantMatch("classes don't match")
else:
assert other.level == LEVEL_CONSTANT
if other.constbox.nonnull() and self.known_class.same_constant(cpu.ts.cls_of_box(other.constbox)):
return
else:
raise VirtualStatesCantMatch("classes don't match")
else:
assert self.level == LEVEL_CONSTANT
if other.level == LEVEL_CONSTANT:
if self.constbox.same_constant(other.constbox):
return
raise VirtualStatesCantMatch("different constants")
if box is not None and self.constbox.same_constant(box.constbox()):
op = ResOperation(rop.GUARD_VALUE, [box, self.constbox], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other not constant")
assert 0, "unreachable"
def _generate_guards_intbounds(self, other, box, extra_guards):
if self.intbound.contains_bound(other.intbound):
return
if box is not None and isinstance(box, BoxInt) and self.intbound.contains(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)
return
raise VirtualStatesCantMatch("intbounds don't match")
def enum_forced_boxes(self, boxes, value, optimizer):
if self.level == LEVEL_CONSTANT:
return
assert 0 <= self.position_in_notvirtuals
if optimizer:
box = value.force_box(optimizer)
else:
if value.is_virtual():
raise BadVirtualState
box = value.get_key_box()
boxes[self.position_in_notvirtuals] = box
def _enum(self, virtual_state):
if self.level == LEVEL_CONSTANT:
return
self.position_in_notvirtuals = virtual_state.numnotvirtuals
virtual_state.numnotvirtuals += 1
def debug_print(self, indent, seen, bad, metainterp_sd=None):
mark = ""
if self in bad:
mark = "*"
if self.level == LEVEL_UNKNOWN:
l = "Unknown"
elif self.level == LEVEL_NONNULL:
l = "NonNull"
elif self.level == LEVEL_KNOWNCLASS:
addr = self.known_class.getaddr()
if metainterp_sd:
name = metainterp_sd.get_name_from_address(addr)
else:
name = "?"
l = "KnownClass(%s)" % name
else:
assert self.level == LEVEL_CONSTANT
const = self.constbox
if isinstance(const, ConstInt):
l = "ConstInt(%s)" % (const.value,)
elif isinstance(const, ConstPtr):
if const.value:
l = "ConstPtr"
else:
l = "ConstPtr(null)"
else:
assert isinstance(const, ConstFloat)
l = "ConstFloat(%s)" % const.getfloat()
lb = ""
if self.lenbound:
lb = ", " + self.lenbound.bound.__repr__()
debug_print(
indent + mark + "NotVirtualInfo(%d" % self.position + ", " + l + ", " + self.intbound.__repr__() + lb + ")"
)
def getintbound(self):
return IntUnbounded()
def test_make():
for _, _, b1 in some_bounds():
for _, _, b2 in some_bounds():
lt = IntUnbounded()
lt.make_lt(b1)
lt.make_lt(b2)
for n in nbr:
c = const(n)
if b1.known_le(c) or b2.known_le(c):
assert lt.known_lt(c)
else:
assert not lt.known_lt(c)
assert not lt.known_gt(c)
assert not lt.known_ge(c)
gt = IntUnbounded()
gt.make_gt(b1)
gt.make_gt(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c) or b2.known_ge(c):
assert gt.known_gt(c)
else:
assert not gt.known_gt(c)
assert not gt.known_lt(c)
assert not gt.known_le(c)
le = IntUnbounded()
le.make_le(b1)
le.make_le(b2)
for n in nbr:
c = const(n)
if b1.known_le(c) or b2.known_le(c):
assert le.known_le(c)
else:
assert not le.known_le(c)
assert not le.known_gt(c)
assert not le.known_ge(c)
ge = IntUnbounded()
ge.make_ge(b1)
ge.make_ge(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c) or b2.known_ge(c):
assert ge.known_ge(c)
else:
assert not ge.known_ge(c)
assert not ge.known_lt(c)
assert not ge.known_le(c)
gl = IntUnbounded()
gl.make_ge(b1)
gl.make_le(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c):
assert gl.known_ge(c)
else:
assert not gl.known_ge(c)
assert not gl.known_gt(c)
if b2.known_le(c):
assert gl.known_le(c)
else:
assert not gl.known_le(c)
assert not gl.known_lt(c)
class NotVirtualStateInfo(AbstractVirtualStateInfo):
def __init__(self, value, is_opaque=False):
self.is_opaque = is_opaque
self.known_class = value.known_class
self.level = value.level
if value.intbound is None:
self.intbound = IntUnbounded()
else:
self.intbound = value.intbound.clone()
if value.is_constant():
self.constbox = value.box
else:
self.constbox = None
self.position_in_notvirtuals = -1
self.lenbound = value.lenbound
def generalization_of(self, other, renum, bad):
# XXX This will always retrace instead of forcing anything which
# might be what we want sometimes?
assert self.position != -1
if self.position in renum:
if renum[self.position] == other.position:
return True
bad[self] = None
bad[other] = None
return False
renum[self.position] = other.position
if not isinstance(other, NotVirtualStateInfo):
bad[self] = None
bad[other] = None
return False
if other.level < self.level:
bad[self] = None
bad[other] = None
return False
if self.level == LEVEL_CONSTANT:
if not self.constbox.same_constant(other.constbox):
bad[self] = None
bad[other] = None
return False
elif self.level == LEVEL_KNOWNCLASS:
if not self.known_class.same_constant(other.known_class):
bad[self] = None
bad[other] = None
return False
if not self.intbound.contains_bound(other.intbound):
bad[self] = None
bad[other] = None
return False
if self.lenbound and other.lenbound:
if self.lenbound.mode != other.lenbound.mode or \
self.lenbound.descr != other.lenbound.descr or \
not self.lenbound.bound.contains_bound(other.lenbound.bound):
bad[self] = None
bad[other] = None
return False
elif self.lenbound:
bad[self] = None
bad[other] = None
return False
return True
def _generate_guards(self, other, box, cpu, extra_guards):
if not isinstance(other, NotVirtualStateInfo):
raise InvalidLoop('The VirtualStates does not match as a ' +
'virtual appears where a pointer is needed ' +
'and it is too late to force it.')
if self.lenbound or other.lenbound:
raise InvalidLoop('The array length bounds does not match.')
if self.is_opaque:
raise InvalidLoop('Generating guards for opaque pointers is not safe')
if self.level == LEVEL_KNOWNCLASS and \
box.nonnull() and \
self.known_class.same_constant(cpu.ts.cls_of_box(box)):
# Note: This is only a hint on what the class of box was
# during the trace. There are actually no guarentees that this
# box realy comes from a trace. The hint is used here to choose
# between either eimtting a guard_class and jumping to an
# excisting compiled loop or retracing the loop. Both
# alternatives will always generate correct behaviour, but
# performace will differ.
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
if (self.level == LEVEL_NONNULL and
other.level == LEVEL_UNKNOWN and
isinstance(box, BoxPtr) and
box.nonnull()):
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
return
if (self.level == LEVEL_UNKNOWN and
other.level == LEVEL_UNKNOWN and
isinstance(box, BoxInt) and
self.intbound.contains(box.getint())):
if self.intbound.has_lower:
bound = self.intbound.lower
if not (other.intbound.has_lower and
other.intbound.lower >= bound):
res = BoxInt()
op = ResOperation(rop.INT_GE, [box, ConstInt(bound)], res)
extra_guards.append(op)
op = ResOperation(rop.GUARD_TRUE, [res], None)
extra_guards.append(op)
if self.intbound.has_upper:
bound = self.intbound.upper
if not (other.intbound.has_upper and
other.intbound.upper <= bound):
res = BoxInt()
op = ResOperation(rop.INT_LE, [box, ConstInt(bound)], res)
extra_guards.append(op)
op = ResOperation(rop.GUARD_TRUE, [res], None)
extra_guards.append(op)
return
# Remaining cases are probably not interesting
raise InvalidLoop('Generating guards for making the VirtualStates ' +
'at hand match have not been implemented')
def enum_forced_boxes(self, boxes, value, optimizer):
if self.level == LEVEL_CONSTANT:
return
assert 0 <= self.position_in_notvirtuals
if optimizer:
box = value.force_box(optimizer)
else:
if value.is_virtual():
raise BadVirtualState
box = value.get_key_box()
boxes[self.position_in_notvirtuals] = box
def _enum(self, virtual_state):
if self.level == LEVEL_CONSTANT:
return
self.position_in_notvirtuals = len(virtual_state.notvirtuals)
virtual_state.notvirtuals.append(self)
def debug_print(self, indent, seen, bad):
mark = ''
if self in bad:
mark = '*'
if we_are_translated():
l = {LEVEL_UNKNOWN: 'Unknown',
LEVEL_NONNULL: 'NonNull',
LEVEL_KNOWNCLASS: 'KnownClass',
LEVEL_CONSTANT: 'Constant',
}[self.level]
else:
l = {LEVEL_UNKNOWN: 'Unknown',
LEVEL_NONNULL: 'NonNull',
LEVEL_KNOWNCLASS: 'KnownClass(%r)' % self.known_class,
LEVEL_CONSTANT: 'Constant(%r)' % self.constbox,
}[self.level]
lb = ''
if self.lenbound:
lb = ', ' + self.lenbound.bound.__repr__()
debug_print(indent + mark + 'NotVirtualInfo(%d' % self.position +
', ' + l + ', ' + self.intbound.__repr__() + lb + ')')
class NotVirtualStateInfo(AbstractVirtualStateInfo):
def __init__(self, value, is_opaque=False):
self.is_opaque = is_opaque
self.known_class = value.get_known_class()
self.level = value.getlevel()
if value.getintbound() is None:
self.intbound = IntUnbounded()
else:
self.intbound = value.getintbound().clone()
if value.is_constant():
self.constbox = value.box
else:
self.constbox = None
self.position_in_notvirtuals = -1
self.lenbound = value.getlenbound()
def _generate_guards(self, other, value, state):
if value is None or self.is_opaque:
box = None # generating guards for opaque pointers isn't safe
else:
box = value.box
# XXX This will always retrace instead of forcing anything which
# might be what we want sometimes?
if not isinstance(other, NotVirtualStateInfo):
raise VirtualStatesCantMatch(
'The VirtualStates does not match as a ' +
'virtual appears where a pointer is needed ' +
'and it is too late to force it.')
extra_guards = state.extra_guards
cpu = state.cpu
if self.lenbound and not self.lenbound.generalization_of(other.lenbound):
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, extra_guards)
# the following conditions often peek into the runtime value that the
# box had when tracing. This value is only used as an educated guess.
# It is used here to choose between either emitting a guard and jumping
# to an existing compiled loop or retracing the loop. Both alternatives
# will always generate correct behaviour, but performance will differ.
elif self.level == LEVEL_NONNULL:
if other.level == LEVEL_UNKNOWN:
if box is not None and box.nonnull():
op = ResOperation(rop.GUARD_NONNULL, [box], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other not known to be nonnull")
elif other.level == LEVEL_NONNULL:
return
elif other.level == LEVEL_KNOWNCLASS:
return # implies nonnull
else:
assert other.level == LEVEL_CONSTANT
assert other.constbox
if not other.constbox.nonnull():
raise VirtualStatesCantMatch("constant is null")
return
elif self.level == LEVEL_KNOWNCLASS:
if other.level == LEVEL_UNKNOWN:
if (box and box.nonnull() and
self.known_class.same_constant(cpu.ts.cls_of_box(box))):
op = ResOperation(rop.GUARD_NONNULL_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other's class is unknown")
elif other.level == LEVEL_NONNULL:
if box and self.known_class.same_constant(cpu.ts.cls_of_box(box)):
op = ResOperation(rop.GUARD_CLASS, [box, self.known_class], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other's class is unknown")
elif other.level == LEVEL_KNOWNCLASS:
if self.known_class.same_constant(other.known_class):
return
raise VirtualStatesCantMatch("classes don't match")
else:
assert other.level == LEVEL_CONSTANT
if (other.constbox.nonnull() and
self.known_class.same_constant(cpu.ts.cls_of_box(other.constbox))):
return
else:
raise VirtualStatesCantMatch("classes don't match")
else:
assert self.level == LEVEL_CONSTANT
if other.level == LEVEL_CONSTANT:
if self.constbox.same_constant(other.constbox):
return
raise VirtualStatesCantMatch("different constants")
if box is not None and self.constbox.same_constant(box.constbox()):
op = ResOperation(rop.GUARD_VALUE, [box, self.constbox], None)
extra_guards.append(op)
return
else:
raise VirtualStatesCantMatch("other not constant")
assert 0, "unreachable"
def _generate_guards_intbounds(self, other, box, extra_guards):
if self.intbound.contains_bound(other.intbound):
return
if (box is not None and isinstance(box, BoxInt) and
self.intbound.contains(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)
return
raise VirtualStatesCantMatch("intbounds don't match")
def enum_forced_boxes(self, boxes, value, optimizer):
if self.level == LEVEL_CONSTANT:
return
assert 0 <= self.position_in_notvirtuals
if optimizer:
box = value.force_box(optimizer)
else:
if value.is_virtual():
raise BadVirtualState
box = value.get_key_box()
boxes[self.position_in_notvirtuals] = box
def _enum(self, virtual_state):
if self.level == LEVEL_CONSTANT:
return
self.position_in_notvirtuals = virtual_state.numnotvirtuals
virtual_state.numnotvirtuals += 1
def debug_print(self, indent, seen, bad, metainterp_sd=None):
mark = ''
if self in bad:
mark = '*'
if self.level == LEVEL_UNKNOWN:
l = "Unknown"
elif self.level == LEVEL_NONNULL:
l = "NonNull"
elif self.level == LEVEL_KNOWNCLASS:
addr = self.known_class.getaddr()
if metainterp_sd:
name = metainterp_sd.get_name_from_address(addr)
else:
name = "?"
l = "KnownClass(%s)" % name
else:
assert self.level == LEVEL_CONSTANT
const = self.constbox
if isinstance(const, ConstInt):
l = "ConstInt(%s)" % (const.value, )
elif isinstance(const, ConstPtr):
if const.value:
l = "ConstPtr"
else:
l = "ConstPtr(null)"
else:
assert isinstance(const, ConstFloat)
l = "ConstFloat(%s)" % const.getfloat()
lb = ''
if self.lenbound:
lb = ', ' + self.lenbound.bound.__repr__()
debug_print(indent + mark + 'NotVirtualInfo(%d' % self.position +
', ' + l + ', ' + self.intbound.__repr__() + lb + ')')
def test_make():
for _, _, b1 in some_bounds():
for _, _, b2 in some_bounds():
lt = IntUnbounded()
lt.make_lt(b1)
lt.make_lt(b2)
for n in nbr:
c = const(n)
if b1.known_le(c) or b2.known_le(c):
assert lt.known_lt(c)
else:
assert not lt.known_lt(c)
assert not lt.known_gt(c)
assert not lt.known_ge(c)
gt = IntUnbounded()
gt.make_gt(b1)
gt.make_gt(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c) or b2.known_ge(c):
assert gt.known_gt(c)
else:
assert not gt.known_gt(c)
assert not gt.known_lt(c)
assert not gt.known_le(c)
le = IntUnbounded()
le.make_le(b1)
le.make_le(b2)
for n in nbr:
c = const(n)
if b1.known_le(c) or b2.known_le(c):
assert le.known_le(c)
else:
assert not le.known_le(c)
assert not le.known_gt(c)
assert not le.known_ge(c)
ge = IntUnbounded()
ge.make_ge(b1)
ge.make_ge(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c) or b2.known_ge(c):
assert ge.known_ge(c)
else:
assert not ge.known_ge(c)
assert not ge.known_lt(c)
assert not ge.known_le(c)
gl = IntUnbounded()
gl.make_ge(b1)
gl.make_le(b2)
for n in nbr:
c = const(n)
if b1.known_ge(c):
assert gl.known_ge(c)
else:
assert not gl.known_ge(c)
assert not gl.known_gt(c)
if b2.known_le(c):
assert gl.known_le(c)
else:
assert not gl.known_le(c)
assert not gl.known_lt(c)