1  /*
  2   * Copyright (C) 2012-2017 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   *
  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   * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
 14   *     its contributors may be used to endorse or promote products derived
 15   *     from this software without specific prior written permission. 
 16   *
 17   * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 18   * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 19   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 20   * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 21   * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 22   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 23   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 24   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 25   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 26   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 27   */
 28  
 29  #include "config.h"
 30  #include "JSSegmentedVariableObject.h"
 31  
 32  #include "HeapAnalyzer.h"
 33  #include "JSCInlines.h"
 34  
 35  namespace JSC {
 36  
 37  const ClassInfo JSSegmentedVariableObject::s_info = { "SegmentedVariableObject", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSSegmentedVariableObject) };
 38  
 39  ScopeOffset JSSegmentedVariableObject::findVariableIndex(void* variableAddress)
 40  {
 41      auto locker = holdLock(cellLock());
 42      
 43      for (unsigned i = m_variables.size(); i--;) {
 44          if (&m_variables[i] != variableAddress)
 45              continue;
 46          return ScopeOffset(i);
 47      }
 48      CRASH();
 49      return ScopeOffset();
 50  }
 51  
 52  ScopeOffset JSSegmentedVariableObject::addVariables(unsigned numberOfVariablesToAdd, JSValue initialValue)
 53  {
 54      auto locker = holdLock(cellLock());
 55      
 56      size_t oldSize = m_variables.size();
 57      m_variables.grow(oldSize + numberOfVariablesToAdd);
 58      
 59      for (size_t i = numberOfVariablesToAdd; i--;)
 60          m_variables[oldSize + i].setWithoutWriteBarrier(initialValue);
 61      
 62      return ScopeOffset(oldSize);
 63  }
 64  
 65  void JSSegmentedVariableObject::visitChildren(JSCell* cell, SlotVisitor& slotVisitor)
 66  {
 67      JSSegmentedVariableObject* thisObject = jsCast<JSSegmentedVariableObject*>(cell);
 68      ASSERT_GC_OBJECT_INHERITS(thisObject, info());
 69      Base::visitChildren(thisObject, slotVisitor);
 70      
 71      // FIXME: We could avoid locking here if SegmentedVector was lock-free. It could be made lock-free
 72      // relatively easily.
 73      auto locker = holdLock(thisObject->cellLock());
 74      for (unsigned i = thisObject->m_variables.size(); i--;)
 75          slotVisitor.appendHidden(thisObject->m_variables[i]);
 76  }
 77  
 78  void JSSegmentedVariableObject::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
 79  {
 80      JSSegmentedVariableObject* thisObject = jsCast<JSSegmentedVariableObject*>(cell);
 81      Base::analyzeHeap(cell, analyzer);
 82  
 83      ConcurrentJSLocker locker(thisObject->symbolTable()->m_lock);
 84      SymbolTable::Map::iterator end = thisObject->symbolTable()->end(locker);
 85      for (SymbolTable::Map::iterator it = thisObject->symbolTable()->begin(locker); it != end; ++it) {
 86          SymbolTableEntry::Fast entry = it->value;
 87          ASSERT(!entry.isNull());
 88          ScopeOffset offset = entry.scopeOffset();
 89          if (!thisObject->isValidScopeOffset(offset))
 90              continue;
 91  
 92          JSValue toValue = thisObject->variableAt(offset).get();
 93          if (toValue && toValue.isCell())
 94              analyzer.analyzeVariableNameEdge(thisObject, toValue.asCell(), it->key.get());
 95      }
 96  }
 97  
 98  JSSegmentedVariableObject::JSSegmentedVariableObject(VM& vm, Structure* structure, JSScope* scope)
 99      : JSSymbolTableObject(vm, structure, scope)
100  {
101  }
102  
103  JSSegmentedVariableObject::~JSSegmentedVariableObject()
104  {
105  #ifndef NDEBUG
106      ASSERT(!m_alreadyDestroyed);
107      m_alreadyDestroyed = true;
108  #endif
109  }
110  
111  void JSSegmentedVariableObject::finishCreation(VM& vm)
112  {
113      Base::finishCreation(vm);
114      setSymbolTable(vm, SymbolTable::create(vm));
115  }
116  
117  } // namespace JSC
118