Harden how the compiler references GC objects
[WebKit.git] / Source / JavaScriptCore / dfg / DFGNode.cpp
1 /*
2  * Copyright (C) 2013, 2014, 2016 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 "DFGNode.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "DFGGraph.h"
32 #include "DFGPromotedHeapLocation.h"
33 #include "JSCInlines.h"
34
35 namespace JSC { namespace DFG {
36
37 bool MultiPutByOffsetData::writesStructures() const
38 {
39     for (unsigned i = variants.size(); i--;) {
40         if (variants[i].writesStructures())
41             return true;
42     }
43     return false;
44 }
45
46 bool MultiPutByOffsetData::reallocatesStorage() const
47 {
48     for (unsigned i = variants.size(); i--;) {
49         if (variants[i].reallocatesStorage())
50             return true;
51     }
52     return false;
53 }
54
55 void BranchTarget::dump(PrintStream& out) const
56 {
57     if (!block)
58         return;
59     
60     out.print(*block);
61     
62     if (count == count) // If the count is not NaN, then print it.
63         out.print("/w:", count);
64 }
65
66 bool Node::hasVariableAccessData(Graph& graph)
67 {
68     switch (op()) {
69     case Phi:
70         return graph.m_form != SSA;
71     case GetLocal:
72     case SetLocal:
73     case SetArgument:
74     case Flush:
75     case PhantomLocal:
76         return true;
77     default:
78         return false;
79     }
80 }
81
82 void Node::remove()
83 {
84     ASSERT(!(flags() & NodeHasVarArgs));
85     
86     children = children.justChecks();
87     
88     setOpAndDefaultFlags(Check);
89 }
90
91 void Node::convertToIdentity()
92 {
93     RELEASE_ASSERT(child1());
94     RELEASE_ASSERT(!child2());
95     NodeFlags result = canonicalResultRepresentation(this->result());
96     setOpAndDefaultFlags(Identity);
97     setResult(result);
98 }
99
100 void Node::convertToIdentityOn(Node* child)
101 {
102     children.reset();
103     child1() = child->defaultEdge();
104     NodeFlags output = canonicalResultRepresentation(this->result());
105     NodeFlags input = canonicalResultRepresentation(child->result());
106     if (output == input) {
107         setOpAndDefaultFlags(Identity);
108         setResult(output);
109         return;
110     }
111     switch (output) {
112     case NodeResultDouble:
113         setOpAndDefaultFlags(DoubleRep);
114         switch (input) {
115         case NodeResultInt52:
116             child1().setUseKind(Int52RepUse);
117             return;
118         case NodeResultJS:
119             child1().setUseKind(NumberUse);
120             return;
121         default:
122             RELEASE_ASSERT_NOT_REACHED();
123             return;
124         }
125     case NodeResultInt52:
126         setOpAndDefaultFlags(Int52Rep);
127         switch (input) {
128         case NodeResultDouble:
129             child1().setUseKind(DoubleRepAnyIntUse);
130             return;
131         case NodeResultJS:
132             child1().setUseKind(AnyIntUse);
133             return;
134         default:
135             RELEASE_ASSERT_NOT_REACHED();
136             return;
137         }
138     case NodeResultJS:
139         setOpAndDefaultFlags(ValueRep);
140         switch (input) {
141         case NodeResultDouble:
142             child1().setUseKind(DoubleRepUse);
143             return;
144         case NodeResultInt52:
145             child1().setUseKind(Int52RepUse);
146             return;
147         default:
148             RELEASE_ASSERT_NOT_REACHED();
149             return;
150         }
151     default:
152         RELEASE_ASSERT_NOT_REACHED();
153         return;
154     }
155 }
156
157 void Node::convertToLazyJSConstant(Graph& graph, LazyJSValue value)
158 {
159     m_op = LazyJSConstant;
160     m_flags &= ~NodeMustGenerate;
161     m_opInfo = graph.m_lazyJSValues.add(value);
162     children.reset();
163 }
164
165 void Node::convertToPutHint(const PromotedLocationDescriptor& descriptor, Node* base, Node* value)
166 {
167     m_op = PutHint;
168     m_opInfo = descriptor.imm1();
169     m_opInfo2 = descriptor.imm2();
170     child1() = base->defaultEdge();
171     child2() = value->defaultEdge();
172     child3() = Edge();
173 }
174
175 void Node::convertToPutStructureHint(Node* structure)
176 {
177     ASSERT(m_op == PutStructure);
178     ASSERT(structure->castConstant<Structure*>() == transition()->next.get());
179     convertToPutHint(StructurePLoc, child1().node(), structure);
180 }
181
182 void Node::convertToPutByOffsetHint()
183 {
184     ASSERT(m_op == PutByOffset);
185     convertToPutHint(
186         PromotedLocationDescriptor(NamedPropertyPLoc, storageAccessData().identifierNumber),
187         child2().node(), child3().node());
188 }
189
190 void Node::convertToPutClosureVarHint()
191 {
192     ASSERT(m_op == PutClosureVar);
193     convertToPutHint(
194         PromotedLocationDescriptor(ClosureVarPLoc, scopeOffset().offset()),
195         child1().node(), child2().node());
196 }
197
198 void Node::convertToDirectCall(FrozenValue* executable)
199 {
200     NodeType newOp = LastNodeType;
201     switch (op()) {
202     case Call:
203         newOp = DirectCall;
204         break;
205     case Construct:
206         newOp = DirectConstruct;
207         break;
208     case TailCallInlinedCaller:
209         newOp = DirectTailCallInlinedCaller;
210         break;
211     case TailCall:
212         newOp = DirectTailCall;
213         break;
214     default:
215         RELEASE_ASSERT_NOT_REACHED();
216         break;
217     }
218     
219     m_op = newOp;
220     m_opInfo = executable;
221 }
222
223 void Node::convertToCallDOM(Graph& graph)
224 {
225     ASSERT(op() == Call);
226     ASSERT(signature());
227
228     Edge edges[3];
229     // Skip the first one. This is callee.
230     RELEASE_ASSERT(numChildren() <= 4);
231     for (unsigned i = 1; i < numChildren(); ++i)
232         edges[i - 1] = graph.varArgChild(this, i);
233
234     setOpAndDefaultFlags(CallDOM);
235     children.setChild1(edges[0]);
236     children.setChild2(edges[1]);
237     children.setChild3(edges[2]);
238
239     if (!signature()->effect.mustGenerate())
240         clearFlags(NodeMustGenerate);
241 }
242
243 String Node::tryGetString(Graph& graph)
244 {
245     if (hasConstant())
246         return constant()->tryGetString(graph);
247     if (hasLazyJSValue())
248         return lazyJSValue().tryGetString(graph);
249     return String();
250 }
251
252 PromotedLocationDescriptor Node::promotedLocationDescriptor()
253 {
254     return PromotedLocationDescriptor(static_cast<PromotedLocationKind>(m_opInfo.as<uint32_t>()), m_opInfo2.as<uint32_t>());
255 }
256
257 } } // namespace JSC::DFG
258
259 namespace WTF {
260
261 using namespace JSC;
262 using namespace JSC::DFG;
263
264 void printInternal(PrintStream& out, SwitchKind kind)
265 {
266     switch (kind) {
267     case SwitchImm:
268         out.print("SwitchImm");
269         return;
270     case SwitchChar:
271         out.print("SwitchChar");
272         return;
273     case SwitchString:
274         out.print("SwitchString");
275         return;
276     case SwitchCell:
277         out.print("SwitchCell");
278         return;
279     }
280     RELEASE_ASSERT_NOT_REACHED();
281 }
282
283 void printInternal(PrintStream& out, Node* node)
284 {
285     if (!node) {
286         out.print("-");
287         return;
288     }
289     out.print("@", node->index());
290     if (node->hasDoubleResult())
291         out.print("<Double>");
292     else if (node->hasInt52Result())
293         out.print("<Int52>");
294 }
295
296 } // namespace WTF
297
298 #endif // ENABLE(DFG_JIT)
299