protected override void Run()
{
if (!HasCode)
{
return;
}
if (HasProtectedRegions)
{
return;
}
trace = CreateTraceLog(8);
foreach (var headBlock in BasicBlocks.HeadBlocks)
{
var analysis = new SimpleFastDominance(BasicBlocks, headBlock);
blockAnalysis.Add(headBlock, analysis);
}
CollectAssignments2();
PlacePhiFunctionsMinimal();
EnterSSA();
RemoveUselessPhiInstructions();
MethodCompiler.IsInSSAForm = true;
}
private void OutputDiagram()
{
var trace = CreateTraceLog("Diagram");
var sb = new StringBuilder();
trace.Log("digraph blocks {");
foreach (var headBlock in BasicBlocks.HeadBlocks)
{
var dominance = new SimpleFastDominance(BasicBlocks, headBlock);
for (int i = 0; i < BasicBlocks.Count; i++)
{
var block = BasicBlocks[i];
var children = dominance.GetChildren(block);
if (children != null && children.Count != 0)
{
foreach (var child in children)
{
trace.Log("\t" + block + " -> " + child);
}
}
}
}
trace.Log("}");
}
private void OutputDominanceBlock()
{
var trace = CreateTraceLog("DominanceBlock");
var sb = new StringBuilder();
foreach (var headBlock in BasicBlocks.HeadBlocks)
{
trace.Log("Head: " + headBlock);
var dominance = new SimpleFastDominance(BasicBlocks, headBlock);
for (int i = 0; i < BasicBlocks.Count; i++)
{
var block = BasicBlocks[i];
sb.Clear();
sb.Append(" Block ");
sb.Append(block);
sb.Append(" : ");
var dom = dominance.GetImmediateDominator(block);
sb.Append((dom != null) ? dom.ToString() : string.Empty);
trace.Log(sb.ToString());
}
trace.Log();
}
}
protected override void Run()
{
// Method is empty - must be a plugged method
if (BasicBlocks.HeadBlocks.Count == 0)
{
return;
}
if (HasProtectedRegions)
{
return;
}
trace = CreateTraceLog(6);
foreach (var headBlock in BasicBlocks.HeadBlocks)
{
var analysis = new SimpleFastDominance(BasicBlocks, headBlock);
blockAnalysis.Add(headBlock, analysis);
}
CollectAssignments();
PlacePhiFunctionsMinimal();
EnterSSA();
}
public static void DominanceCalculation1()
{
var basicBlocks = BlockTests.Scenario3;
var dominance = new SimpleFastDominance(basicBlocks, basicBlocks[0]);
var provider = dominance as IDominanceAnalysis;
Assert.Same(provider.GetImmediateDominator(basicBlocks[0]), null);
Assert.Same(provider.GetImmediateDominator(basicBlocks[1]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[2]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[3]), basicBlocks[2]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[4]), basicBlocks[2]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[5]), basicBlocks[2]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[6]), basicBlocks[0]);
Assert.Equal(provider.GetDominators(basicBlocks[0]), new[] { basicBlocks[0] });
//Assert.Equal(provider.GetDominators(basicBlocks[1]), new[] { basicBlocks[0], basicBlocks[1] });
//Assert.Equal(provider.GetDominators(basicBlocks[2]), new[] { basicBlocks[0], basicBlocks[2] });
//Assert.Equal(provider.GetDominators(basicBlocks[3]), new[] { basicBlocks[0], basicBlocks[2], basicBlocks[3] });
//Assert.Equal(provider.GetDominators(basicBlocks[4]), new[] { basicBlocks[0], basicBlocks[2], basicBlocks[4] });
//Assert.Equal(provider.GetDominators(basicBlocks[5]), new[] { basicBlocks[0], basicBlocks[2], basicBlocks[5] });
//Assert.Equal(provider.GetDominators(basicBlocks[6]), new[] { basicBlocks[0], basicBlocks[6] });
Dump(basicBlocks, dominance);
}
protected override void Run()
{
if (HasProtectedRegions)
{
return;
}
// Method is empty - must be a plugged method
if (BasicBlocks.HeadBlocks.Count != 1)
{
return;
}
if (BasicBlocks.PrologueBlock == null)
{
return;
}
trace = CreateTraceLog(5);
MapToValueNumber = new Dictionary <Operand, Operand>(MethodCompiler.VirtualRegisters.Count);
Expressions = new Dictionary <int, List <Expression> >();
Processed = new BitArray(BasicBlocks.Count, false);
AnalysisDominance = new SimpleFastDominance(BasicBlocks, BasicBlocks.PrologueBlock);
ReversePostOrder = AnalysisDominance.GetReversePostOrder();
DetermineReadOnlyParameters();
ValueNumber();
}
/// <summary>
/// Renames the variables.
/// </summary>
/// <param name="headBlock">The head block.</param>
/// <param name="dominanceAnalysis">The dominance analysis.</param>
private void RenameVariables(BasicBlock headBlock, SimpleFastDominance dominanceAnalysis)
{
var worklist = new Stack <BasicBlock>();
worklist.Push(headBlock);
while (worklist.Count != 0)
{
var block = worklist.Pop();
if (block != null)
{
if (trace.Active)
{
trace.Log("Processing: " + block);
}
UpdateOperands(block);
UpdatePHIs(block);
worklist.Push(block);
worklist.Push(null);
if (trace.Active)
{
trace.Log(" >Pushed: " + block + " (Return)");
}
// Repeat for all children of the dominance block, if any
var children = dominanceAnalysis.GetChildren(block);
if (children != null && children.Count > 0)
{
foreach (var s in children)
{
worklist.Push(s);
if (trace.Active)
{
trace.Log(" >Pushed: " + s);
}
}
}
}
else
{
block = worklist.Pop();
if (trace.Active)
{
trace.Log("Processing: " + block + " (Back)");
}
UpdateResultOperands(block);
}
}
}
protected override void Run()
{
if (!MethodCompiler.IsInSSAForm)
{
return;
}
if (HasProtectedRegions)
{
return;
}
// Method is empty - must be a plugged method
if (BasicBlocks.HeadBlocks.Count != 1)
{
return;
}
if (BasicBlocks.PrologueBlock == null)
{
return;
}
trace = CreateTraceLog(5);
ParamStoreSet = CollectParamStores();
AnalysisDominance = new SimpleFastDominance(BasicBlocks, BasicBlocks.PrologueBlock);
var loops = FindLoops();
if (loops.Count == 0)
{
return;
}
if (trace != null)
{
DumpLoops(loops);
}
SortLoops(loops);
FindLoopInvariantInstructions(loops);
if (CodeMotionCount.Count != 0)
{
Methods.Increment();
}
if (CompilerSettings.FullCheckMode)
{
CheckAllPhiInstructions();
}
}
protected override void Finish()
{
MapToValueNumber = null;
Expressions = null;
Processed = null;
AnalysisDominance = null;
ReversePostOrder = null;
ParamReadOnly = null;
trace = null;
}
protected override void Run()
{
if (HasProtectedRegions)
{
return;
}
// Method is empty - must be a plugged method
if (BasicBlocks.HeadBlocks.Count != 1)
{
return;
}
if (BasicBlocks.PrologueBlock == null)
{
return;
}
trace = CreateTraceLog(5);
AnalysisDominance = new SimpleFastDominance(BasicBlocks, BasicBlocks.PrologueBlock);
var loops = FindLoops();
if (loops.Count == 0)
{
return;
}
if (trace != null)
{
DumpLoops(loops);
}
SortLoops(loops);
FindLoopInvariantInstructions(loops);
if (CodeMotionCount.Count != 0)
{
Methods++;
}
}
/// <summary>
/// Renames the variables.
/// </summary>
/// <param name="block">The block.</param>
/// <param name="dominanceAnalysis">The dominance analysis.</param>
private void RenameVariables2(BasicBlock block, SimpleFastDominance dominanceAnalysis)
{
trace?.Log($"Processing: {block}");
UpdateOperands(block);
UpdatePHIs(block);
// Repeat for all children of the dominance block, if any
var children = dominanceAnalysis.GetChildren(block);
if (children != null && children.Count != 0)
{
foreach (var s in children)
{
RenameVariables2(s, dominanceAnalysis);
}
}
UpdateResultOperands(block);
}
public static void DominanceCalculation2()
{
var basicBlocks = BlockTests.Scenario4;
SimpleFastDominance dominance = new SimpleFastDominance(basicBlocks, basicBlocks[0]);
IDominanceAnalysis provider = dominance as IDominanceAnalysis;
Assert.Same(provider.GetImmediateDominator(basicBlocks[0]), null);
Assert.Same(provider.GetImmediateDominator(basicBlocks[1]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[2]), basicBlocks[1]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[3]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[4]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[5]), basicBlocks[4]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[6]), basicBlocks[4]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[7]), basicBlocks[4]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[8]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[9]), basicBlocks[8]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[10]), basicBlocks[8]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[11]), basicBlocks[0]);
Assert.Same(provider.GetImmediateDominator(basicBlocks[12]), basicBlocks[0]);
Assert.Equal(provider.GetDominators(basicBlocks[0]), new[] { basicBlocks[0] });
//Assert.Equal(provider.GetDominators(basicBlocks[1]), new[] { basicBlocks[0], basicBlocks[1] });
//Assert.Equal(provider.GetDominators(basicBlocks[2]), new[] { basicBlocks[0], basicBlocks[1], basicBlocks[2] });
//Assert.Equal(provider.GetDominators(basicBlocks[3]), new[] { basicBlocks[0], basicBlocks[3] });
//Assert.Equal(provider.GetDominators(basicBlocks[4]), new[] { basicBlocks[0], basicBlocks[4] });
//Assert.Equal(provider.GetDominators(basicBlocks[5]), new[] { basicBlocks[0], basicBlocks[4], basicBlocks[5] });
//Assert.Equal(provider.GetDominators(basicBlocks[6]), new[] { basicBlocks[0], basicBlocks[4], basicBlocks[6] });
//Assert.Equal(provider.GetDominators(basicBlocks[7]), new[] { basicBlocks[0], basicBlocks[4], basicBlocks[7] });
//Assert.Equal(provider.GetDominators(basicBlocks[8]), new[] { basicBlocks[0], basicBlocks[8] });
//Assert.Equal(provider.GetDominators(basicBlocks[9]), new[] { basicBlocks[0], basicBlocks[8], basicBlocks[9] });
//Assert.Equal(provider.GetDominators(basicBlocks[10]), new[] { basicBlocks[0], basicBlocks[8], basicBlocks[10] });
//Assert.Equal(provider.GetDominators(basicBlocks[11]), new[] { basicBlocks[0], basicBlocks[11] });
//Assert.Equal(provider.GetDominators(basicBlocks[12]), new[] { basicBlocks[0], basicBlocks[12] });
//Assert.Equal(provider.GetDominanceFrontier(basicBlocks[4]), new[] { basicBlocks[3], basicBlocks[4], basicBlocks[11], basicBlocks[12] });
Dump(basicBlocks, dominance);
}
protected override void Run()
{
if (HasProtectedRegions)
{
return;
}
// Method is empty - must be a plugged method
if (BasicBlocks.HeadBlocks.Count != 1)
{
return;
}
if (BasicBlocks.PrologueBlock == null)
{
return;
}
trace = CreateTraceLog(5);
AnalysisDominance = new SimpleFastDominance(BasicBlocks, BasicBlocks.PrologueBlock);
}
private void OutputList()
{
var trace = CreateTraceLog("List");
var sb = new StringBuilder();
foreach (var headBlock in BasicBlocks.HeadBlocks)
{
trace.Log("Head: " + headBlock);
var dominance = new SimpleFastDominance(BasicBlocks, headBlock);
for (int i = 0; i < BasicBlocks.Count; i++)
{
var block = BasicBlocks[i];
sb.Clear();
sb.Append(" Block ");
sb.Append(block);
sb.Append(" : ");
var children = dominance.GetChildren(block);
if (children != null && children.Count != 0)
{
foreach (var child in children)
{
sb.Append(child);
sb.Append(", ");
}
sb.Length -= 2;
}
trace.Log(sb.ToString());
}
trace.Log();
}
}
protected override void Finish()
{
ParamStoreSet = null;
AnalysisDominance = null;
}
protected override void Finish()
{
AnalysisDominance = null;
}
