Fix warnings on ARM and MIPS
[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     UNUSED_PARAM(didExit);
62 #endif
63
64     return result;
65 }
66
67 InByIdStatus InByIdStatus::computeFor(CodeBlock* profiledBlock, ICStatusMap& map, unsigned bytecodeIndex, UniquedStringImpl* uid)
68 {
69     return computeFor(profiledBlock, map, bytecodeIndex, uid, hasBadCacheExitSite(profiledBlock, bytecodeIndex));
70 }
71
72 InByIdStatus InByIdStatus::computeFor(
73     CodeBlock* profiledBlock, ICStatusMap& baselineMap,
74     ICStatusContextStack& contextStack, CodeOrigin codeOrigin, UniquedStringImpl* uid)
75 {
76     ExitFlag didExit = hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex);
77     
78     for (ICStatusContext* context : contextStack) {
79         ICStatus status = context->get(codeOrigin);
80         
81         auto bless = [&] (const InByIdStatus& result) -> InByIdStatus {
82             if (!context->isInlined(codeOrigin)) {
83                 InByIdStatus baselineResult = computeFor(
84                     profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
85                 baselineResult.merge(result);
86                 return baselineResult;
87             }
88             if (didExit.isSet(ExitFromInlined))
89                 return InByIdStatus(TakesSlowPath);
90             return result;
91         };
92         
93 #if ENABLE(DFG_JIT)
94         if (status.stubInfo) {
95             InByIdStatus result;
96             {
97                 ConcurrentJSLocker locker(context->optimizedCodeBlock->m_lock);
98                 result = computeForStubInfoWithoutExitSiteFeedback(locker, status.stubInfo, uid);
99             }
100             if (result.isSet())
101                 return bless(result);
102         }
103 #endif
104         
105         if (status.inStatus)
106             return bless(*status.inStatus);
107     }
108     
109     return computeFor(profiledBlock, baselineMap, codeOrigin.bytecodeIndex, uid, didExit);
110 }
111 #endif // ENABLE(JIT)
112
113 #if ENABLE(DFG_JIT)
114 InByIdStatus InByIdStatus::computeForStubInfo(const ConcurrentJSLocker& locker, CodeBlock* profiledBlock, StructureStubInfo* stubInfo, CodeOrigin codeOrigin, UniquedStringImpl* uid)
115 {
116     InByIdStatus result = InByIdStatus::computeForStubInfoWithoutExitSiteFeedback(locker, stubInfo, uid);
117
118     if (!result.takesSlowPath() && hasBadCacheExitSite(profiledBlock, codeOrigin.bytecodeIndex))
119         return InByIdStatus(TakesSlowPath);
120     return result;
121 }
122
123 InByIdStatus InByIdStatus::computeForStubInfoWithoutExitSiteFeedback(const ConcurrentJSLocker&, StructureStubInfo* stubInfo, UniquedStringImpl* uid)
124 {
125     StubInfoSummary summary = StructureStubInfo::summary(stubInfo);
126     if (!isInlineable(summary))
127         return InByIdStatus(summary);
128     
129     // Finally figure out if we can derive an access strategy.
130     InByIdStatus result;
131     result.m_state = Simple;
132     switch (stubInfo->cacheType) {
133     case CacheType::Unset:
134         return InByIdStatus(NoInformation);
135
136     case CacheType::InByIdSelf: {
137         Structure* structure = stubInfo->u.byIdSelf.baseObjectStructure.get();
138         if (structure->takesSlowPathInDFGForImpureProperty())
139             return InByIdStatus(TakesSlowPath);
140         unsigned attributes;
141         InByIdVariant variant;
142         variant.m_offset = structure->getConcurrently(uid, attributes);
143         if (!isValidOffset(variant.m_offset))
144             return InByIdStatus(TakesSlowPath);
145         if (attributes & PropertyAttribute::CustomAccessorOrValue)
146             return InByIdStatus(TakesSlowPath);
147
148         variant.m_structureSet.add(structure);
149         bool didAppend = result.appendVariant(variant);
150         ASSERT_UNUSED(didAppend, didAppend);
151         return result;
152     }
153
154     case CacheType::Stub: {
155         PolymorphicAccess* list = stubInfo->u.stub;
156         for (unsigned listIndex = 0; listIndex < list->size(); ++listIndex) {
157             const AccessCase& access = list->at(listIndex);
158             if (access.viaProxy())
159                 return InByIdStatus(TakesSlowPath);
160
161             if (access.usesPolyProto())
162                 return InByIdStatus(TakesSlowPath);
163
164             Structure* structure = access.structure();
165             if (!structure) {
166                 // The null structure cases arise due to array.length. We have no way of creating a
167                 // InByIdVariant for those, and we don't really have to since the DFG handles those
168                 // cases in FixupPhase using value profiling. That's a bit awkward - we shouldn't
169                 // have to use value profiling to discover something that the AccessCase could have
170                 // told us. But, it works well enough. So, our only concern here is to not
171                 // crash on null structure.
172                 return InByIdStatus(TakesSlowPath);
173             }
174
175             ComplexGetStatus complexGetStatus = ComplexGetStatus::computeFor(structure, access.conditionSet(), uid);
176             switch (complexGetStatus.kind()) {
177             case ComplexGetStatus::ShouldSkip:
178                 continue;
179
180             case ComplexGetStatus::TakesSlowPath:
181                 return InByIdStatus(TakesSlowPath);
182
183             case ComplexGetStatus::Inlineable: {
184                 switch (access.type()) {
185                 case AccessCase::InHit:
186                 case AccessCase::InMiss:
187                     break;
188                 default:
189                     return InByIdStatus(TakesSlowPath);
190                 }
191
192                 InByIdVariant variant(
193                     StructureSet(structure), complexGetStatus.offset(),
194                     complexGetStatus.conditionSet());
195
196                 if (!result.appendVariant(variant))
197                     return InByIdStatus(TakesSlowPath);
198                 break;
199             }
200             }
201         }
202
203         return result;
204     }
205
206     default:
207         return InByIdStatus(TakesSlowPath);
208     }
209
210     RELEASE_ASSERT_NOT_REACHED();
211     return InByIdStatus();
212 }
213 #endif
214
215 void InByIdStatus::merge(const InByIdStatus& other)
216 {
217     if (other.m_state == NoInformation)
218         return;
219     
220     switch (m_state) {
221     case NoInformation:
222         *this = other;
223         return;
224         
225     case Simple:
226         if (other.m_state != Simple) {
227             *this = InByIdStatus(TakesSlowPath);
228             return;
229         }
230         for (const InByIdVariant& otherVariant : other.m_variants) {
231             if (!appendVariant(otherVariant)) {
232                 *this = InByIdStatus(TakesSlowPath);
233                 return;
234             }
235         }
236         return;
237         
238     case TakesSlowPath:
239         return;
240     }
241     
242     RELEASE_ASSERT_NOT_REACHED();
243 }
244
245 void InByIdStatus::filter(const StructureSet& structureSet)
246 {
247     if (m_state != Simple)
248         return;
249     filterICStatusVariants(m_variants, structureSet);
250     if (m_variants.isEmpty())
251         m_state = NoInformation;
252 }
253
254 void InByIdStatus::markIfCheap(SlotVisitor& visitor)
255 {
256     for (InByIdVariant& variant : m_variants)
257         variant.markIfCheap(visitor);
258 }
259
260 bool InByIdStatus::finalize()
261 {
262     for (InByIdVariant& variant : m_variants) {
263         if (!variant.finalize())
264             return false;
265     }
266     return true;
267 }
268
269 void InByIdStatus::dump(PrintStream& out) const
270 {
271     out.print("(");
272     switch (m_state) {
273     case NoInformation:
274         out.print("NoInformation");
275         break;
276     case Simple:
277         out.print("Simple");
278         break;
279     case TakesSlowPath:
280         out.print("TakesSlowPath");
281         break;
282     }
283     out.print(", ", listDump(m_variants), ")");
284 }
285
286 } // namespace JSC
287