void Build(IList <CfgNode> nodes)
{
worklistMoves.Clear();
_graph = InterferenceGraphGenerator.MakeGraph(nodes, regType, precolored);
foreach (var move in _graph.Moves)
{
worklistMoves.Add(move);
var ml = MoveList(move.Register1.ToString());
if (!ml.Contains(move))
{
ml.Add(move);
}
ml = MoveList(move.Register2.ToString());
if (!ml.Contains(move))
{
ml.Add(move);
}
}
foreach (var node in _graph.Nodes)
//foreach (var node in _graph.Nodes.Where(n => !precolored.Contains(n)))
{
degree[node] = _graph.Graph.Count(e => e.Item1 == node || e.Item2 == node);
}
// TODO: Build the movelist!
}
public static InterferenceGraph Select(InterferenceGraph graph, Stack <string> stack)
{
var newgraph = new InterferenceGraph();
while (stack.Count > 0)
{
var node = stack.Pop();
var edges = graph.Graph.Where(e => (newgraph.Nodes.Contains(e.Item1) && e.Item2 == node) ||
(newgraph.Nodes.Contains(e.Item2) && e.Item1 == node));
foreach (var edge in edges)
{
newgraph.Graph.Add(edge);
}
newgraph.Nodes.Add(node);
// Select color (register) for node
// Try to find existing color (register)
int?register = null;
for (var i = 0; i < newgraph.Allocation.Count; i++)
{
var alloc = newgraph.Allocation[i];
var interfered =
newgraph.Graph.Any(
e => ((e.Item2 == node && alloc.Contains(e.Item1)) || (e.Item1 == node && alloc.Contains(e.Item2))));
if (!interfered)
{
register = i;
alloc.Add(node);
break;
}
}
if (!register.HasValue)
{
// Must allocate new
var set = new HashSet <string>();
set.Add(node);
newgraph.Allocation.Add(set);
register = newgraph.Allocation.Count - 1;
}
newgraph.AllocationMap[node] = register.Value;
}
return(newgraph);
}
public static InterferenceGraph MakeGraph(IList <CfgNode> nodes, RegType regType, IList <string> preColored)
{
var graph = new HashSet <Tuple <string, string> >();
var g = new InterferenceGraph {
Graph = graph
};
int added = 0;
foreach (var p1 in preColored)
{
foreach (var p2 in preColored)
{
if (p1 != p2 && !g.IsEdgeBetween(p1, p2) && !g.IsEdgeBetween(p2, p1))
{
g.Graph.Add(new Tuple <string, string>(p1, p2));
added++;
}
}
g.Nodes.Add(p1);
}
foreach (var node in nodes.Where(n => n != null))
{
foreach (var def in node.Def.Where(dn => IsRegType(regType, dn)))
{
foreach (var o in node.Out.Where(dn => IsRegType(regType, dn)))
{
if (o != def && !graph.Contains(new Tuple <string, string>(def, o)) && !graph.Contains(new Tuple <string, string>(o, def)))
{
graph.Add(new Tuple <string, string>(def, o));
}
g.Nodes.Add(o);
g.Nodes.Add(def);
}
}
var inst = node.Instruction;
if (inst.Register1 != null && inst.Register2 != null &&
inst.Register1.Type == regType && inst.Register2.Type == regType &&
inst.AddressingMode1 == M68kAddressingMode.Register && inst.AddressingMode2 == M68kAddressingMode.Register)
{
var a = node.Instruction.Register1.ToString();
var c = node.Instruction.Register2.ToString();
if (node.Instruction.Opcode == M68kOpcode.Move)
{
//g.Moves.Add(a);
//g.Moves.Add(c);
g.Moves.Add(node.Instruction);
}
foreach (var b in node.Out.Where(dn => IsRegType(regType, dn)))
{
if (b != c && !graph.Contains(new Tuple <string, string>(a, b)) && !graph.Contains(new Tuple <string, string>(b, a)))
{
graph.Add(new Tuple <string, string>(a, b));
}
g.Nodes.Add(b);
}
g.Nodes.Add(c);
}
}
return(g);
}
