runtime/JSGlobalData.cpp

   1 /*
   2  * Copyright (C) 2008 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 Computer, 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 "JSGlobalData.h"
  31
  32 #include "ArgList.h"
  33 #include "Collector.h"
  34 #include "CollectorHeapIterator.h"
  35 #include "CommonIdentifiers.h"
  36 #include "FunctionConstructor.h"
  37 #include "GetterSetter.h"
  38 #include "Interpreter.h"
  39 #include "JSActivation.h"
  40 #include "JSAPIValueWrapper.h"
  41 #include "JSArray.h"
  42 #include "JSByteArray.h"
  43 #include "JSClassRef.h"
  44 #include "JSFunction.h"
  45 #include "JSLock.h"
  46 #include "JSNotAnObject.h"
  47 #include "JSPropertyNameIterator.h"
  48 #include "JSStaticScopeObject.h"
  49 #include "Lexer.h"
  50 #include "Lookup.h"
  51 #include "Nodes.h"
  52 #include "Parser.h"
  53 #include "RegExpCache.h"
  54 #include <wtf/WTFThreadData.h>
  55
  56 #if ENABLE(JSC_MULTIPLE_THREADS)
  57 #include <wtf/Threading.h>
  58 #endif
  59
  60 #if PLATFORM(MAC)
  61 #include "ProfilerServer.h"
  62 #include <CoreFoundation/CoreFoundation.h>
  63 #endif
  64
  65 using namespace WTF;
  66
  67 namespace JSC {
  68
  69 extern JSC_CONST_HASHTABLE HashTable arrayTable;
  70 extern JSC_CONST_HASHTABLE HashTable jsonTable;
  71 extern JSC_CONST_HASHTABLE HashTable dateTable;
  72 extern JSC_CONST_HASHTABLE HashTable mathTable;
  73 extern JSC_CONST_HASHTABLE HashTable numberTable;
  74 extern JSC_CONST_HASHTABLE HashTable regExpTable;
  75 extern JSC_CONST_HASHTABLE HashTable regExpConstructorTable;
  76 extern JSC_CONST_HASHTABLE HashTable stringTable;
  77
  78 void* JSGlobalData::jsArrayVPtr;
  79 void* JSGlobalData::jsByteArrayVPtr;
  80 void* JSGlobalData::jsStringVPtr;
  81 void* JSGlobalData::jsFunctionVPtr;
  82
  83 void JSGlobalData::storeVPtrs()
  84 {
  85     CollectorCell cell;
  86     void* storage = &cell;
  87
  88     COMPILE_ASSERT(sizeof(JSArray) <= sizeof(CollectorCell), sizeof_JSArray_must_be_less_than_CollectorCell);
  89     JSCell* jsArray = new (storage) JSArray(JSArray::createStructure(jsNull()));
  90     JSGlobalData::jsArrayVPtr = jsArray->vptr();
  91     jsArray->~JSCell();
  92
  93     COMPILE_ASSERT(sizeof(JSByteArray) <= sizeof(CollectorCell), sizeof_JSByteArray_must_be_less_than_CollectorCell);
  94     JSCell* jsByteArray = new (storage) JSByteArray(JSByteArray::VPtrStealingHack);
  95     JSGlobalData::jsByteArrayVPtr = jsByteArray->vptr();
  96     jsByteArray->~JSCell();
  97
  98     COMPILE_ASSERT(sizeof(JSString) <= sizeof(CollectorCell), sizeof_JSString_must_be_less_than_CollectorCell);
  99     JSCell* jsString = new (storage) JSString(JSString::VPtrStealingHack);
 100     JSGlobalData::jsStringVPtr = jsString->vptr();
 101     jsString->~JSCell();
 102
 103     COMPILE_ASSERT(sizeof(JSFunction) <= sizeof(CollectorCell), sizeof_JSFunction_must_be_less_than_CollectorCell);
 104     JSCell* jsFunction = new (storage) JSFunction(JSFunction::createStructure(jsNull()));
 105     JSGlobalData::jsFunctionVPtr = jsFunction->vptr();
 106     jsFunction->~JSCell();
 107 }
 108
 109 JSGlobalData::JSGlobalData(GlobalDataType globalDataType, ThreadStackType threadStackType)
 110     : globalDataType(globalDataType)
 111     , clientData(0)
 112     , arrayTable(fastNew<HashTable>(JSC::arrayTable))
 113     , dateTable(fastNew<HashTable>(JSC::dateTable))
 114     , jsonTable(fastNew<HashTable>(JSC::jsonTable))
 115     , mathTable(fastNew<HashTable>(JSC::mathTable))
 116     , numberTable(fastNew<HashTable>(JSC::numberTable))
 117     , regExpTable(fastNew<HashTable>(JSC::regExpTable))
 118     , regExpConstructorTable(fastNew<HashTable>(JSC::regExpConstructorTable))
 119     , stringTable(fastNew<HashTable>(JSC::stringTable))
 120     , activationStructure(JSActivation::createStructure(jsNull()))
 121     , interruptedExecutionErrorStructure(JSObject::createStructure(jsNull()))
 122     , terminatedExecutionErrorStructure(JSObject::createStructure(jsNull()))
 123     , staticScopeStructure(JSStaticScopeObject::createStructure(jsNull()))
 124     , stringStructure(JSString::createStructure(jsNull()))
 125     , notAnObjectErrorStubStructure(JSNotAnObjectErrorStub::createStructure(jsNull()))
 126     , notAnObjectStructure(JSNotAnObject::createStructure(jsNull()))
 127     , propertyNameIteratorStructure(JSPropertyNameIterator::createStructure(jsNull()))
 128     , getterSetterStructure(GetterSetter::createStructure(jsNull()))
 129     , apiWrapperStructure(JSAPIValueWrapper::createStructure(jsNull()))
 130     , dummyMarkableCellStructure(JSCell::createDummyStructure())
 131 #if USE(JSVALUE32)
 132     , numberStructure(JSNumberCell::createStructure(jsNull()))
 133 #endif
 134     , identifierTable(globalDataType == Default ? wtfThreadData().currentIdentifierTable() : createIdentifierTable())
 135     , propertyNames(new CommonIdentifiers(this))
 136     , emptyList(new MarkedArgumentBuffer)
 137     , lexer(new Lexer(this))
 138     , parser(new Parser)
 139     , interpreter(new Interpreter)
 140     , heap(this)
 141     , initializingLazyNumericCompareFunction(false)
 142     , head(0)
 143     , dynamicGlobalObject(0)
 144     , functionCodeBlockBeingReparsed(0)
 145     , firstStringifierToMark(0)
 146     , markStack(jsArrayVPtr)
 147     , cachedUTCOffset(NaN)
 148     , maxReentryDepth(threadStackType == ThreadStackTypeSmall ? MaxSmallThreadReentryDepth : MaxLargeThreadReentryDepth)
 149     , m_regExpCache(new RegExpCache(this))
 150 #ifndef NDEBUG
 151     , exclusiveThread(0)
 152 #endif
 153 {
 154 #if PLATFORM(MAC)
 155     startProfilerServerIfNeeded();
 156 #endif
 157 #if ENABLE(JIT) && ENABLE(INTERPRETER)
 158 #if PLATFORM(CF)
 159     CFStringRef canUseJITKey = CFStringCreateWithCString(0 , "JavaScriptCoreUseJIT", kCFStringEncodingMacRoman);
 160     CFBooleanRef canUseJIT = (CFBooleanRef)CFPreferencesCopyAppValue(canUseJITKey, kCFPreferencesCurrentApplication);
 161     if (canUseJIT) {
 162         m_canUseJIT = kCFBooleanTrue == canUseJIT;
 163         CFRelease(canUseJIT);
 164     } else
 165         m_canUseJIT = !getenv("JavaScriptCoreUseJIT");
 166     CFRelease(canUseJITKey);
 167 #elif OS(UNIX)
 168     m_canUseJIT = !getenv("JavaScriptCoreUseJIT");
 169 #else
 170     m_canUseJIT = true;
 171 #endif
 172 #endif
 173 #if ENABLE(JIT)
 174 #if ENABLE(INTERPRETER)
 175     if (m_canUseJIT)
 176         m_canUseJIT = executableAllocator.isValid();
 177 #endif
 178     jitStubs.set(new JITThunks(this));
 179 #endif
 180 }
 181
 182 JSGlobalData::~JSGlobalData()
 183 {
 184     // By the time this is destroyed, heap.destroy() must already have been called.
 185
 186     delete interpreter;
 187 #ifndef NDEBUG
 188     // Zeroing out to make the behavior more predictable when someone attempts to use a deleted instance.
 189     interpreter = 0;
 190 #endif
 191
 192     arrayTable->deleteTable();
 193     dateTable->deleteTable();
 194     jsonTable->deleteTable();
 195     mathTable->deleteTable();
 196     numberTable->deleteTable();
 197     regExpTable->deleteTable();
 198     regExpConstructorTable->deleteTable();
 199     stringTable->deleteTable();
 200
 201     fastDelete(const_cast<HashTable*>(arrayTable));
 202     fastDelete(const_cast<HashTable*>(dateTable));
 203     fastDelete(const_cast<HashTable*>(jsonTable));
 204     fastDelete(const_cast<HashTable*>(mathTable));
 205     fastDelete(const_cast<HashTable*>(numberTable));
 206     fastDelete(const_cast<HashTable*>(regExpTable));
 207     fastDelete(const_cast<HashTable*>(regExpConstructorTable));
 208     fastDelete(const_cast<HashTable*>(stringTable));
 209
 210     delete parser;
 211     delete lexer;
 212
 213     deleteAllValues(opaqueJSClassData);
 214
 215     delete emptyList;
 216
 217     delete propertyNames;
 218     if (globalDataType != Default)
 219         deleteIdentifierTable(identifierTable);
 220
 221     delete clientData;
 222     delete m_regExpCache;
 223 }
 224
 225 PassRefPtr<JSGlobalData> JSGlobalData::createContextGroup(ThreadStackType type)
 226 {
 227     return adoptRef(new JSGlobalData(APIContextGroup, type));
 228 }
 229
 230 PassRefPtr<JSGlobalData> JSGlobalData::create(ThreadStackType type)
 231 {
 232     return adoptRef(new JSGlobalData(Default, type));
 233 }
 234
 235 PassRefPtr<JSGlobalData> JSGlobalData::createLeaked(ThreadStackType type)
 236 {
 237     Structure::startIgnoringLeaks();
 238     RefPtr<JSGlobalData> data = create(type);
 239     Structure::stopIgnoringLeaks();
 240     return data.release();
 241 }
 242
 243 bool JSGlobalData::sharedInstanceExists()
 244 {
 245     return sharedInstanceInternal();
 246 }
 247
 248 JSGlobalData& JSGlobalData::sharedInstance()
 249 {
 250     JSGlobalData*& instance = sharedInstanceInternal();
 251     if (!instance) {
 252         instance = new JSGlobalData(APIShared, ThreadStackTypeSmall);
 253 #if ENABLE(JSC_MULTIPLE_THREADS)
 254         instance->makeUsableFromMultipleThreads();
 255 #endif
 256     }
 257     return *instance;
 258 }
 259
 260 JSGlobalData*& JSGlobalData::sharedInstanceInternal()
 261 {
 262     ASSERT(JSLock::currentThreadIsHoldingLock());
 263     static JSGlobalData* sharedInstance;
 264     return sharedInstance;
 265 }
 266
 267 // FIXME: We can also detect forms like v1 < v2 ? -1 : 0, reverse comparison, etc.
 268 const Vector<Instruction>& JSGlobalData::numericCompareFunction(ExecState* exec)
 269 {
 270     if (!lazyNumericCompareFunction.size() && !initializingLazyNumericCompareFunction) {
 271         initializingLazyNumericCompareFunction = true;
 272         RefPtr<FunctionExecutable> function = FunctionExecutable::fromGlobalCode(Identifier(exec, "numericCompare"), exec, 0, makeSource(UString("(function (v1, v2) { return v1 - v2; })")), 0, 0);
 273         lazyNumericCompareFunction = function->bytecode(exec, exec->scopeChain()).instructions();
 274         initializingLazyNumericCompareFunction = false;
 275     }
 276
 277     return lazyNumericCompareFunction;
 278 }
 279
 280 JSGlobalData::ClientData::~ClientData()
 281 {
 282 }
 283
 284 void JSGlobalData::resetDateCache()
 285 {
 286     cachedUTCOffset = NaN;
 287     dstOffsetCache.reset();
 288     cachedDateString = UString();
 289     dateInstanceCache.reset();
 290 }
 291
 292 void JSGlobalData::startSampling()
 293 {
 294     interpreter->startSampling();
 295 }
 296
 297 void JSGlobalData::stopSampling()
 298 {
 299     interpreter->stopSampling();
 300 }
 301
 302 void JSGlobalData::dumpSampleData(ExecState* exec)
 303 {
 304     interpreter->dumpSampleData(exec);
 305 }
 306
 307 void JSGlobalData::recompileAllJSFunctions()
 308 {
 309     // If JavaScript is running, it's not safe to recompile, since we'll end
 310     // up throwing away code that is live on the stack.
 311     ASSERT(!dynamicGlobalObject);
 312
 313     LiveObjectIterator it = heap.primaryHeapBegin();
 314     LiveObjectIterator heapEnd = heap.primaryHeapEnd();
 315     for ( ; it != heapEnd; ++it) {
 316         if ((*it)->inherits(&JSFunction::info)) {
 317             JSFunction* function = asFunction(*it);
 318             if (!function->executable()->isHostFunction())
 319                 function->jsExecutable()->recompile();
 320         }
 321     }
 322 }
 323
 324 } // namespace JSC