public static ILPrinter <Label> Create <Label, Source, Dest, Context, EdgeData>
(IILDecoder <Label, Source, Dest, Context, EdgeData> ilDecoder,
IMetaDataProvider metaDataProvider,
Func <Source, string> sourceToString, Func <Dest, string> destToString)
{
return(new Printer <Label, Source, Dest, Context, EdgeData> (ilDecoder, metaDataProvider, sourceToString, destToString).PrintCodeAt);
}
public static ForwardAnalysis <AbstractState, EdgeData> Make <Source, Dest, Context> (
IILDecoder <APC, Source, Dest, Context, EdgeData> decoder,
IAnalysis <APC, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState>, EdgeData> analysis)
where Context : IMethodContextProvider
{
IILVisitor <APC, Source, Dest, AbstractState, AbstractState> visitor = analysis.GetVisitor();
var forwardAnalysisSolver = new ForwardAnalysis <AbstractState, EdgeData> (
decoder.ContextProvider.MethodContext.CFG,
(pc, state) => decoder.ForwardDecode <AbstractState, AbstractState, IILVisitor <APC, Source, Dest, AbstractState, AbstractState> > (pc, visitor, state),
analysis.Join,
analysis.ImmutableVersion,
analysis.MutableVersion,
analysis.EdgeConversion,
decoder.EdgeData,
(pc, state) => {
if (!decoder.IsUnreachable(pc))
{
return(analysis.IsBottom(pc, state));
}
return(true);
},
analysis.Dump
);
analysis.SaveFixPointInfo(forwardAnalysisSolver);
return(forwardAnalysisSolver);
}
public ExpressionDecoder(IILDecoder <APC, TSymbolicValue, TSymbolicValue, IValueContextProvider <TSymbolicValue>, TEdgeData> valueDecoder,
ExpressionAnalysisFacade <TSymbolicValue, TContext, TEdgeData> parent)
{
this.value_decoder = valueDecoder;
this.parent = parent;
this.underlying = valueDecoder.ContextProvider;
}
public Printer(IILDecoder <Label, Source, Dest, Context, EdgeData> ilDecoder, IMetaDataProvider metaDataProvider,
Func <Source, string> sourceToString, Func <Dest, string> destToString)
{
this.il_decoder = ilDecoder;
this.meta_data_provider = metaDataProvider;
this.source_to_string = sourceToString;
this.dest_to_string = destToString;
}
Create <Expression, Variable, ContextData, EdgeConversionData> (
IILDecoder <APC, Expression, Variable, ContextData, EdgeConversionData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder, Func <Expression, string> expressionToString, Func <Variable, string> variableToString, ILPrinter <APC> printer)
where ContextData : IMethodContextProvider
{
return(new CodeLayer <Expression, Variable, ContextData, EdgeConversionData>
(ilDecoder, metadataDecoder, contractDecoder, expressionToString, variableToString, printer));
}
public CodeLayer(IILDecoder <APC, Expression, Variable, ContextData, EdgeData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder,
Func <Expression, string> expressionToString,
Func <Variable, string> variableToString, ILPrinter <APC> printer)
: this(ilDecoder, metadataDecoder, contractDecoder, expressionToString, variableToString)
{
this.printer = new Lazy <ILPrinter <APC> > (() => printer);
}
public CodeLayer(IILDecoder <APC, Expression, Variable, ContextData, EdgeData> ilDecoder,
IMetaDataProvider metadataDecoder,
IContractProvider contractDecoder,
Func <Expression, string> expressionToString,
Func <Variable, string> variableToString)
{
ExpressionToString = expressionToString;
VariableToString = variableToString;
ILDecoder = ilDecoder;
MetaDataProvider = metadataDecoder;
ContractProvider = contractDecoder;
this.printer = new Lazy <ILPrinter <APC> > (() => PrinterFactory.Create(ILDecoder, MetaDataProvider, ExpressionToString, VariableToString));
}
public void RunHeapAndExpressionAnalyses()
{
if (this.heap_analysis != null)
{
return;
}
this.heap_analysis = new HeapAnalysis.HeapAnalysis(StackLayer);
StackLayer.CreateForward(this.heap_analysis) (this.heap_analysis.InitialValue());
ValueLayer = CodeLayerFactory.Create(
this.heap_analysis.GetDecoder(StackLayer.ILDecoder), StackLayer.MetaDataProvider, StackLayer.ContractProvider,
source => source.ToString(), dest => dest.ToString());
var expressionAnalysis = new ExpressionAnalysisFacade <SymbolicValue, IValueContextProvider <SymbolicValue>, IImmutableMap <SymbolicValue, LispList <SymbolicValue> > >
(ValueLayer, this.heap_analysis.IsUnreachable);
ValueLayer.CreateForward(expressionAnalysis.CreateExpressionAnalysis()) (expressionAnalysis.InitialValue(SymbolicValue.GetUniqueKey));
if (DebugOptions.Debug)
{
Console.WriteLine("------------Value based CFG-----------------");
ValueLayer.ILDecoder.ContextProvider.MethodContext.CFG.Print(Console.Out, ValueLayer.Printer, null, null);
}
IILDecoder
<APC, LabeledSymbol <APC, SymbolicValue>, SymbolicValue, IExpressionContextProvider <LabeledSymbol <APC, SymbolicValue>, SymbolicValue>, IImmutableMap <SymbolicValue, LispList <SymbolicValue> > >
decoder = expressionAnalysis.GetDecoder(ValueLayer.ILDecoder);
this.expr2String = ExpressionPrinterFactory.Printer(decoder.ContextProvider, this);
ExpressionLayer = CodeLayerFactory.Create(decoder, ValueLayer.MetaDataProvider, ValueLayer.ContractProvider,
this.expr2String, ValueLayer.VariableToString);
if (DebugOptions.Debug)
{
Console.WriteLine("------------Expression based CFG-------------");
ExpressionLayer.ILDecoder.ContextProvider.MethodContext.CFG.Print(Console.Out, ExpressionLayer.Printer, null, null);
}
HybridLayer = CodeLayerFactory.Create(ValueLayer.ILDecoder, ValueLayer.MetaDataProvider, ValueLayer.ContractProvider,
ValueLayer.ExpressionToString,
ValueLayer.VariableToString, ExpressionLayer.Printer);
}
public StackDepthProvider(IILDecoder <APC, Dummy, Dummy, TContext, Dummy> ilDecoder,
IMetaDataProvider metaDataProvider)
{
this.il_decoder = ilDecoder;
MetaDataProvider = metaDataProvider;
}
GetDecoder(
IILDecoder <APC, TSymValue, TSymValue, IValueContextProvider <TSymValue>, TEdgeData> ilDecoder)
{
return(new ExpressionDecoder <TSymValue, TContext, TEdgeData> (ilDecoder, this));
}
GetDecoder <Context>(IILDecoder <APC, int, int, Context, Dummy> underlying)
where Context : IStackContextProvider
{
return(new ValueDecoder <Context> (this, underlying));
}
public ValueDecoder(HeapAnalysis parent, IILDecoder <APC, int, int, TContext, Dummy> stackDecoder)
{
this.context = new Lazy <IValueContextProvider <SymbolicValue> > (() => new ValueContextProvider <TContext>(this.parent, this.stack_decoder.ContextProvider));
this.parent = parent;
this.stack_decoder = stackDecoder;
}
public static IILDecoder <APC, int, int, IStackContextProvider, Dummy> Create <TContext> (IILDecoder <APC, Dummy, Dummy, TContext, Dummy> ilDecoder,
IMetaDataProvider metadataDecoder) where TContext : IMethodContextProvider
{
return(new StackDepthProvider <TContext> (ilDecoder, metadataDecoder));
}
