public SimpleAnalysis(ControlFlowGraph.ControlFlowGraph entryCFG, Weverca.MemoryModels.MemoryModelFactory memoryModel, EnvironmentInitializer initializer)
: base(entryCFG, memoryModel.CreateSnapshot)
{
_flowResolver = new SimpleFlowResolver();
_functionResolver = new SimpleFunctionResolver(initializer);
initializer(EntryInput);
}
/// <summary>
/// Initialises the analysis singletons.
/// </summary>
private void initialiseAnalysisSingletons()
{
ControlFlowGraph.ControlFlowGraph cfg = ControlFlowGraph.ControlFlowGraph.FromSource("<? $a = 1; echo $a; ?>", FileName);
var analysis = new Weverca.Analysis.ForwardAnalysis(cfg, MemoryModel);
analysis.Analyse();
}
/// <summary>
/// Creates new Instance of ForwardAnalysis
/// </summary>
/// <param name="entryMethodGraph">ControlFlowGraph to analyze</param>
/// <param name="memoryModel">Memory model used by analyser</param>
/// <param name="simplifyLimit">Limit for calling simplificaion in memory model. It is different for tests</param>
public ForwardAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel, int simplifyLimit = 3)
: base(entryMethodGraph, memoryModel.CreateSnapshot)
{
GlobalsInitializer();
this.SimplifyLimit = simplifyLimit;
this.WideningLimit = 2;
}
} // множества OUT для блоков
/// <summary>
/// Итерационный алгоритм для активных переменных. Находит для графа <paramref name="graph"/> множества
/// IN (<paramref name="InBlocks"/>) и OUT (<paramref name="OutBlocks"/>) на основе ранее вычисленных
/// Def и Use (<paramref name="defUseBlocks"/>). IN и OUT сохраняются в объекте IterAlgoActiveVariables
/// Граф должен содержать фиктивный узел ВЫХОД.
/// </summary>
/// <param name="defUseBlocks"></param>
/// <param name="graph"></param>
public InOutActiveVariables(DefUseBlocks defUseBlocks, ControlFlowGraph.ControlFlowGraph graph)
{
InBlocks = new List <HashSet <string> >();
OutBlocks = new List <HashSet <string> >();
for (int i = 0; i < defUseBlocks.DefBs.Count; i++)
{
InBlocks.Add(new HashSet <string>());
OutBlocks.Add(new HashSet <string>());
}
bool isInChanged = true;
while (isInChanged)
{
isInChanged = false;
for (int i = 0; i < defUseBlocks.DefBs.Count - 1; i++)
{
var previousIn = new string[InBlocks[i].Count];
InBlocks[i].CopyTo(previousIn);
OutBlocks[i] = MeetOperator(graph, i);
var Except = new HashSet <string>(OutBlocks[i]);
Except.ExceptWith(defUseBlocks.DefBs[i]);
InBlocks[i].UnionWith(Except);
InBlocks[i].UnionWith(defUseBlocks.UseBs[i]);
isInChanged = isInChanged || !InBlocks[i].SetEquals(previousIn);
}
}
}
/// <summary>
/// Применяет к графу <paramref name="graph"/> удаление мертвых переменных на основе
/// информации о множествах IN и OUT для блоков из <paramref name="InOut"/>.
/// Возвращает новый граф с выполненной на нем оптимизацией без изменения исходного графа.
/// </summary>
/// <param name="InOut"></param>
/// <param name="graph"></param>
/// <returns></returns>
public CFG DeadOrAliveOnGraph(List <HashSet <string> > OutBlocks, CFG graph)
{
IsApplyed = false;
var resGraph = new ControlFlowGraph.ControlFlowGraph(
new List <LinkedList <Visitors.ThreeCode> >(graph.blocks));
if (OutBlocks.Count != resGraph.blocks.Count)
{
throw new ArgumentException("The number of elements in the sets OUT, graph.blocks must be equal");
}
for (int i = resGraph.blocks.Count - 1; i >= 0; i--)
{
var variables = new Dictionary <string, bool>();
foreach (var ъуъ in OutBlocks[i])
{
variables[ъуъ] = true;
}
var Optimizer = new DeadOrAliveOptimizationAdapter();
resGraph.blocks[i] = Optimizer.DeleteDeadVariables(resGraph.blocks[i], variables);
IsApplyed = IsApplyed || Optimizer.Applyed();
}
return(resGraph);
}
static ProgramPointGraph Analyze(ControlFlowGraph.ControlFlowGraph entryMethod, string fileName, MemoryModels.MemoryModelFactory memoryModel)
{
FileInfo fileInfo = new FileInfo(fileName);
var analysis = new ForwardAnalysis(entryMethod, memoryModel);
analysis.Analyse();
return(analysis.ProgramPointGraph);
}
/// <summary>
/// Оператор сбора для задачи анализа активных переменных
/// </summary>
/// <param name="graph">Граф потоков управления</param>
/// <param name="index">Индекс анализируемого блока B</param>
/// <returns></returns>
private HashSet <string> MeetOperator(ControlFlowGraph.ControlFlowGraph graph, int index)
{
var successors = graph.GetAsGraph().GetOutputNodes(index);
var OutBlock = new HashSet <string>();
foreach (var i in successors)
{
OutBlock.UnionWith(InBlocks[i]);
}
return(OutBlock);
}
public IterativeAlgorithm(List <BlockInfo> blocksInfo, ControlFlowGraph.ControlFlowGraph graph,
Func <List <BlockInfo>, ControlFlowGraph.ControlFlowGraph, int, BlockInfo> meetOperator, bool isForward,
IEnumerable <string> initValueEntryExit, IEnumerable <string> initValueOthers,
TransferFunction <BlockInfo> function)
{
BlocksInfo = blocksInfo;
Graph = graph;
MeetOperator = meetOperator;
IsForward = isForward;
InitEntryExit = new HashSet <string>(initValueEntryExit);
InitOther = new HashSet <string>(initValueOthers);
Function = function;
}
/// <summary>
/// Creates analyses used for the test case.
/// </summary>
/// <param name="cfg"></param>
/// <returns></returns>
internal List <ForwardAnalysisBase> CreateAnalyses(ControlFlowGraph.ControlFlowGraph cfg)
{
var analyses = new List <ForwardAnalysisBase>();
foreach (var analysis in _analyses)
{
foreach (var memoryModel in _memoryModels)
{
analyses.Add(analysis.createAnalysis(cfg, memoryModel, EnvironmentInitializer));
}
}
return(analyses);
}
/// <summary>
/// Возвращает результат применения к графу <paramref name="graph"/> оптимизацию LVN как новый граф.
/// </summary>
/// <param name="graph"></param>
public static ControlFlowGraph.ControlFlowGraph LVNOptimize(ControlFlowGraph.ControlFlowGraph graph)
{
var resGraph = new ControlFlowGraph.ControlFlowGraph(
new List <LinkedList <Visitors.ThreeCode> >(graph.blocks));
foreach (var block in resGraph.blocks)
{
var replace = LVNOptimization.LVNOptimize(block);
block.Clear();
foreach (var line in replace)
{
block.AddLast(line);
}
}
return(resGraph);
}
/// <summary>
/// Возвращает результат каскадного удаления живых и мертвых переменных,
/// выполненного над графом <paramref name="graph"/>.
/// </summary>
/// <param name="graph"></param>
public static ControlFlowGraph.ControlFlowGraph DeleteDeadVariables(ControlFlowGraph.ControlFlowGraph graph)
{
var resGraph = new ControlFlowGraph.ControlFlowGraph(
new List <LinkedList <Visitors.ThreeCode> >(graph.blocks));
foreach (var block in resGraph.blocks)
{
var replace = DeadOrAliveOptimization.DeleteDeadVariables(block);
block.Clear();
foreach (var line in replace)
{
block.AddLast(line);
}
}
return(resGraph);
}
/// <summary>
/// Применяет к графу <paramref name="graph"/> удаление мертвых переменных на основе
/// информации о множествах IN и OUT для блоков из <paramref name="InOut"/>.
/// Возвращает новый граф с выполненной на нем оптимизацией без изменения исходного графа.
/// </summary>
/// <param name="InOut"></param>
/// <param name="graph"></param>
/// <returns></returns>
public static ControlFlowGraph.ControlFlowGraph DeadOrAliveOnGraph(List <HashSet <string> > OutBlocks, ControlFlowGraph.ControlFlowGraph graph)
{
var resGraph = new ControlFlowGraph.ControlFlowGraph(
new List <LinkedList <Visitors.ThreeCode> >(graph.blocks));
if (OutBlocks.Count != resGraph.blocks.Count)
{
throw new ArgumentException("The number of elements in the sets OUT, graph.blocks must be equal");
}
for (int i = resGraph.blocks.Count - 1; i >= 0; i--)
{
var variables = new Dictionary <string, bool>();
foreach (var v in OutBlocks[i])
{
variables[v] = true;
}
resGraph.blocks[i] = DeadOrAliveOptimization.DeleteDeadVariables(resGraph.blocks[i], variables);
}
return(resGraph);
}
static string RunVerification(ControlFlowGraph.ControlFlowGraph controlFlowGraph, string fileName, MemoryModels.MemoryModelFactory memoryModel)
{
var output = new WebOutput();
try
{
var ppGraph = Analyze(controlFlowGraph, fileName, memoryModel);
if (ppGraph.End != null)
{
output.ProgramPointInfo("End point", ppGraph.End);
}
else
{
output.Error("End point was not reached");
}
}
catch (Exception e)
{
output.Error(e.Message);
}
return(output.Output);
}
public DominatorsFinder(ControlFlowGraph.ControlFlowGraph cfg)
{
this.cfg = cfg;
}
public override ForwardAnalysisBase CreateAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel)
{
return(createAnalysis(entryMethodGraph, memoryModel, EnvironmentInitializer));
}
public override ForwardAnalysisBase CreateAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel)
{
return(createAnalysis(entryMethodGraph, memoryModel, delegate(FlowOutputSet o) { }));
}
public WevercaAnalysisTest(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel, EnvironmentInitializer initializer)
: base(entryMethodGraph, memoryModel)
{
_flowResolver = new WevercaFlowResolverTest();
_functionResolver = new WevercaFunctionResolverTest(initializer);
}
/// <summary> /// Creates an instance of ForwardAnalysis corresponding to given enumeration item. /// </summary> /// <param name="entryMethodGraph">the method where the analysis starts</param> /// <param name="memoryModel">memory model used for the analysis</param> /// <returns></returns> public abstract ForwardAnalysisBase CreateAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel);
/// <summary> /// Creates an instance of ForwardAnalysis corresponding to given enumeration item. /// </summary> /// <returns>an instance of ForwardAnalysis corresponding to given enumeration item</returns> internal abstract ForwardAnalysisBase createAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel, EnvironmentInitializer initializer);
/// <summary>
/// Creates program point graph for given control flow graph
/// </summary>
/// <param name="cfg">Input control flow graph</param>
/// <returns>Created program point graph</returns>
public static ProgramPointGraph FromSource(ControlFlowGraph.ControlFlowGraph cfg)
{
var ppgraph = new ProgramPointGraph(cfg, null);
return(ppgraph);
}
/// <summary>
/// Create program point graph from source begining by entryPoint
/// </summary>
/// <param name="cfg">Entry cfg into source (all feasible basic blocks will be included in program point graph)</param>
/// <param name="sourceObject">Object that is source for program point graph (Function declaration, GlobalCode,...)</param>
private ProgramPointGraph(ControlFlowGraph.ControlFlowGraph cfg, LangElement sourceObject)
: this(cfg.start, sourceObject)
{
OwningScript = cfg.File;
}
public override ForwardAnalysisBase CreateAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel)
{
throw new NotImplementedException();
}
/// <summary>
/// Creates the control flow graph.
/// </summary>
private void createControlFlowGraph()
{
FileInfo sourceFile = new FileInfo(FileName);
controlFlowGraph = ControlFlowGraph.ControlFlowGraph.FromFile(sourceFile);
}
internal override ForwardAnalysisBase createAnalysis(ControlFlowGraph.ControlFlowGraph entryMethodGraph, MemoryModels.MemoryModelFactory memoryModel, EnvironmentInitializer initializer)
{
return(new WevercaAnalysisTest(entryMethodGraph, memoryModel, initializer));
}
