bd1ba87eeb2e526d8b4c05eb736d3efeaed2be85
[WebKit-https.git] / Source / JavaScriptCore / dfg / DFGVariableAccessData.cpp
1 /*
2  * Copyright (C) 2014, 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 "DFGVariableAccessData.h"
28
29 #if ENABLE(DFG_JIT)
30
31 namespace JSC { namespace DFG {
32
33 VariableAccessData::VariableAccessData()
34     : m_local(static_cast<VirtualRegister>(std::numeric_limits<int>::min()))
35     , m_prediction(SpecNone)
36     , m_argumentAwarePrediction(SpecNone)
37     , m_flags(0)
38     , m_shouldNeverUnbox(false)
39     , m_structureCheckHoistingFailed(false)
40     , m_checkArrayHoistingFailed(false)
41     , m_isProfitableToUnbox(false)
42     , m_isLoadedFrom(false)
43     , m_doubleFormatState(EmptyDoubleFormatState)
44 {
45     clearVotes();
46 }
47
48 VariableAccessData::VariableAccessData(VirtualRegister local)
49     : m_local(local)
50     , m_prediction(SpecNone)
51     , m_argumentAwarePrediction(SpecNone)
52     , m_flags(0)
53     , m_shouldNeverUnbox(false)
54     , m_structureCheckHoistingFailed(false)
55     , m_checkArrayHoistingFailed(false)
56     , m_isProfitableToUnbox(false)
57     , m_isLoadedFrom(false)
58     , m_doubleFormatState(EmptyDoubleFormatState)
59 {
60     clearVotes();
61 }
62
63 bool VariableAccessData::mergeShouldNeverUnbox(bool shouldNeverUnbox)
64 {
65     bool newShouldNeverUnbox = m_shouldNeverUnbox | shouldNeverUnbox;
66     if (newShouldNeverUnbox == m_shouldNeverUnbox)
67         return false;
68     m_shouldNeverUnbox = newShouldNeverUnbox;
69     return true;
70 }
71
72 bool VariableAccessData::predict(SpeculatedType prediction)
73 {
74     VariableAccessData* self = find();
75     bool result = mergeSpeculation(self->m_prediction, prediction);
76     if (result)
77         mergeSpeculation(m_argumentAwarePrediction, m_prediction);
78     return result;
79 }
80
81 bool VariableAccessData::mergeArgumentAwarePrediction(SpeculatedType prediction)
82 {
83     return mergeSpeculation(find()->m_argumentAwarePrediction, prediction);
84 }
85
86 bool VariableAccessData::shouldUseDoubleFormatAccordingToVote()
87 {
88     // We don't support this facility for arguments, yet.
89     // FIXME: make this work for arguments.
90     if (local().isArgument())
91         return false;
92         
93     // If the variable is not a number prediction, then this doesn't
94     // make any sense.
95     if (!isFullNumberSpeculation(prediction())) {
96         // FIXME: we may end up forcing a local in inlined argument position to be a double even
97         // if it is sometimes not even numeric, since this never signals the fact that it doesn't
98         // want doubles. https://bugs.webkit.org/show_bug.cgi?id=109511
99         return false;
100     }
101         
102     // If the variable is predicted to hold only doubles, then it's a
103     // no-brainer: it should be formatted as a double.
104     if (isDoubleSpeculation(prediction()))
105         return true;
106         
107     // If the variable is known to be used as an integer, then be safe -
108     // don't force it to be a double.
109     if (flags() & NodeBytecodeUsesAsInt)
110         return false;
111         
112     // If the variable has been voted to become a double, then make it a
113     // double.
114     if (voteRatio() >= Options::doubleVoteRatioForDoubleFormat())
115         return true;
116         
117     return false;
118 }
119
120 bool VariableAccessData::tallyVotesForShouldUseDoubleFormat()
121 {
122     ASSERT(isRoot());
123         
124     if (local().isArgument() || shouldNeverUnbox()
125         || (flags() & NodeBytecodeUsesAsArrayIndex))
126         return DFG::mergeDoubleFormatState(m_doubleFormatState, NotUsingDoubleFormat);
127     
128     if (m_doubleFormatState == CantUseDoubleFormat)
129         return false;
130         
131     bool newValueOfShouldUseDoubleFormat = shouldUseDoubleFormatAccordingToVote();
132     if (!newValueOfShouldUseDoubleFormat) {
133         // We monotonically convert to double. Hence, if the fixpoint leads us to conclude that we should
134         // switch back to int, we instead ignore this and stick with double.
135         return false;
136     }
137         
138     if (m_doubleFormatState == UsingDoubleFormat)
139         return false;
140         
141     return DFG::mergeDoubleFormatState(m_doubleFormatState, UsingDoubleFormat);
142 }
143
144 bool VariableAccessData::mergeDoubleFormatState(DoubleFormatState doubleFormatState)
145 {
146     return DFG::mergeDoubleFormatState(find()->m_doubleFormatState, doubleFormatState);
147 }
148
149 bool VariableAccessData::makePredictionForDoubleFormat()
150 {
151     ASSERT(isRoot());
152     
153     if (m_doubleFormatState != UsingDoubleFormat)
154         return false;
155     
156     SpeculatedType type = m_prediction;
157     if (type & ~SpecBytecodeNumber)
158         type |= SpecDoublePureNaN;
159     if (type & SpecMachineInt)
160         type |= SpecInt52AsDouble;
161     return checkAndSet(m_prediction, type);
162 }
163
164 bool VariableAccessData::couldRepresentInt52()
165 {
166     if (shouldNeverUnbox())
167         return false;
168     
169     return couldRepresentInt52Impl();
170 }
171
172 bool VariableAccessData::couldRepresentInt52Impl()
173 {
174     // The hardware has to support it.
175     if (!enableInt52())
176         return false;
177     
178     // We punt for machine arguments.
179     if (m_local.isArgument())
180         return false;
181     
182     // The argument-aware prediction -- which merges all of an (inlined or machine)
183     // argument's variable access datas' predictions -- must possibly be MachineInt.
184     return !(argumentAwarePrediction() & ~SpecMachineInt);
185 }
186
187 FlushFormat VariableAccessData::flushFormat()
188 {
189     ASSERT(find() == this);
190     
191     if (!shouldUnboxIfPossible())
192         return FlushedJSValue;
193     
194     if (shouldUseDoubleFormat())
195         return FlushedDouble;
196     
197     SpeculatedType prediction = argumentAwarePrediction();
198     
199     // This guard is here to protect the call to couldRepresentInt52(), which will return
200     // true for !prediction.
201     if (!prediction)
202         return FlushedJSValue;
203     
204     if (isInt32Speculation(prediction))
205         return FlushedInt32;
206     
207     if (couldRepresentInt52Impl())
208         return FlushedInt52;
209     
210     if (isCellSpeculation(prediction))
211         return FlushedCell;
212     
213     if (isBooleanSpeculation(prediction))
214         return FlushedBoolean;
215     
216     return FlushedJSValue;
217 }
218
219 } } // namespace JSC::DFG
220
221 #endif // ENABLE(DFG_JIT)
222