const V3NetId V3NtkElaborate::elaborateLTLFormula(V3LTLFormula* const ltlFormula, const uint32_t& rootIndex) { assert (ltlFormula); assert (ltlFormula->isValid(rootIndex)); assert (isMutable()); assert (_ntk); assert (this == ltlFormula->getHandler()); if (ltlFormula->isLeaf(rootIndex)) { V3Formula* const formula = ltlFormula->getFormula(rootIndex); assert (formula); assert (ltlFormula->getHandler() == formula->getHandler()); return dynamic_cast<V3BvNtk*>(ltlFormula->getHandler()->getNtk()) ? elaborateBvFormula(formula, formula->getRoot(), _netHash) : elaborateAigFormula(formula, formula->getRoot(), _netHash); } switch (ltlFormula->getOpType(rootIndex)) { case V3_LTL_T_G : // Currently Support Single Layered LTL assert (1 == ltlFormula->getBranchSize(rootIndex)); assert (ltlFormula->isLeaf(ltlFormula->getBranchIndex(rootIndex, 0))); return elaborateLTLFormula(ltlFormula, ltlFormula->getBranchIndex(rootIndex, 0)); case V3_LTL_T_F : // Currently Support Single Layered LTL assert (1 == ltlFormula->getBranchSize(rootIndex)); assert (ltlFormula->isLeaf(ltlFormula->getBranchIndex(rootIndex, 0))); return elaborateLTLFormula(ltlFormula, ltlFormula->getBranchIndex(rootIndex, 0)); default : Msg(MSG_WAR) << "Verification of General LTL Formula Has NOT Been Supported Yet !!" << endl; } return V3NetUD; }
// Elaboration Functions const uint32_t V3NtkElaborate::elaborateProperty(V3Property* const p, V3NetVec& constrList, const bool& l2s) { assert (p); V3LTLFormula* const ltlFormula = p->getLTLFormula(); assert (ltlFormula); const uint32_t pIndex = elaborateLTLFormula(ltlFormula, l2s); V3NetVec invList; invList.clear(); constrList.clear(); // Elaborate Invariants for (uint32_t i = 0; i < p->getInvariantSize(); ++i) { const V3NetId id = elaborateInvariants(p->getInvariant(i)); if (V3NetUD != id) invList.push_back(id); } // Elaborate Invariant Constraints V3NetVec invConstrList; for (uint32_t i = 0; i < p->getInvConstrSize(); ++i) { invConstrList.clear(); elaborateConstraints(p->getInvConstr(i), invConstrList); if (invConstrList.size()) constrList.push_back(combineConstraints(invConstrList)); } // Elaborate Fairness Constraints if (l2s && p->getFairConstrSize()) { V3NetVec fairList; for (uint32_t i = 0; i < p->getFairConstrSize(); ++i) { fairList.clear(); elaborateFairnessL2S(p->getFairConstr(i), fairList); if (!fairList.size()) continue; fairList.push_back(_ntk->getOutput(pIndex)); _ntk->replaceOutput(pIndex, combineConstraints(fairList)); } } // Combine Invariants to Property Outpins if (invList.size()) combineInvariantToOutputs(pIndex, invList); assert ((1 + pIndex) == _ntk->getOutputSize()); return pIndex; }
// Elaboration Functions const uint32_t V3NtkElaborate::elaborateProperty(V3Property* const p, const bool& l2s) { assert (p); V3LTLFormula* const ltlFormula = p->getLTLFormula(); assert (ltlFormula); const uint32_t pIndex = elaborateLTLFormula(ltlFormula, l2s); assert ((1 + pIndex) == _ntk->getOutputSize()); return pIndex; }
const uint32_t V3NtkElaborate::elaborateLTLFormula(V3LTLFormula* const ltlFormula, const bool& l2s) { // Make Sure Mapping Tables are Maintained, or NO properties can be proliferated if (!isMutable() || (_ntk && (!_p2cMap.size()))) return V3NtkUD; // Elaborate LTL Formula into Ntk assert (ltlFormula); assert (_handler == ltlFormula->getHandler()); elaborate(ltlFormula); // Create Formula for this Ntk, and Perform LTL Formula Rewriting if Enabled V3LTLFormula* const formula = ltlFormula->createSuccessor(this); // Currently Support ONLY AG(p) and AF(p) const uint32_t rootIndex = formula->getRoot(); assert (!formula->isLeaf(rootIndex)); V3NetId id = elaborateLTLFormula(formula, rootIndex); if (V3NetUD == id) return V3NtkUD; id = (l2s && V3_LTL_T_F == formula->getOpType(rootIndex)) ? elaborateL2S(id) : ~id; // Record LTL Formula and Set to Output _pOutput.push_back(formula); _ntk->createOutput(id); assert (_pOutput.size() == _ntk->getOutputSize()); return _ntk->getOutputSize() - 1; }