def test3():
I1 = ila.Abstraction('a')
inp1 = I1.inp('inp', 1)
r1 = I1.reg('r1', 5)
I1.decode_exprs = [inp1 == 1, inp1 == 0]
uI1 = I1.add_microabstraction("mic", (r1 != 0) & (r1 < 2))
I1.set_next('r1', ila.ite(inp1 == 1, I1.const(1, 5), I1.const(0, 5)))
ur1 = uI1.reg('ur1', 5)
r1p = uI1.getreg('r1')
uI1.set_init('ur1', uI1.const(0, 5))
uI1.set_next('ur1', ur1 + 1)
uI1.set_next('r1', ila.ite(ur1 > 5, ur1, r1p))
#######################
I2 = ila.Abstraction('b')
inp2 = I2.inp('inp', 1)
r2 = I2.reg('r1', 5)
uI2 = I2.add_microabstraction("mic", (r2 != 0) & (r2 < 2))
I2.set_next('r1', ila.ite(inp2 == 1, I2.const(1, 5), I2.const(0, 5)))
I2.decode_exprs = [inp2 == 1, inp2 == 0]
ur2 = uI2.reg('ur1', 5)
r2p = uI2.getreg('r1')
uI2.set_init('ur1', uI1.const(0, 5))
uI2.set_next('ur1', ur2 + 3)
uI2.set_next('r1', ila.ite(ur2 > 5, ur2, r2p))
print 'simple signature test:'
print ila.eqcheckSimple(I1, I2)
print 'full test'
u1 = I1.newUnroller(uI1, True)
u1.addAssumption(inp1 == 1)
u1.unrollTo(20)
u1.checkAssertion(~(uI1.fetch_valid))
u1.checkAssertion(r1 == 6)
u2 = I2.newUnroller(uI2, True)
u2.addAssumption(inp2 == 1)
u2.unrollTo(20)
u2.checkAssertion(~(uI2.fetch_valid))
u2.checkAssertion(r2 == 6)
print ila.eqcheck(u1, u2, 'r1', 'r1')
def Exit(self, bound1, bound2, a1, a2, c1, c2, CrossAssumpt,
CrossConclusion):
## For abs 1
checkRsFlag = True
u1 = self.a1.newUnroller(self.ua1, setInitCondition=False)
print 'Assuming:'
invStr = ' AND '.join(['$%d' % idx for idx in range(len(a1))] + ['$$'])
for idx, inv in enumerate(a1):
print '$%d = %s' % (idx, inv)
for inv in a1:
u1.addAssumption(inv)
print 'Unrolling...'
u1.unrollTo(bound1)
u1.addAssumption(~self.ua1.fetch_valid)
print 'And also micro-program terminates: ', ~self.ua1.fetch_valid
for idx, cond in enumerate(c1):
print invStr + ' -> ' + str(cond)
checkRsFlag = checkRsFlag and u1.checkAssertion(cond)
## For abs 2
u2 = self.a2.newUnroller(self.ua2, setInitCondition=False)
print 'Assuming:'
invStr = ' AND '.join(['$%d' % idx for idx in range(len(a2))] + ['$$'])
for idx, inv in enumerate(a2):
print '$%d = %s' % (idx, inv)
for inv in a2:
u2.addAssumption(inv)
u2.unrollTo(bound2)
u2.addAssumption(~self.ua2.fetch_valid)
print 'And also: micro-prog ends $$: ', ~self.ua2.fetch_valid
for idx, cond in enumerate(c2):
print invStr + ' -> ' + str(cond)
checkRsFlag = checkRsFlag and u2.checkAssertion(cond)
## Cross
CrossAssumptList = []
for n1, n2 in CrossAssumpt:
CrossAssumptList.append((1, n1, n2))
for n1, n2 in CrossConclusion:
ila.enablelog("Unroller")
ila.setloglevel(3, "info.txt")
if ila.eqcheck(u1, u2, n1, n2,
assumption=CrossAssumptList) == False:
print 'left.{n1} = right.{n2} --/--> left.{n1} = right.{n2}'.format(
n1=n1, n2=n2)
checkRsFlag = False
else:
print 'left.{n1} = right.{n2} ==>> left.{n1} = right.{n2}, is valid'.format(
n1=n1, n2=n2)
return checkRsFlag
def test4():
I1 = ila.Abstraction('a')
inp1 = I1.inp('inp', 1)
r1 = I1.reg('r1', 5)
r1a = I1.reg('ra', 5)
I1.decode_exprs = [inp1 == 1, inp1 == 0]
uI1 = I1.add_microabstraction("mic", (r1 != 0))
I1.set_next('r1', ila.ite(inp1 == 1, I1.const(1, 5), I1.const(0, 5)))
I1.set_next('ra', r1a)
ur1 = uI1.reg('ur1', 5)
r1p = uI1.getreg('r1')
uI1.set_init('ur1', uI1.const(0, 5))
uI1.set_next('ur1', ur1 + 1)
ura1 = uI1.getreg('ra')
uI1.set_next('ra', ura1 - 1)
uI1.set_next('r1', ila.ite(ura1 == 1, I1.const(0, 5), I1.const(1, 5)))
#######################
I2 = ila.Abstraction('b')
inp2 = I2.inp('inp', 1)
r2 = I2.reg('r1', 5)
r2a = I2.reg('ra', 5)
I2.decode_exprs = [inp2 == 1, inp2 == 0]
uI2 = I2.add_microabstraction("mic", (r2 != 0))
I2.set_next('r1', ila.ite(inp2 == 1, I2.const(1, 5), I2.const(0, 5)))
I2.set_next('ra', r2a)
ur2 = uI2.reg('ur1', 5)
r2p = uI2.getreg('r1')
uI2.set_init('ur1', uI2.const(0, 5))
uI2.set_next('ur1', ur2 + 1)
ura2 = uI2.getreg('ra')
uI2.set_next('ra', uI2.getreg('ra') - 1)
uI2.set_next('r1', ila.ite(ura2 == 1, I2.const(0, 5), I2.const(1, 5)))
print 'simple signature test:'
print ila.eqcheckSimple(I1, I2)
print 'full test'
u1 = I1.newUnroller(uI1, False)
u1.unrollTo(4)
u2 = I2.newUnroller(uI2, False)
u2.unrollTo(4)
inductiveAssumpt = [(1, "r1", "r1"), (1, "ra", "ra"), (1, "ur1", "ur1")]
print ila.eqcheck(u1, u2, "r1", "r1", inductiveAssumpt)
print ila.eqcheck(u1, u2, "ra", "ra", inductiveAssumpt)
print ila.eqcheck(u1, u2, "ur1", "ur1", inductiveAssumpt)
def InductiveStep(self, bound1, bound2, inv1, inv2, invCross):
checkRsFlag = True
## For abs 1
u1 = self.a1.newUnroller(self.ua1, setInitCondition=False)
print 'Checking invariants:'
invStr = ' AND '.join(['$%d' % idx for idx in range(len(inv1))])
for idx, inv in enumerate(inv1):
print '$%d = %s' % (idx, inv)
for inv in inv1:
u1.addAssumption(inv)
print 'Unrolling...'
u1.unrollTo(bound1)
u1.addAssumption(self.ua1.fetch_valid)
for idx, inv in enumerate(inv1):
print 'Checking', invStr + ' -> ' + '$%d' % (idx), '...'
checkRsFlag = checkRsFlag and u1.checkAssertion(inv)
## For abs 2
print 'Checking invariants:'
u2 = self.a2.newUnroller(self.ua2, setInitCondition=False)
invStr = ' AND '.join(['$%d' % idx for idx in range(len(inv2))])
for idx, inv in enumerate(inv2):
print '$%d = %s' % (idx, inv)
for inv in inv2:
u2.addAssumption(inv)
print 'Unrolling...'
u2.unrollTo(bound2)
u2.addAssumption(self.ua2.fetch_valid)
for idx, inv in enumerate(inv2):
print 'Checking', invStr + ' -> ' + '$%d' % (idx), '...'
if u2.checkAssertion(inv) == False:
print 'Fail!'
return False
## Cross
CrossAssumpt = []
for n1, n2 in invCross:
CrossAssumpt.append((1, n1, n2))
for n1, n2 in invCross:
if ila.eqcheck(u1, u2, n1, n2, assumption=CrossAssumpt) == False:
print 'left.{n1} = right.{n2} --/--> left.{n1} = right.{n2}'.format(
n1=n1, n2=n2)
return False
return checkRsFlag
def BMC(self, bound1, bound2, decode1, decode2, conclusion1, conclusion2,
conclusionCross):
u1 = self.a1.newUnroller(self.ua1, setInitCondition=True)
u1.addAssumption(decode1)
u1.unrollTo(bound1)
for c in conclusion1:
print 'Checking base assertion:', c
u1.checkAssertion(c)
u2 = self.a2.newUnroller(self.ua2, setInitCondition=True)
u2.addAssumption(decode2)
u2.unrollTo(bound2)
for c in conclusion2:
print 'Checking base assertion:', c
u2.checkAssertion(c)
for n1, n2 in conclusionCross:
print 'Checking left.%s = right.%s' % (n1, n2)
if (ila.eqcheck(u1, u2, n1, n2)):
print 'It is valid.'
