Ryujinx.Graphics/Shader/Translation/Dominance.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

using Ryujinx.Graphics.Shader.IntermediateRepresentation;
using System.Collections.Generic;

namespace Ryujinx.Graphics.Shader.Translation
{
    static class Dominance
    {
        //Those methods are an implementation of the algorithms on "A Simple, Fast Dominance Algorithm".
        //https://www.cs.rice.edu/~keith/EMBED/dom.pdf
        public static void FindDominators(BasicBlock entry, int blocksCount)
        {
            HashSet<BasicBlock> visited = new HashSet<BasicBlock>();

            Stack<BasicBlock> blockStack = new Stack<BasicBlock>();

            List<BasicBlock> postOrderBlocks = new List<BasicBlock>(blocksCount);

            int[] postOrderMap = new int[blocksCount];

            visited.Add(entry);

            blockStack.Push(entry);

            while (blockStack.TryPop(out BasicBlock block))
            {
                if (block.Next != null && visited.Add(block.Next))
                {
                    blockStack.Push(block);
                    blockStack.Push(block.Next);
                }
                else if (block.Branch != null && visited.Add(block.Branch))
                {
                    blockStack.Push(block);
                    blockStack.Push(block.Branch);
                }
                else
                {
                    postOrderMap[block.Index] = postOrderBlocks.Count;

                    postOrderBlocks.Add(block);
                }
            }

            BasicBlock Intersect(BasicBlock block1, BasicBlock block2)
            {
                while (block1 != block2)
                {
                    while (postOrderMap[block1.Index] < postOrderMap[block2.Index])
                    {
                        block1 = block1.ImmediateDominator;
                    }

                    while (postOrderMap[block2.Index] < postOrderMap[block1.Index])
                    {
                        block2 = block2.ImmediateDominator;
                    }
                }

                return block1;
            }

            entry.ImmediateDominator = entry;

            bool modified;

            do
            {
                modified = false;

                for (int blkIndex = postOrderBlocks.Count - 2; blkIndex >= 0; blkIndex--)
                {
                    BasicBlock block = postOrderBlocks[blkIndex];

                    BasicBlock newIDom = null;

                    foreach (BasicBlock predecessor in block.Predecessors)
                    {
                        if (predecessor.ImmediateDominator != null)
                        {
                            if (newIDom != null)
                            {
                                newIDom = Intersect(predecessor, newIDom);
                            }
                            else
                            {
                                newIDom = predecessor;
                            }
                        }
                    }

                    if (block.ImmediateDominator != newIDom)
                    {
                        block.ImmediateDominator = newIDom;

                        modified = true;
                    }
                }
            }
            while (modified);
        }

        public static void FindDominanceFrontiers(BasicBlock[] blocks)
        {
            for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
            {
                BasicBlock block = blocks[blkIndex];

                if (block.Predecessors.Count < 2)
                {
                    continue;
                }

                for (int pBlkIndex = 0; pBlkIndex < block.Predecessors.Count; pBlkIndex++)
                {
                    BasicBlock current = block.Predecessors[pBlkIndex];

                    while (current != block.ImmediateDominator)
                    {
                        current.DominanceFrontiers.Add(block);

                        current = current.ImmediateDominator;
                    }
                }
            }
        }
    }
}