c9d90d4c2959366691c9db7dd2da0e370b950abb
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGVarargsForwardingPhase.cpp
1 /*
2  * Copyright (C) 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 "DFGVarargsForwardingPhase.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "DFGArgumentsUtilities.h"
32 #include "DFGClobberize.h"
33 #include "DFGGraph.h"
34 #include "DFGPhase.h"
35 #include "JSCInlines.h"
36
37 namespace JSC { namespace DFG {
38
39 namespace {
40
41 bool verbose = false;
42
43 class VarargsForwardingPhase : public Phase {
44 public:
45     VarargsForwardingPhase(Graph& graph)
46         : Phase(graph, "varargs forwarding")
47     {
48     }
49     
50     bool run()
51     {
52         if (verbose) {
53             dataLog("Graph before varargs forwarding:\n");
54             m_graph.dump();
55         }
56         
57         m_changed = false;
58         for (BasicBlock* block : m_graph.blocksInNaturalOrder())
59             handleBlock(block);
60         return m_changed;
61     }
62
63 private:
64     void handleBlock(BasicBlock* block)
65     {
66         for (unsigned nodeIndex = 0; nodeIndex < block->size(); ++nodeIndex) {
67             Node* node = block->at(nodeIndex);
68             switch (node->op()) {
69             case CreateDirectArguments:
70             case CreateClonedArguments:
71                 handleCandidate(block, nodeIndex);
72                 break;
73             default:
74                 break;
75             }
76         }
77     }
78     
79     void handleCandidate(BasicBlock* block, unsigned candidateNodeIndex)
80     {
81         // We expect calls into this function to be rare. So, this is written in a simple O(n) manner.
82         
83         Node* candidate = block->at(candidateNodeIndex);
84         if (verbose)
85             dataLog("Handling candidate ", candidate, "\n");
86         
87         // Find the index of the last node in this block to use the candidate, and look for escaping
88         // sites.
89         unsigned lastUserIndex = candidateNodeIndex;
90         for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex < block->size(); ++nodeIndex) {
91             Node* node = block->at(nodeIndex);
92             switch (node->op()) {
93             case Phantom:
94             case Check:
95             case MovHint:
96             case PutHint:
97             case LoadVarargs:
98                 if (m_graph.uses(node, candidate))
99                     lastUserIndex = nodeIndex;
100                 break;
101                 
102             case CallVarargs:
103             case ConstructVarargs:
104                 if (node->child1() == candidate || node->child3() == candidate) {
105                     if (verbose)
106                         dataLog("    Escape at ", node, "\n");
107                     return;
108                 }
109                 if (node->child2() == candidate)
110                     lastUserIndex = nodeIndex;
111                 break;
112                 
113             case SetLocal:
114                 if (node->child1() == candidate && node->variableAccessData()->isLoadedFrom()) {
115                     if (verbose)
116                         dataLog("    Escape at ", node, "\n");
117                     return;
118                 }
119                 break;
120                 
121             default:
122                 if (m_graph.uses(node, candidate)) {
123                     if (verbose)
124                         dataLog("    Escape at ", node, "\n");
125                     return;
126                 }
127             }
128         }
129         if (verbose)
130             dataLog("Selected lastUserIndex = ", lastUserIndex, ", ", block->at(lastUserIndex), "\n");
131         
132         // We're still in business. Determine if between the candidate and the last user there is any
133         // effect that could interfere with sinking.
134         for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex <= lastUserIndex; ++nodeIndex) {
135             Node* node = block->at(nodeIndex);
136             
137             // We have our own custom switch to detect some interferences that clobberize() wouldn't know
138             // about, and also some of the common ones, too. In particular, clobberize() doesn't know
139             // that Flush, MovHint, ZombieHint, and KillStack are bad because it's not worried about
140             // what gets read on OSR exit.
141             switch (node->op()) {
142             case MovHint:
143             case ZombieHint:
144             case KillStack:
145                 if (argumentsInvolveStackSlot(candidate, node->unlinkedLocal())) {
146                     if (verbose)
147                         dataLog("    Interference at ", node, "\n");
148                     return;
149                 }
150                 break;
151                 
152             case PutStack:
153                 if (argumentsInvolveStackSlot(candidate, node->stackAccessData()->local)) {
154                     if (verbose)
155                         dataLog("    Interference at ", node, "\n");
156                     return;
157                 }
158                 break;
159                 
160             case SetLocal:
161             case Flush:
162                 if (argumentsInvolveStackSlot(candidate, node->local())) {
163                     if (verbose)
164                         dataLog("    Interference at ", node, "\n");
165                     return;
166                 }
167                 break;
168                 
169             default: {
170                 bool doesInterfere = false;
171                 clobberize(
172                     m_graph, node, NoOpClobberize(),
173                     [&] (AbstractHeap heap) {
174                         if (heap.kind() != Stack) {
175                             ASSERT(!heap.overlaps(Stack));
176                             return;
177                         }
178                         ASSERT(!heap.payload().isTop());
179                         VirtualRegister reg(heap.payload().value32());
180                         if (argumentsInvolveStackSlot(candidate, reg))
181                             doesInterfere = true;
182                     },
183                     NoOpClobberize());
184                 if (doesInterfere) {
185                     if (verbose)
186                         dataLog("    Interference at ", node, "\n");
187                     return;
188                 }
189             } }
190         }
191         
192         // We can make this work.
193         if (verbose)
194             dataLog("    Will do forwarding!\n");
195         m_changed = true;
196         
197         // Transform the program.
198         switch (candidate->op()) {
199         case CreateDirectArguments:
200             candidate->setOpAndDefaultFlags(PhantomDirectArguments);
201             break;
202
203         case CreateClonedArguments:
204             candidate->setOpAndDefaultFlags(PhantomClonedArguments);
205             break;
206             
207         default:
208             DFG_CRASH(m_graph, candidate, "bad node type");
209             break;
210         }
211         for (unsigned nodeIndex = candidateNodeIndex + 1; nodeIndex <= lastUserIndex; ++nodeIndex) {
212             Node* node = block->at(nodeIndex);
213             switch (node->op()) {
214             case Phantom:
215             case Check:
216             case MovHint:
217             case PutHint:
218                 // We don't need to change anything with these.
219                 break;
220                 
221             case LoadVarargs:
222                 if (node->child1() != candidate)
223                     break;
224                 node->setOpAndDefaultFlags(ForwardVarargs);
225                 break;
226                 
227             case CallVarargs:
228                 if (node->child2() != candidate)
229                     break;
230                 node->setOpAndDefaultFlags(CallForwardVarargs);
231                 break;
232                 
233             case ConstructVarargs:
234                 if (node->child2() != candidate)
235                     break;
236                 node->setOpAndDefaultFlags(ConstructForwardVarargs);
237                 break;
238                 
239             case SetLocal:
240                 // This is super odd. We don't have to do anything here, since in DFG IR, the phantom
241                 // arguments nodes do produce a JSValue. Also, we know that if this SetLocal referenecs a
242                 // candidate then the SetLocal - along with all of its references - will die off pretty
243                 // soon, since it has no real users. DCE will surely kill it. If we make it to SSA, then
244                 // SSA conversion will kill it.
245                 break;
246                 
247             default:
248                 if (ASSERT_DISABLED)
249                     break;
250                 m_graph.doToChildren(
251                     node,
252                     [&] (Edge edge) {
253                         DFG_ASSERT(m_graph, node, edge != candidate);
254                     });
255                 break;
256             }
257         }
258     }
259     
260     bool m_changed;
261 };
262
263 } // anonymous namespace
264
265 bool performVarargsForwarding(Graph& graph)
266 {
267     SamplingRegion samplingRegion("DFG Varargs Forwarding Phase");
268     return runPhase<VarargsForwardingPhase>(graph);
269 }
270
271 } } // namespace JSC::DFG
272
273 #endif // ENABLE(DFG_JIT)
274