private ICFG contractFreeCFG; // computed on demand protected BasicMethodDriver( Method method, IBasicAnalysisDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, LogOptions> parent ) { Contract.Requires(parent != null); this.method = method; this.parent = parent; var rawCFG = this.parent.MethodCache.GetCFG(method); // Here we build our stack of adapters. // // StackDepth (Temp decoder for APC) // CFG (Unit decoder for APC, including Assume) // cciilprovider (Unit decoder for PC) // rawLayer = CodeLayerFactory.Create( rawCFG.GetDecoder(parent.MetaDataDecoder), parent.MetaDataDecoder, parent.ContractDecoder, (unit) => "", (unit) => "", (v1, v2) => false); if (PrintIL) { Console.WriteLine("-----------------APC based CFG---------------------"); this.RawLayer.Decoder.AssumeNotNull().Context.MethodContext.CFG.Print(Console.Out, this.RawLayer.Printer, null, null, null); } stackLayer = CodeLayerFactory.Create( StackDepthFactory.Create( this.RawLayer.Decoder, this.RawLayer.MetaDataDecoder), this.RawLayer.MetaDataDecoder, this.RawLayer.ContractDecoder, delegate(int i) { return("s" + i.ToString()); }, delegate(int i) { return("s" + i.ToString()); }, (s1, s2) => false ); if (PrintIL) { Console.WriteLine("-----------------Stack based CFG---------------------"); this.StackLayer.Decoder.AssumeNotNull().Context.MethodContext.CFG.Print(Console.Out, StackLayer.Printer, null, null, null); } // set static wp tracing option WeakestPreconditionProver.Trace = parent.Options.TraceWP; WeakestPreconditionProver.EmitSMT2Formula = parent.Options.EmitSMT2Formula; }
public void RunHeapAndExpressionAnalyses(DFAController controller) { if (optimisticHeapAnalysis != null) { return; } optimisticHeapAnalysis = new OptimisticHeapAnalyzer <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly>(this.StackLayer, this.Options.TraceEGraph); optimisticHeapAnalysis.TurnArgumentExceptionThrowsIntoAssertFalse = this.Options.TurnArgumentExceptionThrowsIntoAssertFalse; optimisticHeapAnalysis.IgnoreExplicitAssumptions = this.Options.IgnoreExplicitAssumptions; optimisticHeapAnalysis.TraceAssumptions = this.Options.TraceAssumptions; var heapsolver = this.StackLayer.CreateForward(optimisticHeapAnalysis, new DFAOptions { Trace = this.Options.TraceHeapAnalysis }, controller); heapsolver(optimisticHeapAnalysis.InitialValue()); this.ValueLayer = CodeLayerFactory.Create(optimisticHeapAnalysis.GetDecoder(this.StackLayer.Decoder), this.StackLayer.MetaDataDecoder, this.StackLayer.ContractDecoder, delegate(SymbolicValue source) { return(source.ToString()); }, delegate(SymbolicValue dest) { return(dest.ToString()); }, (v1, v2) => v1.symbol.GlobalId > v2.symbol.GlobalId ); if (this.PrintIL) { Console.WriteLine("-----------------Value based CFG---------------------"); this.ValueLayer.Decoder.Context.MethodContext.CFG.Print(Console.Out, this.ValueLayer.Printer, optimisticHeapAnalysis.GetEdgePrinter(), (block) => optimisticHeapAnalysis.GetContexts(block), null); } var exprAnalysis = new ExpressionAnalysis <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, SymbolicValue, IValueContext <Local, Parameter, Method, Field, Type, SymbolicValue>, EdgeData>( this.ValueLayer, this.Options, optimisticHeapAnalysis.IsUnreachable ); var exprsolver = this.ValueLayer.CreateForward(exprAnalysis.CreateExpressionAnalyzer(), new DFAOptions { Trace = this.Options.TraceExpressionAnalysis }, controller); exprsolver(exprAnalysis.InitialValue(SymbolicValue.GetUniqueKey)); var exprDecoder = exprAnalysis.GetDecoder(this.ValueLayer.Decoder); expr2String = ExprPrinter.Printer(exprDecoder.Context, this); this.ExpressionLayer = CodeLayerFactory.Create( exprDecoder, this.ValueLayer.MetaDataDecoder, this.ValueLayer.ContractDecoder, expr2String, this.ValueLayer.VariableToString, (v1, v2) => v1.symbol.GlobalId > v2.symbol.GlobalId ); if (this.PrintIL) { Console.WriteLine("-----------------Expression based CFG---------------------"); this.ExpressionLayer.Decoder.Context.MethodContext.CFG.Print(Console.Out, this.ExpressionLayer.Printer, exprAnalysis.GetBlockPrinter(expr2String), (block) => exprAnalysis.GetContexts(block), null); } this.HybridLayer = CodeLayerFactory.Create( this.ValueLayer.Decoder, this.ValueLayer.MetaDataDecoder, this.ValueLayer.ContractDecoder, this.ValueLayer.ExpressionToString, this.ValueLayer.VariableToString, this.ExpressionLayer.Printer, this.ExpressionLayer.NewerThan ); if (Options.TraceAssumptions) { #region Produce trace output to extract implicit assumptions. Please don't remove this code! Console.WriteLine("<assumptions>"); Console.WriteLine(@"<subroutine id=""{0}"" methodName=""{1}"">", HybridLayer.Decoder.Context.MethodContext.CFG.Subroutine.Id, HybridLayer.Decoder.Context.MethodContext.CFG.Subroutine.Name); foreach (var b in HybridLayer.Decoder.Context.MethodContext.CFG.Subroutine.Blocks) { Console.WriteLine(@"<block index=""{0}"">", b.Index); foreach (var apc in b.APCs()) { Console.WriteLine(@"<apc name=""{0}"" index=""{1}"" ilOffset=""{2}"" primarySourceContext=""{3}"" sourceContext=""{4}"">", apc.ToString(), apc.Index, apc.ILOffset, apc.PrimarySourceContext(), HybridLayer.Decoder.Context.MethodContext.SourceContext(apc)); Console.WriteLine("<code>"); HybridLayer.Printer(apc, "", Console.Out); Console.WriteLine("</code>"); optimisticHeapAnalysis.Dump(apc); Console.WriteLine("</apc>"); } Console.WriteLine("</block>"); } Console.WriteLine("</subroutine>"); Console.WriteLine("</assumptions>"); #endregion } ModifiedAtCall = optimisticHeapAnalysis.ModifiedAtCall; }