Пример #1
0
        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!
        }
Пример #2
0
        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);
        }