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 "CommonIdentifiers.h" 35 #include "FunctionConstructor.h" 36 #include "GetterSetter.h" 37 #include "Interpreter.h" 38 #include "JSActivation.h" 39 #include "JSAPIValueWrapper.h" 40 #include "JSArray.h" 41 #include "JSByteArray.h" 42 #include "JSClassRef.h" 43 #include "JSFunction.h" 44 #include "JSLock.h" 45 #include "JSNotAnObject.h" 46 #include "JSPropertyNameIterator.h" 47 #include "JSStaticScopeObject.h" 48 #include "Lexer.h" 49 #include "Lookup.h" 50 #include "Nodes.h" 51 #include "Parser.h" 52 53 #if ENABLE(JSC_MULTIPLE_THREADS) 54 #include <wtf/Threading.h> 55 #endif 56 57 #if PLATFORM(MAC) 58 #include "ProfilerServer.h" 59 #endif 60 61 using namespace WTF; 62 63 namespace JSC { 64 65 extern JSC_CONST_HASHTABLE HashTable arrayTable; 66 extern JSC_CONST_HASHTABLE HashTable jsonTable; 67 extern JSC_CONST_HASHTABLE HashTable dateTable; 68 extern JSC_CONST_HASHTABLE HashTable mathTable; 69 extern JSC_CONST_HASHTABLE HashTable numberTable; 70 extern JSC_CONST_HASHTABLE HashTable regExpTable; 71 extern JSC_CONST_HASHTABLE HashTable regExpConstructorTable; 72 extern JSC_CONST_HASHTABLE HashTable stringTable; 73 74 void* JSGlobalData::jsArrayVPtr; 75 void* JSGlobalData::jsByteArrayVPtr; 76 void* JSGlobalData::jsStringVPtr; 77 void* JSGlobalData::jsFunctionVPtr; 78 79 void JSGlobalData::storeVPtrs() 80 { 81 CollectorCell cell; 82 void* storage = &cell; 83 84 COMPILE_ASSERT(sizeof(JSArray) <= sizeof(CollectorCell), sizeof_JSArray_must_be_less_than_CollectorCell); 85 JSCell* jsArray = new (storage) JSArray(JSArray::createStructure(jsNull())); 86 JSGlobalData::jsArrayVPtr = jsArray->vptr(); 87 jsArray->~JSCell(); 88 89 COMPILE_ASSERT(sizeof(JSByteArray) <= sizeof(CollectorCell), sizeof_JSByteArray_must_be_less_than_CollectorCell); 90 JSCell* jsByteArray = new (storage) JSByteArray(JSByteArray::VPtrStealingHack); 91 JSGlobalData::jsByteArrayVPtr = jsByteArray->vptr(); 92 jsByteArray->~JSCell(); 93 94 COMPILE_ASSERT(sizeof(JSString) <= sizeof(CollectorCell), sizeof_JSString_must_be_less_than_CollectorCell); 95 JSCell* jsString = new (storage) JSString(JSString::VPtrStealingHack); 96 JSGlobalData::jsStringVPtr = jsString->vptr(); 97 jsString->~JSCell(); 98 99 COMPILE_ASSERT(sizeof(JSFunction) <= sizeof(CollectorCell), sizeof_JSFunction_must_be_less_than_CollectorCell); 100 JSCell* jsFunction = new (storage) JSFunction(JSFunction::createStructure(jsNull())); 101 JSGlobalData::jsFunctionVPtr = jsFunction->vptr(); 102 jsFunction->~JSCell(); 103 } 104 105 JSGlobalData::JSGlobalData(bool isShared) 106 : isSharedInstance(isShared) 107 , clientData(0) 108 , arrayTable(fastNew<HashTable>(JSC::arrayTable)) 109 , dateTable(fastNew<HashTable>(JSC::dateTable)) 110 , jsonTable(fastNew<HashTable>(JSC::jsonTable)) 111 , mathTable(fastNew<HashTable>(JSC::mathTable)) 112 , numberTable(fastNew<HashTable>(JSC::numberTable)) 113 , regExpTable(fastNew<HashTable>(JSC::regExpTable)) 114 , regExpConstructorTable(fastNew<HashTable>(JSC::regExpConstructorTable)) 115 , stringTable(fastNew<HashTable>(JSC::stringTable)) 116 , activationStructure(JSActivation::createStructure(jsNull())) 117 , interruptedExecutionErrorStructure(JSObject::createStructure(jsNull())) 118 , staticScopeStructure(JSStaticScopeObject::createStructure(jsNull())) 119 , stringStructure(JSString::createStructure(jsNull())) 120 , notAnObjectErrorStubStructure(JSNotAnObjectErrorStub::createStructure(jsNull())) 121 , notAnObjectStructure(JSNotAnObject::createStructure(jsNull())) 122 , propertyNameIteratorStructure(JSPropertyNameIterator::createStructure(jsNull())) 123 , getterSetterStructure(GetterSetter::createStructure(jsNull())) 124 , apiWrapperStructure(JSAPIValueWrapper::createStructure(jsNull())) 125 , dummyMarkableCellStructure(JSCell::createDummyStructure()) 126 #if USE(JSVALUE32) 127 , numberStructure(JSNumberCell::createStructure(jsNull())) 128 #endif 129 , identifierTable(createIdentifierTable()) 130 , propertyNames(new CommonIdentifiers(this)) 131 , emptyList(new MarkedArgumentBuffer) 132 , lexer(new Lexer(this)) 133 , parser(new Parser) 134 , interpreter(new Interpreter) 135 #if ENABLE(JIT) 136 , jitStubs(this) 137 #endif 138 , heap(this) 139 , initializingLazyNumericCompareFunction(false) 140 , head(0) 141 , dynamicGlobalObject(0) 142 , functionCodeBlockBeingReparsed(0) 143 , firstStringifierToMark(0) 144 , markStack(jsArrayVPtr) 145 , cachedUTCOffset(NaN) 146 , weakRandom(static_cast<int>(currentTime())) 147 #ifndef NDEBUG 148 , mainThreadOnly(false) 149 #endif 150 { 151 #if PLATFORM(MAC) 152 startProfilerServerIfNeeded(); 153 #endif 154 } 155 156 JSGlobalData::~JSGlobalData() 157 { 158 // By the time this is destroyed, heap.destroy() must already have been called. 159 160 delete interpreter; 161 #ifndef NDEBUG 162 // Zeroing out to make the behavior more predictable when someone attempts to use a deleted instance. 163 interpreter = 0; 164 #endif 165 166 arrayTable->deleteTable(); 167 dateTable->deleteTable(); 168 jsonTable->deleteTable(); 169 mathTable->deleteTable(); 170 numberTable->deleteTable(); 171 regExpTable->deleteTable(); 172 regExpConstructorTable->deleteTable(); 173 stringTable->deleteTable(); 174 175 fastDelete(const_cast<HashTable*>(arrayTable)); 176 fastDelete(const_cast<HashTable*>(dateTable)); 177 fastDelete(const_cast<HashTable*>(jsonTable)); 178 fastDelete(const_cast<HashTable*>(mathTable)); 179 fastDelete(const_cast<HashTable*>(numberTable)); 180 fastDelete(const_cast<HashTable*>(regExpTable)); 181 fastDelete(const_cast<HashTable*>(regExpConstructorTable)); 182 fastDelete(const_cast<HashTable*>(stringTable)); 183 184 delete parser; 185 delete lexer; 186 187 deleteAllValues(opaqueJSClassData); 188 189 delete emptyList; 190 191 delete propertyNames; 192 deleteIdentifierTable(identifierTable); 193 194 delete clientData; 195 } 196 197 PassRefPtr<JSGlobalData> JSGlobalData::createNonDefault() 198 { 199 return adoptRef(new JSGlobalData(false)); 200 } 201 202 PassRefPtr<JSGlobalData> JSGlobalData::create() 203 { 204 JSGlobalData* globalData = new JSGlobalData(false); 205 setDefaultIdentifierTable(globalData->identifierTable); 206 setCurrentIdentifierTable(globalData->identifierTable); 207 return adoptRef(globalData); 208 } 209 210 PassRefPtr<JSGlobalData> JSGlobalData::createLeaked() 211 { 212 Structure::startIgnoringLeaks(); 213 RefPtr<JSGlobalData> data = create(); 214 Structure::stopIgnoringLeaks(); 215 return data.release(); 216 } 217 218 bool JSGlobalData::sharedInstanceExists() 219 { 220 return sharedInstanceInternal(); 221 } 222 223 JSGlobalData& JSGlobalData::sharedInstance() 224 { 225 JSGlobalData*& instance = sharedInstanceInternal(); 226 if (!instance) { 227 instance = new JSGlobalData(true); 228 #if ENABLE(JSC_MULTIPLE_THREADS) 229 instance->makeUsableFromMultipleThreads(); 230 #endif 231 } 232 return *instance; 233 } 234 235 JSGlobalData*& JSGlobalData::sharedInstanceInternal() 236 { 237 ASSERT(JSLock::currentThreadIsHoldingLock()); 238 static JSGlobalData* sharedInstance; 239 return sharedInstance; 240 } 241 242 // FIXME: We can also detect forms like v1 < v2 ? -1 : 0, reverse comparison, etc. 243 const Vector<Instruction>& JSGlobalData::numericCompareFunction(ExecState* exec) 244 { 245 if (!lazyNumericCompareFunction.size() && !initializingLazyNumericCompareFunction) { 246 initializingLazyNumericCompareFunction = true; 247 RefPtr<FunctionExecutable> function = FunctionExecutable::fromGlobalCode(Identifier(exec, "numericCompare"), exec, 0, makeSource(UString("(function (v1, v2) { return v1 - v2; })")), 0, 0); 248 lazyNumericCompareFunction = function->bytecode(exec, exec->scopeChain()).instructions(); 249 initializingLazyNumericCompareFunction = false; 250 } 251 252 return lazyNumericCompareFunction; 253 } 254 255 JSGlobalData::ClientData::~ClientData() 256 { 257 } 258 259 void JSGlobalData::resetDateCache() 260 { 261 cachedUTCOffset = NaN; 262 dstOffsetCache.reset(); 263 cachedDateString = UString(); 264 dateInstanceCache.reset(); 265 } 266 267 void JSGlobalData::startSampling() 268 { 269 interpreter->startSampling(); 270 } 271 272 void JSGlobalData::stopSampling() 273 { 274 interpreter->stopSampling(); 275 } 276 277 void JSGlobalData::dumpSampleData(ExecState* exec) 278 { 279 interpreter->dumpSampleData(exec); 280 } 281 282 } // namespace JSC 283
