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::CustomAccessorOrValue)
 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