Fix build with disabled DFG/FTL
[WebKit-https.git] / Source / JavaScriptCore / bytecode / InByIdStatus.cpp
1 /*
2  * Copyright (C) 2018 Yusuke Suzuki <utatane.tea@gmail.com>.
3  * Copyright (C) 2018 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #include "config.h"
28 #include "InByIdStatus.h"
29
30 #include "CodeBlock.h"
31 #include "ComplexGetStatus.h"
32 #include "ICStatusUtils.h"
33 #include "JSCInlines.h"
34 #include "PolymorphicAccess.h"
35 #include "StructureStubInfo.h"
36 #include <wtf/ListDump.h>
37
38 namespace JSC {
39
40 bool InByIdStatus::appendVariant(const InByIdVariant& variant)
41 {
42     return appendICStatusVariant(m_variants, variant);
43 }
44
45 #if ENABLE(JIT)
46 InByIdStatus InByIdStatus::computeFor(CodeBlock* profiledBlock, ICStatusMap& map, unsigned bytecodeIndex, UniquedStringImpl* uid, ExitFlag didExit)
47 {
48     ConcurrentJSLocker locker(profiledBlock->m_lock);
49
50     InByIdStatus result;
51
52 #if ENABLE(DFG_JIT)
53     result = computeForStubInfoWithoutExitSiteFeedback(locker, map.get(CodeOrigin(bytecodeIndex)).stubInfo, uid);
54
55     if (!result.takesSlowPath() && didExit)
56         return InByIdStatus(TakesSlowPath);
57 #else
58     UNUSED_PARAM(map);
59     UNUSED_PARAM(bytecodeIndex);
60     UNUSED_PARAM(uid);
61 #endif
62
63     return result;
64 }
65
66 InByIdStatus InByIdStatus::computeFor(CodeBlock* profiledBlock, ICStatusMap& map, unsigned bytecodeIndex, UniquedStringImpl* uid)
67 {
68     return computeFor(profiledBlock, map, bytecodeIndex, uid, hasBadCacheExitSite(profiledBlock, bytecodeIndex));
69 }
70
71 InByIdStatus InByIdStatus::computeFor(
72     CodeBlock* profiledBlock, ICStatusMap& baselineMap,
73     ICStatusContextStack& contextStack, CodeOrigin codeOrigin, UniquedStringImpl* uid)
74 {
75     ExitFlag didExit = hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex);
76     
77     for (ICStatusContext* context : contextStack) {
78         ICStatus status = context->get(codeOrigin);
79         
80         auto bless = [&] (const InByIdStatus& result) -> InByIdStatus {
81             if (!context->isInlined(codeOrigin)) {
82                 InByIdStatus baselineResult = computeFor(
83                     profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
84                 baselineResult.merge(result);
85                 return baselineResult;
86             }
87             if (didExit.isSet(ExitFromInlined))
88                 return InByIdStatus(TakesSlowPath);
89             return result;
90         };
91         
92 #if ENABLE(DFG_JIT)
93         if (status.stubInfo) {
94             InByIdStatus result;
95             {
96                 ConcurrentJSLocker locker(context->optimizedCodeBlock->m_lock);
97                 result = computeForStubInfoWithoutExitSiteFeedback(locker, status.stubInfo, uid);
98             }
99             if (result.isSet())
100                 return bless(result);
101         }
102 #endif
103         
104         if (status.inStatus)
105             return bless(*status.inStatus);
106     }
107     
108     return computeFor(profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
109 }
110 #endif // ENABLE(JIT)
111
112 #if ENABLE(DFG_JIT)
113 InByIdStatus InByIdStatus::computeForStubInfo(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
114 {
115     InByIdStatus result = InByIdStatus::computeForStubInfoWithoutExitSiteFeedback(locker, stubInfo, uid);
116
117     if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex))
118         return InByIdStatus(TakesSlowPath);
119     return result;
120 }
121
122 InByIdStatus InByIdStatus::computeForStubInfoWithoutExitSiteFeedback(const ConcurrentJSLocker&, StructureStubInfo* stubInfo, UniquedStringImpl* uid)
123 {
124     StubInfoSummary summary = StructureStubInfo::summary(stubInfo);
125     if (!isInlineable(summary))
126         return InByIdStatus(summary);
127     
128     // Finally figure out if we can derive an access strategy.
129     InByIdStatus result;
130     result.m_state = Simple;
131     switch (stubInfo->cacheType) {
132     case CacheType::Unset:
133         return InByIdStatus(NoInformation);
134
135     case CacheType::InByIdSelf: {
136         Structure* structure = stubInfo->u.byIdSelf.baseObjectStructure.get();
137         if (structure->takesSlowPathInDFGForImpureProperty())
138             return InByIdStatus(TakesSlowPath);
139         unsigned attributes;
140         InByIdVariant variant;
141         variant.m_offset = structure->getConcurrently(uid, attributes);
142         if (!isValidOffset(variant.m_offset))
143             return InByIdStatus(TakesSlowPath);
144         if (attributes & PropertyAttribute::CustomAccessor)
145             return InByIdStatus(TakesSlowPath);
146
147         variant.m_structureSet.add(structure);
148         bool didAppend = result.appendVariant(variant);
149         ASSERT_UNUSED(didAppend, didAppend);
150         return result;
151     }
152
153     case CacheType::Stub: {
154         PolymorphicAccess* list = stubInfo->u.stub;
155         for (unsigned listIndex = 0; listIndex < list->size(); ++listIndex) {
156             const AccessCase& access = list->at(listIndex);
157             if (access.viaProxy())
158                 return InByIdStatus(TakesSlowPath);
159
160             if (access.usesPolyProto())
161                 return InByIdStatus(TakesSlowPath);
162
163             Structure* structure = access.structure();
164             if (!structure) {
165                 // The null structure cases arise due to array.length. We have no way of creating a
166                 // InByIdVariant for those, and we don't really have to since the DFG handles those
167                 // cases in FixupPhase using value profiling. That's a bit awkward - we shouldn't
168                 // have to use value profiling to discover something that the AccessCase could have
169                 // told us. But, it works well enough. So, our only concern here is to not
170                 // crash on null structure.
171                 return InByIdStatus(TakesSlowPath);
172             }
173
174             ComplexGetStatus complexGetStatus = ComplexGetStatus::computeFor(structure, access.conditionSet(), uid);
175             switch (complexGetStatus.kind()) {
176             case ComplexGetStatus::ShouldSkip:
177                 continue;
178
179             case ComplexGetStatus::TakesSlowPath:
180                 return InByIdStatus(TakesSlowPath);
181
182             case ComplexGetStatus::Inlineable: {
183                 switch (access.type()) {
184                 case AccessCase::InHit:
185                 case AccessCase::InMiss:
186                     break;
187                 default:
188                     return InByIdStatus(TakesSlowPath);
189                 }
190
191                 InByIdVariant variant(
192                     StructureSet(structure), complexGetStatus.offset(),
193                     complexGetStatus.conditionSet());
194
195                 if (!result.appendVariant(variant))
196                     return InByIdStatus(TakesSlowPath);
197                 break;
198             }
199             }
200         }
201
202         return result;
203     }
204
205     default:
206         return InByIdStatus(TakesSlowPath);
207     }
208
209     RELEASE_ASSERT_NOT_REACHED();
210     return InByIdStatus();
211 }
212 #endif
213
214 void InByIdStatus::merge(const InByIdStatus& other)
215 {
216     if (other.m_state == NoInformation)
217         return;
218     
219     switch (m_state) {
220     case NoInformation:
221         *this = other;
222         return;
223         
224     case Simple:
225         if (other.m_state != Simple) {
226             *this = InByIdStatus(TakesSlowPath);
227             return;
228         }
229         for (const InByIdVariant& otherVariant : other.m_variants) {
230             if (!appendVariant(otherVariant)) {
231                 *this = InByIdStatus(TakesSlowPath);
232                 return;
233             }
234         }
235         return;
236         
237     case TakesSlowPath:
238         return;
239     }
240     
241     RELEASE_ASSERT_NOT_REACHED();
242 }
243
244 void InByIdStatus::filter(const StructureSet& structureSet)
245 {
246     if (m_state != Simple)
247         return;
248     filterICStatusVariants(m_variants, structureSet);
249     if (m_variants.isEmpty())
250         m_state = NoInformation;
251 }
252
253 void InByIdStatus::markIfCheap(SlotVisitor& visitor)
254 {
255     for (InByIdVariant& variant : m_variants)
256         variant.markIfCheap(visitor);
257 }
258
259 bool InByIdStatus::finalize()
260 {
261     for (InByIdVariant& variant : m_variants) {
262         if (!variant.finalize())
263             return false;
264     }
265     return true;
266 }
267
268 void InByIdStatus::dump(PrintStream& out) const
269 {
270     out.print("(");
271     switch (m_state) {
272     case NoInformation:
273         out.print("NoInformation");
274         break;
275     case Simple:
276         out.print("Simple");
277         break;
278     case TakesSlowPath:
279         out.print("TakesSlowPath");
280         break;
281     }
282     out.print(", ", listDump(m_variants), ")");
283 }
284
285 } // namespace JSC
286