9f316e873462b5f2b50abc8957b6ebfd13d7d48f
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGLICMPhase.cpp
1 /*
2  * Copyright (C) 2013-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "DFGLICMPhase.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "DFGAbstractInterpreterInlines.h"
32 #include "DFGAtTailAbstractState.h"
33 #include "DFGBasicBlockInlines.h"
34 #include "DFGClobberSet.h"
35 #include "DFGClobberize.h"
36 #include "DFGEdgeDominates.h"
37 #include "DFGGraph.h"
38 #include "DFGInsertionSet.h"
39 #include "DFGPhase.h"
40 #include "DFGSafeToExecute.h"
41 #include "JSCInlines.h"
42
43 namespace JSC { namespace DFG {
44
45 namespace {
46
47 struct LoopData {
48     LoopData()
49         : preHeader(0)
50     {
51     }
52     
53     ClobberSet writes;
54     BasicBlock* preHeader;
55 };
56
57 } // anonymous namespace
58
59 class LICMPhase : public Phase {
60     static const bool verbose = false;
61     
62 public:
63     LICMPhase(Graph& graph)
64         : Phase(graph, "LICM")
65         , m_state(graph)
66         , m_interpreter(graph, m_state)
67     {
68     }
69     
70     bool run()
71     {
72         DFG_ASSERT(m_graph, nullptr, m_graph.m_form == SSA);
73         
74         m_graph.m_dominators.computeIfNecessary(m_graph);
75         m_graph.m_naturalLoops.computeIfNecessary(m_graph);
76         
77         m_data.resize(m_graph.m_naturalLoops.numLoops());
78         
79         // Figure out the set of things each loop writes to, not including blocks that
80         // belong to inner loops. We fix this later.
81         for (BlockIndex blockIndex = m_graph.numBlocks(); blockIndex--;) {
82             BasicBlock* block = m_graph.block(blockIndex);
83             if (!block)
84                 continue;
85             
86             // Skip blocks that are proved to not execute.
87             // FIXME: This shouldn't be needed.
88             // https://bugs.webkit.org/show_bug.cgi?id=128584
89             if (!block->cfaHasVisited)
90                 continue;
91             
92             const NaturalLoop* loop = m_graph.m_naturalLoops.innerMostLoopOf(block);
93             if (!loop)
94                 continue;
95             LoopData& data = m_data[loop->index()];
96             for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
97                 Node* node = block->at(nodeIndex);
98                 
99                 // Don't look beyond parts of the code that definitely always exit.
100                 // FIXME: This shouldn't be needed.
101                 // https://bugs.webkit.org/show_bug.cgi?id=128584
102                 if (node->op() == ForceOSRExit)
103                     break;
104
105                 addWrites(m_graph, node, data.writes);
106             }
107         }
108         
109         // For each loop:
110         // - Identify its pre-header.
111         // - Make sure its outer loops know what it clobbers.
112         for (unsigned loopIndex = m_graph.m_naturalLoops.numLoops(); loopIndex--;) {
113             const NaturalLoop& loop = m_graph.m_naturalLoops.loop(loopIndex);
114             LoopData& data = m_data[loop.index()];
115             for (
116                 const NaturalLoop* outerLoop = m_graph.m_naturalLoops.innerMostOuterLoop(loop);
117                 outerLoop;
118                 outerLoop = m_graph.m_naturalLoops.innerMostOuterLoop(*outerLoop))
119                 m_data[outerLoop->index()].writes.addAll(data.writes);
120             
121             BasicBlock* header = loop.header();
122             BasicBlock* preHeader = 0;
123             for (unsigned i = header->predecessors.size(); i--;) {
124                 BasicBlock* predecessor = header->predecessors[i];
125                 if (m_graph.m_dominators.dominates(header, predecessor))
126                     continue;
127                 DFG_ASSERT(m_graph, nullptr, !preHeader || preHeader == predecessor);
128                 preHeader = predecessor;
129             }
130             
131             DFG_ASSERT(m_graph, preHeader->terminal(), preHeader->terminal()->op() == Jump);
132             
133             data.preHeader = preHeader;
134         }
135         
136         m_graph.initializeNodeOwners();
137         
138         // Walk all basic blocks that belong to loops, looking for hoisting opportunities.
139         // We try to hoist to the outer-most loop that permits it. Hoisting is valid if:
140         // - The node doesn't write anything.
141         // - The node doesn't read anything that the loop writes.
142         // - The preHeader's state at tail makes the node safe to execute.
143         // - The loop's children all belong to nodes that strictly dominate the loop header.
144         // - The preHeader's state at tail is still valid. This is mostly to save compile
145         //   time and preserve some kind of sanity, if we hoist something that must exit.
146         //
147         // Also, we need to remember to:
148         // - Update the state-at-tail with the node we hoisted, so future hoist candidates
149         //   know about any type checks we hoisted.
150         //
151         // For maximum profit, we walk blocks in DFS order to ensure that we generally
152         // tend to hoist dominators before dominatees.
153         Vector<const NaturalLoop*> loopStack;
154         bool changed = false;
155         for (BasicBlock* block : m_graph.blocksInPreOrder()) {
156             const NaturalLoop* loop = m_graph.m_naturalLoops.innerMostLoopOf(block);
157             if (!loop)
158                 continue;
159             
160             loopStack.resize(0);
161             for (
162                 const NaturalLoop* current = loop;
163                 current;
164                 current = m_graph.m_naturalLoops.innerMostOuterLoop(*current))
165                 loopStack.append(current);
166             
167             // Remember: the loop stack has the inner-most loop at index 0, so if we want
168             // to bias hoisting to outer loops then we need to use a reverse loop.
169             
170             if (verbose) {
171                 dataLog(
172                     "Attempting to hoist out of block ", *block, " in loops:\n");
173                 for (unsigned stackIndex = loopStack.size(); stackIndex--;) {
174                     dataLog(
175                         "        ", *loopStack[stackIndex], ", which writes ",
176                         m_data[loopStack[stackIndex]->index()].writes, "\n");
177                 }
178             }
179             
180             for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
181                 Node*& nodeRef = block->at(nodeIndex);
182                 if (doesWrites(m_graph, nodeRef)) {
183                     if (verbose)
184                         dataLog("    Not hoisting ", nodeRef, " because it writes things.\n");
185                     continue;
186                 }
187
188                 for (unsigned stackIndex = loopStack.size(); stackIndex--;)
189                     changed |= attemptHoist(block, nodeRef, loopStack[stackIndex]);
190             }
191         }
192         
193         return changed;
194     }
195
196 private:
197     bool attemptHoist(BasicBlock* fromBlock, Node*& nodeRef, const NaturalLoop* loop)
198     {
199         Node* node = nodeRef;
200         LoopData& data = m_data[loop->index()];
201         
202         if (!data.preHeader->cfaDidFinish) {
203             if (verbose)
204                 dataLog("    Not hoisting ", node, " because CFA is invalid.\n");
205             return false;
206         }
207         
208         if (!edgesDominate(m_graph, node, data.preHeader)) {
209             if (verbose) {
210                 dataLog(
211                     "    Not hoisting ", node, " because it isn't loop invariant.\n");
212             }
213             return false;
214         }
215         
216         if (readsOverlap(m_graph, node, data.writes)) {
217             if (verbose) {
218                 dataLog(
219                     "    Not hoisting ", node,
220                     " because it reads things that the loop writes.\n");
221             }
222             return false;
223         }
224         
225         m_state.initializeTo(data.preHeader);
226         if (!safeToExecute(m_state, m_graph, node)) {
227             if (verbose) {
228                 dataLog(
229                     "    Not hoisting ", node, " because it isn't safe to execute.\n");
230             }
231             return false;
232         }
233         
234         if (verbose) {
235             dataLog(
236                 "    Hoisting ", node, " from ", *fromBlock, " to ", *data.preHeader,
237                 "\n");
238         }
239         
240         data.preHeader->insertBeforeTerminal(node);
241         node->owner = data.preHeader;
242         NodeOrigin originalOrigin = node->origin;
243         node->origin.forExit = data.preHeader->terminal()->origin.forExit;
244         
245         // Modify the states at the end of the preHeader of the loop we hoisted to,
246         // and all pre-headers inside the loop.
247         // FIXME: This could become a scalability bottleneck. Fortunately, most loops
248         // are small and anyway we rapidly skip over basic blocks here.
249         for (unsigned bodyIndex = loop->size(); bodyIndex--;) {
250             BasicBlock* subBlock = loop->at(bodyIndex);
251             const NaturalLoop* subLoop = m_graph.m_naturalLoops.headerOf(subBlock);
252             if (!subLoop)
253                 continue;
254             BasicBlock* subPreHeader = m_data[subLoop->index()].preHeader;
255             if (!subPreHeader->cfaDidFinish)
256                 continue;
257             m_state.initializeTo(subPreHeader);
258             m_interpreter.execute(node);
259         }
260         
261         // It just so happens that all of the nodes we currently know how to hoist
262         // don't have var-arg children. That may change and then we can fix this
263         // code. But for now we just assert that's the case.
264         DFG_ASSERT(m_graph, node, !(node->flags() & NodeHasVarArgs));
265         
266         nodeRef = m_graph.addNode(SpecNone, Check, originalOrigin, node->children);
267         
268         return true;
269     }
270     
271     AtTailAbstractState m_state;
272     AbstractInterpreter<AtTailAbstractState> m_interpreter;
273     Vector<LoopData> m_data;
274 };
275
276 bool performLICM(Graph& graph)
277 {
278     SamplingRegion samplingRegion("DFG LICM Phase");
279     return runPhase<LICMPhase>(graph);
280 }
281
282 } } // namespace JSC::DFG
283
284 #endif // ENABLE(DFG_JIT)
285