Merge r169148, r169185, r169188, r169578, r169582, r169584, r169588, r169753 from...
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGAbstractValue.cpp
1 /*
2  * Copyright (C) 2013, 2014 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 "DFGAbstractValue.h"
28
29 #if ENABLE(DFG_JIT)
30
31 #include "DFGGraph.h"
32 #include "JSCInlines.h"
33
34 namespace JSC { namespace DFG {
35
36 void AbstractValue::observeTransitions(const TransitionVector& vector)
37 {
38     if (m_type & SpecCell) {
39         m_structure.observeTransitions(vector);
40         ArrayModes newModes = 0;
41         for (unsigned i = vector.size(); i--;) {
42             if (m_arrayModes & asArrayModes(vector[i].previous->indexingType()))
43                 newModes |= asArrayModes(vector[i].next->indexingType());
44         }
45         m_arrayModes |= newModes;
46     }
47     checkConsistency();
48 }
49
50 void AbstractValue::setMostSpecific(Graph& graph, JSValue value)
51 {
52     if (!!value && value.isCell()) {
53         Structure* structure = value.asCell()->structure();
54         graph.watchpoints().consider(structure);
55         m_structure = structure;
56         m_arrayModes = asArrayModes(structure->indexingType());
57     } else {
58         m_structure.clear();
59         m_arrayModes = 0;
60     }
61         
62     m_type = speculationFromValue(value);
63     m_value = value;
64         
65     checkConsistency();
66     assertIsWatched(graph);
67 }
68
69 void AbstractValue::set(Graph& graph, JSValue value, StructureClobberState clobberState)
70 {
71     if (!!value && value.isCell()) {
72         Structure* structure = value.asCell()->structure();
73         if (graph.watchpoints().consider(structure)) {
74             // We should be able to assume that the watchpoint for this has already been set.
75             // But we can't because our view of what structure a value has keeps changing. That's
76             // why we call consider().
77             // https://bugs.webkit.org/show_bug.cgi?id=133426
78             m_structure = structure;
79             if (clobberState == StructuresAreClobbered) {
80                 m_arrayModes = ALL_ARRAY_MODES;
81                 m_structure.clobber();
82             } else
83                 m_arrayModes = asArrayModes(structure->indexingType());
84         } else {
85             m_structure.makeTop();
86             m_arrayModes = ALL_ARRAY_MODES;
87         }
88     } else {
89         m_structure.clear();
90         m_arrayModes = 0;
91     }
92     
93     m_type = speculationFromValue(value);
94     m_value = value;
95     
96     checkConsistency();
97     assertIsWatched(graph);
98 }
99
100 void AbstractValue::set(Graph& graph, Structure* structure)
101 {
102     m_structure = structure;
103     m_arrayModes = asArrayModes(structure->indexingType());
104     m_type = speculationFromStructure(structure);
105     m_value = JSValue();
106     
107     checkConsistency();
108     assertIsWatched(graph);
109 }
110
111 void AbstractValue::set(Graph& graph, const StructureSet& set)
112 {
113     m_structure = set;
114     m_arrayModes = set.arrayModesFromStructures();
115     m_type = set.speculationFromStructures();
116     m_value = JSValue();
117     
118     checkConsistency();
119     assertIsWatched(graph);
120 }
121
122 void AbstractValue::fixTypeForRepresentation(NodeFlags representation)
123 {
124     if (representation == NodeResultDouble) {
125         if (m_value) {
126             ASSERT(m_value.isNumber());
127             if (m_value.isInt32())
128                 m_value = jsDoubleNumber(m_value.asNumber());
129         }
130         if (m_type & SpecMachineInt) {
131             m_type &= ~SpecMachineInt;
132             m_type |= SpecInt52AsDouble;
133         }
134         if (m_type & ~SpecFullDouble) {
135             startCrashing();
136             dataLog("Abstract value ", *this, " for double node has type outside SpecFullDouble.\n");
137             CRASH();
138         }
139     } else if (representation == NodeResultInt52) {
140         if (m_type & SpecInt52AsDouble) {
141             m_type &= ~SpecInt52AsDouble;
142             m_type |= SpecInt52;
143         }
144         if (m_type & ~SpecMachineInt) {
145             startCrashing();
146             dataLog("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n");
147             CRASH();
148         }
149     } else {
150         if (m_type & SpecInt52) {
151             m_type &= ~SpecInt52;
152             m_type |= SpecInt52AsDouble;
153         }
154         if (m_type & ~SpecBytecodeTop) {
155             startCrashing();
156             dataLog("Abstract value ", *this, " for value node has type outside SpecBytecodeTop.\n");
157             CRASH();
158         }
159     }
160     
161     checkConsistency();
162 }
163
164 void AbstractValue::fixTypeForRepresentation(Node* node)
165 {
166     fixTypeForRepresentation(node->result());
167 }
168
169 FiltrationResult AbstractValue::filter(Graph& graph, const StructureSet& other)
170 {
171     if (isClear())
172         return FiltrationOK;
173     
174     // FIXME: This could be optimized for the common case of m_type not
175     // having structures, array modes, or a specific value.
176     // https://bugs.webkit.org/show_bug.cgi?id=109663
177     
178     m_type &= other.speculationFromStructures();
179     m_arrayModes &= other.arrayModesFromStructures();
180     m_structure.filter(other);
181     
182     // It's possible that prior to the above two statements we had (Foo, TOP), where
183     // Foo is a SpeculatedType that is disjoint with the passed StructureSet. In that
184     // case, we will now have (None, [someStructure]). In general, we need to make
185     // sure that new information gleaned from the SpeculatedType needs to be fed back
186     // into the information gleaned from the StructureSet.
187     m_structure.filter(m_type);
188     
189     filterArrayModesByType();
190     filterValueByType();
191     return normalizeClarity(graph);
192 }
193
194 FiltrationResult AbstractValue::filterArrayModes(ArrayModes arrayModes)
195 {
196     ASSERT(arrayModes);
197     
198     if (isClear())
199         return FiltrationOK;
200     
201     m_type &= SpecCell;
202     m_arrayModes &= arrayModes;
203     return normalizeClarity();
204 }
205
206 FiltrationResult AbstractValue::filter(SpeculatedType type)
207 {
208     if ((m_type & type) == m_type)
209         return FiltrationOK;
210     
211     // Fast path for the case that we don't even have a cell.
212     if (!(m_type & SpecCell)) {
213         m_type &= type;
214         FiltrationResult result;
215         if (m_type == SpecNone) {
216             clear();
217             result = Contradiction;
218         } else
219             result = FiltrationOK;
220         checkConsistency();
221         return result;
222     }
223     
224     m_type &= type;
225     
226     // It's possible that prior to this filter() call we had, say, (Final, TOP), and
227     // the passed type is Array. At this point we'll have (None, TOP). The best way
228     // to ensure that the structure filtering does the right thing is to filter on
229     // the new type (None) rather than the one passed (Array).
230     m_structure.filter(type);
231     filterArrayModesByType();
232     filterValueByType();
233     return normalizeClarity();
234 }
235
236 FiltrationResult AbstractValue::filterByValue(JSValue value)
237 {
238     FiltrationResult result = filter(speculationFromValue(value));
239     if (m_type)
240         m_value = value;
241     return result;
242 }
243
244 void AbstractValue::filterValueByType()
245 {
246     // We could go further, and ensure that if the futurePossibleStructure contravenes
247     // the value, then we could clear both of those things. But that's unlikely to help
248     // in any realistic scenario, so we don't do it. Simpler is better.
249
250     if (!!m_type) {
251         // The type is still non-empty. It may be that the new type renders
252         // the value empty because it contravenes the constant value we had.
253         if (m_value && !validateType(m_value))
254             clear();
255         return;
256     }
257     
258     // The type has been rendered empty. That means that the value must now be invalid,
259     // as well.
260     ASSERT(!m_value || !validateType(m_value));
261     m_value = JSValue();
262 }
263
264 void AbstractValue::filterArrayModesByType()
265 {
266     if (!(m_type & SpecCell))
267         m_arrayModes = 0;
268     else if (!(m_type & ~SpecArray))
269         m_arrayModes &= ALL_ARRAY_ARRAY_MODES;
270     
271     // NOTE: If m_type doesn't have SpecArray set, that doesn't mean that the
272     // array modes have to be a subset of ALL_NON_ARRAY_ARRAY_MODES, since
273     // in the speculated type type-system, RegExpMatchesArry and ArrayPrototype
274     // are Otherobj (since they are not *exactly* JSArray) but in the ArrayModes
275     // type system they are arrays (since they expose the magical length
276     // property and are otherwise allocated using array allocation). Hence the
277     // following would be wrong:
278     //
279     // if (!(m_type & SpecArray))
280     //    m_arrayModes &= ALL_NON_ARRAY_ARRAY_MODES;
281 }
282
283 bool AbstractValue::shouldBeClear() const
284 {
285     if (m_type == SpecNone)
286         return true;
287     
288     if (!(m_type & ~SpecCell)
289         && (!m_arrayModes || m_structure.isClear()))
290         return true;
291     
292     return false;
293 }
294
295 FiltrationResult AbstractValue::normalizeClarity()
296 {
297     // It's useful to be able to quickly check if an abstract value is clear.
298     // This normalizes everything to make that easy.
299     
300     FiltrationResult result;
301     
302     if (shouldBeClear()) {
303         clear();
304         result = Contradiction;
305     } else
306         result = FiltrationOK;
307
308     checkConsistency();
309     
310     return result;
311 }
312
313 FiltrationResult AbstractValue::normalizeClarity(Graph& graph)
314 {
315     FiltrationResult result = normalizeClarity();
316     assertIsWatched(graph);
317     return result;
318 }
319
320 #if !ASSERT_DISABLED
321 void AbstractValue::checkConsistency() const
322 {
323     if (!(m_type & SpecCell)) {
324         ASSERT(m_structure.isClear());
325         ASSERT(!m_arrayModes);
326     }
327     
328     if (isClear())
329         ASSERT(!m_value);
330     
331     if (!!m_value) {
332         SpeculatedType type = m_type;
333         // This relaxes the assertion below a bit, since we don't know the representation of the
334         // node.
335         if (type & SpecInt52)
336             type |= SpecInt52AsDouble;
337         ASSERT(mergeSpeculations(type, speculationFromValue(m_value)) == type);
338     }
339     
340     // Note that it's possible for a prediction like (Final, []). This really means that
341     // the value is bottom and that any code that uses the value is unreachable. But
342     // we don't want to get pedantic about this as it would only increase the computational
343     // complexity of the code.
344 }
345
346 void AbstractValue::assertIsWatched(Graph& graph) const
347 {
348     m_structure.assertIsWatched(graph);
349 }
350 #endif
351
352 void AbstractValue::dump(PrintStream& out) const
353 {
354     dumpInContext(out, 0);
355 }
356
357 void AbstractValue::dumpInContext(PrintStream& out, DumpContext* context) const
358 {
359     out.print("(", SpeculationDump(m_type));
360     if (m_type & SpecCell) {
361         out.print(
362             ", ", ArrayModesDump(m_arrayModes), ", ",
363             inContext(m_structure, context));
364     }
365     if (!!m_value)
366         out.print(", ", inContext(m_value, context));
367     out.print(")");
368 }
369
370 } } // namespace JSC::DFG
371
372 #endif // ENABLE(DFG_JIT)
373