//////////////////////////////////////////////////////////////////////////// public Statement propagate(EqualityAnalyzer prestate, StatementId si) { // Console.WriteLine("EqualityAnalyzer.propagate({0})", si.ToString()); statementId = si; Debug.Assert(!ReferenceEquals(prestate, this)); database = prestate.database; //alias Debug.Assert(database != null); Debug.Assert(procedure != null); database.statementId = si; //for reporting firstOccurenceVariables = new HashSet <string>(); Statement result; if (pathCondition.isFalse || database.additionalConditions.isFalse) { result = null; } else { result = si.statement.visit(this); } // Console.WriteLine("/EqualityAnalyzer.propagate({0})", si.ToString()); return(result); }
public void CreateStatement_ExpectValid() { //Arrange string localStatementIdString = "STMT01"; StatementId localStatementId = new StatementId(localStatementIdString); SpecificFieldsFactory localfactory = new SpecificFieldsFactory(); string[] listspecificfields = { "Credit Card", "12" }; StatementType localStatementType = new StatementType(localfactory, "CreditCardProvider", listspecificfields); StatementSpecificFields localspecificfields = localStatementType.getSpecificFields(); int localstatementAccountnumber = 1234567; string localstatementAccountholdername = "Bruce"; DateTime localstatementDate = DateTime.Now; StatementCommonFields localStatementCommonFields = new StatementCommonFields(localstatementAccountnumber, localstatementAccountholdername, localstatementDate); APSUser localAPSUser = new APSUser(new APSUserId("1"), "testusername", "testpassword"); BillingAccount localBillingAccount = new BillingAccount(new BillingAccountId("1"), new BillingCompanyId("1"), "testusername", "testpassword", localAPSUser); //Act Statement localStatement = new Statement(localStatementId, localStatementCommonFields, localStatementType, localspecificfields, localAPSUser, localBillingAccount); //Assert Assert.AreEqual(localStatement.StatementId, localStatementId); Assert.AreEqual(localStatement.StatementCommonFields, localStatementCommonFields); Assert.AreEqual(localStatement.StatementType, localStatementType); Assert.AreEqual(localStatement.StatementSpecificFields, localspecificfields); Assert.AreEqual(localStatement.APSUser, localAPSUser); Assert.AreEqual(localStatement.BillingAccount, localBillingAccount); }
//////////////////////////////////////////////////////////////////////////////////////////////// private static IEnumerable <StatementId> getRelevant(CFG <BasicBlock, BasicEdge> cfg, StatementId target) { var result = new Dictionary <string, StatementId>(); var toMark = new Queue <StatementId>(); foreach (var p in target.predecessors) { toMark.Enqueue(p.Item2); } while (toMark.Count > 0) { StatementId si = toMark.Dequeue(); if (!result.ContainsKey(si.ToString())) { if (si.statement is PredicateStatement) { result.Add(si.ToString(), si); } foreach (var p in si.predecessors) { toMark.Enqueue(p.Item2); } } } return(result.Values); }
public Statement propagate(SubexpressionCounter prestate, StatementId si) { currentStatement = si; if (si.successors.Count == 1 && si.successors.First().Item2.predecessors.Count == 1) { subexpressionCounts = prestate.subexpressionCounts; } else { subexpressionCounts = new Dictionary <string, SubExpression>(); foreach (var sec in prestate.subexpressionCounts) { subexpressionCounts.Add(sec.Key, new SubExpression(sec.Value)); // Debug.Assert(sec.Key == subexpressionCounts[sec.Key].fae.ToString()); } } context = new Stack <string>(); context.Push(""); Statement ns = si.statement.visit(this); Debug.Assert(ns != null); return(ns); }
public void join(ICollection <Tuple <BasicEdge.Guard, SubexpressionCounter> > predecessors, StatementId si) { subexpressionCounts = new Dictionary <string, SubExpression>(); currentStatement = si; // HashSet<string> ses = new HashSet<string>(); if (predecessors.Count == 1 && predecessors.First().Item2.currentStatement.predecessors.Count == 1) { subexpressionCounts = predecessors.First().Item2.subexpressionCounts; } else { foreach (var p in predecessors) { foreach (var v in p.Item2.subexpressionCounts) { SubExpression se = null; if (!subexpressionCounts.TryGetValue(v.Key, out se)) { subexpressionCounts.Add(v.Key, new SubExpression(v.Value)); // Debug.Assert(v.Key == subexpressionCounts[v.Key].fae.ToString()); } else { se.merge(currentStatement, v.Value); // Debug.Assert(v.Key == subexpressionCounts[v.Key].fae.ToString()); } } } } // currentStatement = null; }
public override int GetHashCode() { unchecked { int hashCode = (StatementId != null ? StatementId.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Name != null ? Name.GetHashCode() : 0); hashCode = (hashCode * 397) ^ (Variable != null ? Variable.GetHashCode() : 0); return(hashCode); } }
public void CreateStatementId_ExpectValid() { //Arrange string localStatementIdString = "STMT01"; //Act StatementId localStatementId = new StatementId(localStatementIdString); //Assert Assert.AreEqual(localStatementId.StatementIdString, localStatementIdString); }
public Statement propagate(InitializedVariables prestate, StatementId si) { // Console.WriteLine("propagate({0} : {1})", si.ToString(), si.statement.ToString()); firstOccurence = new Dictionary <string, Dictionary <string, Tuple <PropositionalFormula, StatementId> > >( prestate.firstOccurence); currentStatement = si; si.statement.visit(this); currentStatement = null; return(si.statement); }
public Statement propagate(DeadCodeEliminator prestate, StatementId si) { liveVariables = new HashSet <string>(); foreach (var v in prestate.liveVariables) { liveVariables.Add(v); } Statement ns = si.statement.visit(this); return(ns); }
public void collect(StatementId si) { // currentStatement = si; if (si.statement is PredicateStatement) { (si.statement as PredicateStatement).expression.visit(this); } else { Debug.Assert(si.statement is ControlStatement); } }
public SubExpression(SubExpression other) { Debug.Assert(other != null); expression = other.expression; contexts = new Dictionary <string, HashSet <StatementId> >(); foreach (var c in other.contexts) { contexts.Add(c.Key, new HashSet <StatementId>(c.Value)); } definition = other.definition; Debug.Assert(definition != null); }
//////////////////////////////////////////////////////////////////////////// public void join(ICollection <Tuple <BasicEdge.Guard, EqualityAnalyzer> > predecessors, StatementId si) { /* Console.WriteLine("EqualityAnalyzer.join({0})", si.ToString()); * foreach (var p in predecessors) * Console.WriteLine("\t{0} : {1}", p.Item2.statementId.ToString(), p.Item2.pathCondition.ToString()); */ statementId = si; Debug.Assert(predecessors.Count > 0); Procedure procedure = predecessors.First().Item2.procedure; Debug.Assert(procedure != null); if (predecessors.Count == 1 && si.predecessors.First().Item2.successors.Count == 1) { Debug.Assert(((predecessors.First().Item1.expression as LiteralExpression).value as BooleanValue).value); EqualityAnalyzer onlyPred = predecessors.First().Item2; database = onlyPred.database; database.statementId = si; } else { var predConditions = new List <PropositionalFormula>(); foreach (var p in predecessors) { if (!p.Item2.pathCondition.isFalse) { PropositionalFormula c = p.Item2.database.toDNF(p.Item1); PropositionalFormula a = p.Item2.pathCondition & c; predConditions.Add(a); } } // Console.WriteLine("\tEqualityAnalyzer.join({0}).pathCondition", si.ToString()); PropositionalFormula pathCondition = PropositionalFormula.or(predConditions); var preds = new List <EqualityDatabase>(); foreach (var p in predecessors) { preds.Add(p.Item2.database); } // Console.WriteLine("\tEqualityAnalyzer.join({0}).database", si.ToString()); database = new EqualityDatabase(si, procedure, pathCondition, preds); if (pathCondition.isFalse) { Console.Error.WriteLine("[{0}] Warning - path condition ({1}) is false", si.ToString(), pathCondition.ToString(conditionVariableNames)); } } // Console.WriteLine("/EqualityAnalyzer.join({0})", si.ToString()); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////// private void removeTypeQuantification(StatementId si) { if (!(si.statement is PredicateStatement)) { return; } var ps = si.statement as PredicateStatement; currentSID = si; ps.expression = removeTypeQuantification(ps.expression); currentSID = null; }
internal void add(StatementId currentStatement, string context) { Debug.Assert(currentStatement != null); HashSet <StatementId> c = null; if (!contexts.TryGetValue(context, out c)) { c = new HashSet <StatementId>(); contexts.Add(context, c); } c.Add(currentStatement); definition = currentStatement; Debug.Assert(definition != null); }
private void correctControlStatement(StatementId si, ControlStatement newS) { IEnumerable <Tuple <BasicEdge.Guard, StatementId> > os = getSuccessors(si); IEnumerable <Tuple <BasicEdge.Guard, StatementId> > ns = getSuccessors(si, newS); var dif = new HashSet <BasicBlock>(from s in os select s.Item2.basicBlock); var nss = new HashSet <BasicBlock>(from s in ns select s.Item2.basicBlock); Debug.Assert(nss.IsSubsetOf(dif)); dif.ExceptWith(nss); if (dif.Count == 0) { return; } var q = new Queue <BasicBlock>(dif); var numReaches = new Dictionary <BasicBlock, int>(); foreach (var d in dif) { numReaches.Add(d, 1); } while (q.Count > 0) { BasicBlock bb = q.Dequeue(); Debug.Assert(bb.statements.First().preState.evaluatorInformation.numIncompletePredecessors > 0); bb.statements.First().preState.evaluatorInformation.numIncompletePredecessors--; if (bb.statements.First().preState.evaluatorInformation.numIncompletePredecessors == 0) { if (bb.predecessors.Count - numReaches[bb] == 0) //will be deleted { foreach (var nbbe in bb.successors) { BasicBlock nbb = nbbe.target; q.Enqueue(nbb); if (!numReaches.ContainsKey(nbb)) { numReaches.Add(nbb, 1); } else { numReaches[nbb]++; } } } else { ready.Enqueue(bb.statements[0].statementId); } } } }
///////////////////////////////////////////////////////// private void propagateAll(StatementId start) { Debug.Assert(start != null); ready = new Queue <StatementId>(); ready.Enqueue(start); while (ready.Count > 0) { StatementId s = ready.Dequeue(); propagate(s); } }
public override int GetHashCode() { int hashcode = 157; unchecked { hashcode = (hashcode * 397) + SessionId.GetHashCode(); hashcode = (hashcode * 397) + Statement.GetHashCode(); hashcode = (hashcode * 397) + StatementId.GetHashCode(); if (__isset.fetchSize) { hashcode = (hashcode * 397) + FetchSize.GetHashCode(); } } return(hashcode); }
public SubExpression(Expression e, StatementId id, string context) { Debug.Assert(e != null); Debug.Assert(id != null); Debug.Assert(context != null); expression = e; contexts = new Dictionary <string, HashSet <StatementId> >(); var idSet = new HashSet <StatementId>(); idSet.Add(id); contexts.Add(context, idSet); definition = id; Debug.Assert(definition != null); }
public Assignment(StatementId statementId) { this.statementId = statementId; Debug.Assert(statementId.statement is Assume); Debug.Assert((statementId.statement as Assume).expression is FAE); Debug.Assert( BFunction.isEquality( ((statementId.statement as Assume).expression as FAE).function)); Debug.Assert( (((statementId.statement as Assume).expression as FAE).arguments[0] is ProgramVariableExpression)); variable = (((statementId.statement as Assume).expression as FAE).arguments[0] as ProgramVariableExpression).programVariable; value = ((statementId.statement as Assume).expression as FAE).arguments[1]; basicBlock = statementId.basicBlock; }
//////////////////////////////////////////////////////////////////////////// public void initializeStart(StatementId si) { // Console.WriteLine("EqualityAnalyzer.initializeStart({0})", si.ToString()); Debug.Assert(procedure != null); database = new EqualityDatabase(si, procedure, new PropositionalFormula(true)); int numConstants = 0; // var constants = (from c in procedure.parentScope.locals where c is Constant select c as Constant).ToArray(); var constantMap = new Dictionary <string, List <BasicProgramVariableExpression> >(); // Console.Write("\tCollecting unique constants : "); foreach (var d in procedure.parentScope.locals) { var c = d as Constant; if (c != null && c.isUnique) { numConstants++; List <BasicProgramVariableExpression> cme; if (!constantMap.TryGetValue(c.type.ToStringN(), out cme)) { constantMap[c.type.ToStringN()] = cme = new List <BasicProgramVariableExpression>(); } cme.Add(new BasicProgramVariableExpression(c)); } } // Console.WriteLine("{0}", numConstants); int cc = 0; foreach (var l in constantMap) { // Console.WriteLine("\t\tAdding inequalities for {0} : {1}", l.Key.ToString(), l.Value.Count); for (int i = 0; i < l.Value.Count; i++) { for (int j = i + 1; j < l.Value.Count; j++) { // Console.WriteLine("\t\t\t{0}: {1} != {2}", cc, l.Value[i].ToString(), l.Value[j].ToString()); database.addInequality(l.Value[i], l.Value[j]); cc++; } } } statementId = si; // Console.WriteLine("/EqualityAnalyzer.initializeStart({0})", si.ToString()); }
//////////////////////////////////////////////////////////////////////////////////////////////// private static void addAssumptions(BasicBlock block, PropositionalFormula pathCondition, PropositionalFormula notPathCondition, StatementId si) { Debug.Assert((pathCondition & notPathCondition).isFalse); Debug.Assert((pathCondition | notPathCondition).isTrue); PropositionalFormula statementPathCondition = si.basicBlock.getPreState(0).equalityAnalyzer.pathCondition; if ((statementPathCondition & pathCondition).isFalse) { // Console.WriteLine("Eliminating {0} & {1}", statementPathCondition.ToString(), pathCondition.ToString()); return; } if (!(statementPathCondition.isTrue)) { PropositionalFormula simplifiedPathCondition = statementPathCondition | notPathCondition; if (simplifiedPathCondition.size() < statementPathCondition.size()) { statementPathCondition = simplifiedPathCondition; } } var q = new Queue <Expression>(); q.Enqueue(((PredicateStatement)si.statement).expression); while (q.Count > 0) { Expression e = q.Dequeue(); var fae = e as FAE; if (fae != null && BFunction.isConjunction(fae.function)) { q.Enqueue(fae.arguments[0]); q.Enqueue(fae.arguments[1]); } else { block.appendStatement(new Assume(makeFlatExpression(si.basicBlock, statementPathCondition, e))); } } }
public void propagate(DeadCodeEliminator prestate, StatementId s) { this.liveVariables = new HashSet <string>(); foreach (var v in prestate.liveVariables) { liveVariables.Add(v); } procedure = prestate.procedure; if (!s.deleted) { var ns = s.statement.visit(this); if (ns == null) { s.delete(); } else { s.statement = ns; } } }
// private HashSet<string> visited; /* ///////////////////////////////////////////////////// * private void spill(BasicBlock si, BasicEdge e, int l) * { * for (int i = 0; i < l; i++) * Console.Write("\t"); * Console.Write(si.label); * if (e!=null && e.isBackEdge()) * Console.Write(" - b"); * Console.WriteLine(); * * visited.Add(si.label); * foreach (var p in si.predecessors) * if (!visited.Contains(p.source.label)) * spill(p.source, p, l + 1); * } */ ///////////////////////////////////////////////////// public void propagate(MapCollector prestate, StatementId s) { /* if (prestate.procedure == null) * { * visited = new HashSet<string>(); * spill(s.basicBlock, null, 0); * } * else * { * Console.WriteLine("propagate: {0}", s.ToString()); * foreach (var p in s.predecessors) * Console.WriteLine("\t{0}", p.Item2.ToString()); * } */ Debug.Assert(!ReferenceEquals(this, prestate)); Debug.Assert(!ReferenceEquals(this.maps, prestate.maps)); Debug.Assert(prestate.procedure != null); this.procedure = prestate.procedure; maps.procedure = procedure; maps.merge(prestate.maps); s.statement.visit(this); }
internal void merge(StatementId currentStatement, SubExpression other) { Debug.Assert(currentStatement != null); Debug.Assert(expression.ToString() == other.expression.ToString()); foreach (var c in other.contexts) { HashSet <StatementId> context = null; if (!contexts.TryGetValue(c.Key, out context)) { context = new HashSet <StatementId>(); contexts.Add(c.Key, context); } int oldSize = context.Count; context.UnionWith(c.Value); if (oldSize != context.Count || c.Value.Count != context.Count || !ReferenceEquals(other.definition, definition)) { definition = currentStatement; } } Debug.Assert(definition != null); }
private Assignment getAssignment(ProgramVariable v, StatementId statementId) { StatementId si = statementId; var assume = statementId.statement as Assume; if (assume == null) { si = null; } else { var fae = assume.expression as FAE; if (fae == null || !BFunction.isEquality(fae.function)) { si = null; } else { var dest = fae.arguments[0] as ProgramVariableExpression; if (dest == null || (dest.programVariable != v)) { si = null; } } } if (si == null) { return(new Assignment(statementId.basicBlock, v)); } else { return(new Assignment(si)); } }
public async Task<Statement> GetSpecificStatement(StatementId StatementId) { //Gets a specific statement //code logic return null for now return null; }
///////////////////////////////////////////////////////// protected override IEnumerable <Tuple <BasicEdge.Guard, StatementId> > getSuccessors(StatementId si, ControlStatement cs) { return(si.predecessors); }
public void initializeStart(StatementId si) { subexpressionCounts = new Dictionary <string, SubExpression>(); }
public bool isEqual(StatementId other) { return(ReferenceEquals((other as StatementIdImp).statementInfo, statementInfo)); }
public void join(ICollection <Tuple <BasicEdge.Guard, DeadCodeEliminator> > predecessors, StatementId si) { liveVariables = new HashSet <string>(); foreach (var p in predecessors) { foreach (var v in p.Item2.liveVariables) { liveVariables.Add(v); } } }
public void initializeStart(StatementId si) { liveVariables = new HashSet <string>(); }