public BasicBlock(BasicBlockKind kind)
{
Kind = kind;
_statements = ImmutableArray.CreateBuilder <IOperation>();
_successors = ImmutableHashSet.CreateBuilder <BasicBlock>();
_predecessors = ImmutableHashSet.CreateBuilder <BasicBlock>();
}
internal BasicBlock(
BasicBlockKind kind,
ImmutableArray <IOperation> operations,
IOperation branchValue,
ControlFlowConditionKind conditionKind,
int ordinal,
bool isReachable,
ControlFlowRegion region)
{
Kind = kind;
Operations = operations;
BranchValue = branchValue;
ConditionKind = conditionKind;
Ordinal = ordinal;
IsReachable = isReachable;
EnclosingRegion = region;
}
public BasicBlockBuilder(BasicBlockKind kind)
{
Kind = kind;
Ordinal = -1;
IsReachable = false;
}
public static Dictionary <int, postDominant> MPostDominant(string Code)
{
ControlFlowGraph CFG = MControlFlowGraphCompilation(Code);
Dictionary <int, Node> reversControlFlowGraph = MReverseControlFlowGraph(Code);
Dictionary <int, postDominant> postDominants = new Dictionary <int, postDominant>();
// initial postDominant
foreach (var basicBlock in CFG.Blocks.Reverse())
{
postDominant postDom = new postDominant();
BasicBlockKind basicBlockKind = basicBlock.Kind;
if (basicBlockKind.ToString() == "Exit")
{
postDominants.Add(basicBlock.Ordinal, postDom);
}
else
{
postDom.PostDominantBasicBlock = new List <BasicBlock>();
postDom.PostDominantId = new List <int>();
postDom.PostDominantBasicBlock.AddRange(CFG.Blocks);
//postDom.PostDominantBasicBlock.RemoveAt((CFG.Blocks.Count()) - 1); // delete exit block
postDom.PostDominantBasicBlock.ForEach(x => postDom.PostDominantId.Add(x.Ordinal));
postDominants.Add(basicBlock.Ordinal, postDom);
}
}
// obtaine postDominat for every node
foreach (var item in reversControlFlowGraph)
{
if (item.Value.basicBlock.Kind.ToString() == "Exit") // Set Node Exit
{
postDominants[item.Key].PostDominantBasicBlock = new List <BasicBlock>();
postDominants[item.Key].PostDominantId = new List <int>();
postDominants[item.Key].PostDominantBasicBlock.Add(item.Value.basicBlock);
postDominants[item.Key].PostDominantId.Add(item.Value.id);
postDominants[item.Key].check = true;
continue;
} //basic block is exit
List <int> basicBlockResult = new List <int>();
postDominants[item.Key].PostDominantId.ForEach(x => basicBlockResult.Add(x)); //basic block result
postDominants[item.Key].PostDominantBasicBlock.RemoveRange(0, postDominants[item.Key].PostDominantBasicBlock.Count);
postDominants[item.Key].PostDominantId.RemoveRange(0, postDominants[item.Key].PostDominantId.Count);
postDominants[item.Key].PostDominantBasicBlock.Add(item.Value.basicBlock); //1
postDominants[item.Key].PostDominantId.Add(item.Value.basicBlock.Ordinal); //1
var parentList = item.Value.parentList;
if (parentList.Count == 1)
{
int parent = new int();
parent = parentList.ElementAt(0);
if (postDominants[parent].PostDominantBasicBlock == null)
{
postDominants[parent].PostDominantBasicBlock = new List <BasicBlock>(); // create new bject
}
if (postDominants[parent].PostDominantId == null)
{
postDominants[parent].PostDominantId = new List <int>(); // create new object
}
if (postDominants[parent].PostDominantBasicBlock.Count() != 0 && postDominants[parent].check == true) // if node is not Exit
{
postDominants[parent].PostDominantBasicBlock.ForEach(x => postDominants[item.Key].PostDominantBasicBlock.Add(x)); //2
postDominants[parent].PostDominantId.ForEach(x => postDominants[item.Key].PostDominantId.Add(x));
}
else if (postDominants[parent].PostDominantBasicBlock.Count() == 0)
{
postDominants[item.Key].PostDominantBasicBlock.Add(CFG.Blocks.Last()); // Add Exit Block
postDominants[item.Key].PostDominantId.Add(CFG.Blocks.Last().Ordinal);
} // 2
postDominants[item.Key].check = true;
}
else if (parentList.Count > 1)
{
// Intersect predecessore
foreach (var member in parentList)
{
List <int> basicBlockIntersect = postDominants[member].PostDominantId;
basicBlockResult = basicBlockResult.Intersect(basicBlockIntersect).ToList();
}
// Add list postDominantId
basicBlockResult.ForEach(x => postDominants[item.Key].PostDominantId.Add(x));
// Find basicBlock
foreach (var id in basicBlockResult)
{
foreach (var BB in CFG.Blocks)
{
if (id == BB.Ordinal)
{
postDominants[item.Key].PostDominantBasicBlock.Add(BB);
}
}
}
basicBlockResult.Clear();
}
postDominants[item.Key].check = true;
}
//sort postDominant
Queue queue = new Queue();
Dictionary <int, Node> cfg = MControlFlowGraph(Code);
foreach (var postDominant in postDominants)
{
postDominant postDominantIsSort = new postDominant();
postDominantIsSort.PostDominantId = new List <int>();
postDominantIsSort.PostDominantBasicBlock = new List <BasicBlock>();
queue.Enqueue(cfg.Last().Value.id); //initial Quequ
//initial postDominant
postDominantIsSort.check = true;
postDominantIsSort.id = postDominant.Key;
while (queue.Count > 0 && postDominantIsSort.PostDominantId.Count != postDominant.Value.PostDominantId.Count)
{
int Id = int.Parse(queue.Dequeue().ToString()); //1:Id pop from Queqe
Node node = cfg.ElementAtOrDefault(Id).Value;
if (postDominant.Value.PostDominantId.Exists(x => x == Id))
{
postDominantIsSort.PostDominantId.Add(node.id);
postDominantIsSort.PostDominantBasicBlock.Add(node.basicBlock);
}
foreach (var parent in node.parentList) //2:parent Id add to queue
{
if (queue.Contains(parent) == false) //parent hasn't in queue
{
queue.Enqueue(parent);
}
}
}
queue.Clear();
postDominant.Value.PostDominantId.Clear();
postDominantIsSort.PostDominantId.ForEach(x => postDominant.Value.PostDominantId.Add(x)); //Add sorting Ids
postDominant.Value.PostDominantBasicBlock.Clear();
postDominantIsSort.PostDominantBasicBlock.ForEach(x => postDominant.Value.PostDominantBasicBlock.Add(x)); //Add sorting basic Blocks
}
return(postDominants);
}
private static BasicBlock Find(this ControlFlowGraph graph, BasicBlockKind kind) => graph.Blocks.Single(block => block.Kind == kind);
public BasicBlock(BasicBlockKind kind = BasicBlockKind.Block)
{
Kind = kind;
Predecessors = new List <BasicBlock>();
}
