Source/JavaScriptCore/bytecode/StructureStubInfo.cpp

   1 /*
   2  * Copyright (C) 2008, 2014-2016 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 "StructureStubInfo.h"
  28
  29 #include "JSObject.h"
  30 #include "PolymorphicAccess.h"
  31 #include "Repatch.h"
  32
  33 namespace JSC {
  34
  35 #if ENABLE(JIT)
  36 StructureStubInfo::StructureStubInfo(AccessType accessType)
  37     : callSiteIndex(UINT_MAX)
  38     , accessType(accessType)
  39     , cacheType(CacheType::Unset)
  40     , countdown(1) // For a totally clear stub, we'll patch it after the first execution.
  41     , repatchCount(0)
  42     , numberOfCoolDowns(0)
  43     , resetByGC(false)
  44     , tookSlowPath(false)
  45     , everConsidered(false)
  46 {
  47 }
  48
  49 StructureStubInfo::~StructureStubInfo()
  50 {
  51 }
  52
  53 void StructureStubInfo::initGetByIdSelf(CodeBlock* codeBlock, Structure* baseObjectStructure, PropertyOffset offset)
  54 {
  55     cacheType = CacheType::GetByIdSelf;
  56
  57     u.byIdSelf.baseObjectStructure.set(
  58         *codeBlock->vm(), codeBlock, baseObjectStructure);
  59     u.byIdSelf.offset = offset;
  60 }
  61
  62 void StructureStubInfo::initPutByIdReplace(CodeBlock* codeBlock, Structure* baseObjectStructure, PropertyOffset offset)
  63 {
  64     cacheType = CacheType::PutByIdReplace;
  65
  66     u.byIdSelf.baseObjectStructure.set(
  67         *codeBlock->vm(), codeBlock, baseObjectStructure);
  68     u.byIdSelf.offset = offset;
  69 }
  70
  71 void StructureStubInfo::initStub(CodeBlock*, std::unique_ptr<PolymorphicAccess> stub)
  72 {
  73     cacheType = CacheType::Stub;
  74     u.stub = stub.release();
  75 }
  76
  77 void StructureStubInfo::deref()
  78 {
  79     switch (cacheType) {
  80     case CacheType::Stub:
  81         delete u.stub;
  82         return;
  83     case CacheType::Unset:
  84     case CacheType::GetByIdSelf:
  85     case CacheType::PutByIdReplace:
  86         return;
  87     }
  88
  89     RELEASE_ASSERT_NOT_REACHED();
  90 }
  91
  92 void StructureStubInfo::aboutToDie()
  93 {
  94     switch (cacheType) {
  95     case CacheType::Stub:
  96         u.stub->aboutToDie();
  97         return;
  98     case CacheType::Unset:
  99     case CacheType::GetByIdSelf:
 100     case CacheType::PutByIdReplace:
 101         return;
 102     }
 103
 104     RELEASE_ASSERT_NOT_REACHED();
 105 }
 106
 107 AccessGenerationResult StructureStubInfo::addAccessCase(
 108     CodeBlock* codeBlock, const Identifier& ident, std::unique_ptr<AccessCase> accessCase)
 109 {
 110     VM& vm = *codeBlock->vm();
 111
 112     if (!accessCase)
 113         return AccessGenerationResult::MadeNoChanges;
 114
 115     if (cacheType == CacheType::Stub)
 116         return u.stub->regenerateWithCase(vm, codeBlock, *this, ident, WTFMove(accessCase));
 117
 118     std::unique_ptr<PolymorphicAccess> access = std::make_unique<PolymorphicAccess>();
 119
 120     Vector<std::unique_ptr<AccessCase>> accessCases;
 121
 122     std::unique_ptr<AccessCase> previousCase =
 123         AccessCase::fromStructureStubInfo(vm, codeBlock, *this);
 124     if (previousCase)
 125         accessCases.append(WTFMove(previousCase));
 126
 127     accessCases.append(WTFMove(accessCase));
 128
 129     AccessGenerationResult result =
 130         access->regenerateWithCases(vm, codeBlock, *this, ident, WTFMove(accessCases));
 131
 132     if (!result.generatedNewCode())
 133         return result;
 134
 135     initStub(codeBlock, WTFMove(access));
 136     return result;
 137 }
 138
 139 void StructureStubInfo::reset(CodeBlock* codeBlock)
 140 {
 141     if (cacheType == CacheType::Unset)
 142         return;
 143
 144     if (Options::verboseOSR()) {
 145         // This can be called from GC destructor calls, so we don't try to do a full dump
 146         // of the CodeBlock.
 147         dataLog("Clearing structure cache (kind ", static_cast<int>(accessType), ") in ", RawPointer(codeBlock), ".\n");
 148     }
 149
 150     switch (accessType) {
 151     case AccessType::Get:
 152         resetGetByID(codeBlock, *this);
 153         break;
 154     case AccessType::Put:
 155         resetPutByID(codeBlock, *this);
 156         break;
 157     case AccessType::In:
 158         resetIn(codeBlock, *this);
 159         break;
 160     }
 161
 162     deref();
 163     cacheType = CacheType::Unset;
 164 }
 165
 166 void StructureStubInfo::visitWeakReferences(CodeBlock* codeBlock)
 167 {
 168     VM& vm = *codeBlock->vm();
 169
 170     switch (cacheType) {
 171     case CacheType::GetByIdSelf:
 172     case CacheType::PutByIdReplace:
 173         if (Heap::isMarked(u.byIdSelf.baseObjectStructure.get()))
 174             return;
 175         break;
 176     case CacheType::Stub:
 177         if (u.stub->visitWeak(vm))
 178             return;
 179         break;
 180     default:
 181         return;
 182     }
 183
 184     reset(codeBlock);
 185     resetByGC = true;
 186 }
 187
 188 bool StructureStubInfo::containsPC(void* pc) const
 189 {
 190     if (cacheType != CacheType::Stub)
 191         return false;
 192     return u.stub->containsPC(pc);
 193 }
 194 #endif
 195
 196 } // namespace JSC