def test_virtuals_with_equal_fields(self): info1 = VirtualStateInfo(ConstInt(42), [1, 2]) value = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) info1.fieldstate = [knownclass_info, knownclass_info] vstate1 = VirtualState([info1]) assert vstate1.generalization_of(vstate1) info2 = VirtualStateInfo(ConstInt(42), [1, 2]) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) info2.fieldstate = [unknown_info1, unknown_info1] vstate2 = VirtualState([info2]) assert vstate2.generalization_of(vstate2) assert not vstate1.generalization_of(vstate2) assert vstate2.generalization_of(vstate1) info3 = VirtualStateInfo(ConstInt(42), [1, 2]) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) unknown_info2 = NotVirtualStateInfo(OptValue(self.nodebox)) info3.fieldstate = [unknown_info1, unknown_info2] vstate3 = VirtualState([info3]) assert vstate3.generalization_of(vstate2) assert vstate3.generalization_of(vstate1) assert not vstate2.generalization_of(vstate3) assert not vstate1.generalization_of(vstate3)
def test_NotVirtualStateInfo_generalization(self): def isgeneral(value1, value2): info1 = NotVirtualStateInfo(value1) info1.position = 0 info2 = NotVirtualStateInfo(value2) info2.position = 0 return info1.generalization_of(info2, {}, {}) assert isgeneral(OptValue(BoxInt()), OptValue(ConstInt(7))) assert not isgeneral(OptValue(ConstInt(7)), OptValue(BoxInt())) ptr = OptValue(BoxPtr()) nonnull = OptValue(BoxPtr()) nonnull.make_nonnull(0) knownclass = OptValue(BoxPtr()) knownclass.make_constant_class(ConstPtr(self.someptr1), 0) const = OptValue(BoxPtr) const.make_constant_class(ConstPtr(self.someptr1), 0) const.make_constant(ConstPtr(self.someptr1)) inorder = [ptr, nonnull, knownclass, const] for i in range(len(inorder)): for j in range(i, len(inorder)): assert isgeneral(inorder[i], inorder[j]) if i != j: assert not isgeneral(inorder[j], inorder[i]) value1 = OptValue(BoxInt()) value2 = OptValue(BoxInt()) value2.intbound.make_lt(IntBound(10, 10)) assert isgeneral(value1, value2) assert not isgeneral(value2, value1)
def test_known_class_value(self): value1 = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value1.make_constant_class(classbox, -1) box = self.nodebox guards = value1.make_guards(box) expected = """ [p0] guard_nonnull(p0) [] guard_class(p0, ConstClass(node_vtable)) [] """ self.compare(guards, expected, [box])
def test_known_class(self): value1 = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value1.make_constant_class(classbox, -1) info1 = NotVirtualStateInfo(value1) info2 = NotVirtualStateInfo(OptValue(self.nodebox)) expected = """ [p0] guard_nonnull(p0) [] guard_class(p0, ConstClass(node_vtable)) [] """ self.guards(info1, info2, self.nodebox, expected) py.test.raises(InvalidLoop, self.guards, info1, info2, BoxPtr(), expected)
def test_nonvirtual_is_not_array(self): info1 = VArrayStateInfo(42) value = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) info1.fieldstate = [knownclass_info, knownclass_info] vstate1 = VirtualState([info1]) assert vstate1.generalization_of(vstate1) info2 = NotVirtualStateInfo(value) vstate2 = VirtualState([info2]) assert vstate2.generalization_of(vstate2) assert not vstate2.generalization_of(vstate1) assert not vstate1.generalization_of(vstate2)
def test_virtuals_with_nonmatching_classes(self): info1 = VirtualStateInfo(ConstInt(42), [1, 2]) value = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) info1.fieldstate = [knownclass_info, knownclass_info] vstate1 = VirtualState([info1]) assert vstate1.generalization_of(vstate1) info2 = VirtualStateInfo(ConstInt(7), [1, 2]) value = OptValue(self.nodebox2) classbox = self.cpu.ts.cls_of_box(self.nodebox2) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) info2.fieldstate = [knownclass_info, knownclass_info] vstate2 = VirtualState([info2]) assert vstate2.generalization_of(vstate2) assert not vstate2.generalization_of(vstate1) assert not vstate1.generalization_of(vstate2)
def test_equal_inputargs(self): value = OptValue(self.nodebox) classbox = self.cpu.ts.cls_of_box(self.nodebox) value.make_constant_class(classbox, -1) knownclass_info = NotVirtualStateInfo(value) vstate1 = VirtualState([knownclass_info, knownclass_info]) assert vstate1.generalization_of(vstate1) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) vstate2 = VirtualState([unknown_info1, unknown_info1]) assert vstate2.generalization_of(vstate2) assert not vstate1.generalization_of(vstate2) assert vstate2.generalization_of(vstate1) unknown_info1 = NotVirtualStateInfo(OptValue(self.nodebox)) unknown_info2 = NotVirtualStateInfo(OptValue(self.nodebox)) vstate3 = VirtualState([unknown_info1, unknown_info2]) assert vstate3.generalization_of(vstate2) assert vstate3.generalization_of(vstate1) assert not vstate2.generalization_of(vstate3) assert not vstate1.generalization_of(vstate3) expected = """ [p0] guard_nonnull(p0) [] guard_class(p0, ConstClass(node_vtable)) [] """ guards = [] vstate1.generate_guards(vstate2, [self.nodebox, self.nodebox], self.cpu, guards) self.compare(guards, expected, [self.nodebox]) with py.test.raises(InvalidLoop): guards = [] vstate1.generate_guards(vstate3, [self.nodebox, self.nodebox], self.cpu, guards) with py.test.raises(InvalidLoop): guards = [] vstate2.generate_guards(vstate3, [self.nodebox, self.nodebox], self.cpu, guards)
def test_NotVirtualStateInfo_generalization(self): def isgeneral(value1, value2): info1 = NotVirtualStateInfo(value1) info1.position = 0 info2 = NotVirtualStateInfo(value2) info2.position = 0 return info1.generalization_of(info2, {}, {}) assert isgeneral(OptValue(BoxInt()), OptValue(ConstInt(7))) assert not isgeneral(OptValue(ConstInt(7)), OptValue(BoxInt())) ptr = OptValue(BoxPtr()) nonnull = OptValue(BoxPtr()) nonnull.make_nonnull(0) knownclass = OptValue(BoxPtr()) knownclass.make_constant_class(ConstPtr(self.someptr1), 0) const = OptValue(BoxPtr) const.make_constant_class(ConstPtr(self.someptr1), 0) const.make_constant(ConstPtr(self.someptr1)) inorder = [ptr, nonnull, knownclass, const] for i in range(len(inorder)): for j in range(i, len(inorder)): assert isgeneral(inorder[i], inorder[j]) if i != j: assert not isgeneral(inorder[j], inorder[i]) value1 = OptValue(BoxInt()) value2 = OptValue(BoxInt()) value2.intbound.make_lt(IntBound(10, 10)) assert isgeneral(value1, value2) assert not isgeneral(value2, value1) assert isgeneral(OptValue(ConstInt(7)), OptValue(ConstInt(7))) S = lltype.GcStruct('S') foo = lltype.malloc(S) fooref = lltype.cast_opaque_ptr(llmemory.GCREF, foo) assert isgeneral(OptValue(ConstPtr(fooref)), OptValue(ConstPtr(fooref)))
def test_known_class_generalization(self): knownclass1 = OptValue(BoxPtr()) knownclass1.make_constant_class(ConstPtr(self.someptr1), 0) info1 = NotVirtualStateInfo(knownclass1) info1.position = 0 knownclass2 = OptValue(BoxPtr()) knownclass2.make_constant_class(ConstPtr(self.someptr1), 0) info2 = NotVirtualStateInfo(knownclass2) info2.position = 0 assert info1.generalization_of(info2, {}, {}) assert info2.generalization_of(info1, {}, {}) knownclass3 = OptValue(BoxPtr()) knownclass3.make_constant_class(ConstPtr(self.someptr2), 0) info3 = NotVirtualStateInfo(knownclass3) info3.position = 0 assert not info1.generalization_of(info3, {}, {}) assert not info2.generalization_of(info3, {}, {}) assert not info3.generalization_of(info2, {}, {}) assert not info3.generalization_of(info1, {}, {})