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 #ifndef JSGlobalData_h 30 #define JSGlobalData_h 31 32 #include <wtf/Forward.h> 33 #include <wtf/HashMap.h> 34 #include <wtf/RefCounted.h> 35 #include "Collector.h" 36 #include "ExecutableAllocator.h" 37 #include "SmallStrings.h" 38 #include "JSValue.h" 39 40 struct OpaqueJSClass; 41 struct OpaqueJSClassContextData; 42 43 namespace JSC { 44 45 class ArgList; 46 class CommonIdentifiers; 47 class Heap; 48 class IdentifierTable; 49 class Instruction; 50 class Interpreter; 51 class JSGlobalObject; 52 class JSObject; 53 class Lexer; 54 class Parser; 55 class ParserRefCounted; 56 class ScopeNode; 57 class Structure; 58 class UString; 59 struct HashTable; 60 61 class JSGlobalData : public RefCounted<JSGlobalData> { 62 public: 63 static bool sharedInstanceExists(); 64 static JSGlobalData& sharedInstance(); 65 66 static PassRefPtr<JSGlobalData> create(); 67 static PassRefPtr<JSGlobalData> createLeaked(); 68 ~JSGlobalData(); 69 70 #if ENABLE(JSC_MULTIPLE_THREADS) 71 // Will start tracking threads that use the heap, which is resource-heavy. makeUsableFromMultipleThreads()72 void makeUsableFromMultipleThreads() { heap.makeUsableFromMultipleThreads(); } 73 #endif 74 75 const Vector<Instruction>& numericCompareFunction(ExecState*); 76 Vector<Instruction> lazyNumericCompareFunction; 77 bool initializingLazyNumericCompareFunction; 78 79 Interpreter* interpreter; 80 81 JSValuePtr exception; 82 #if ENABLE(JIT) 83 void* exceptionLocation; 84 #endif 85 86 const HashTable* arrayTable; 87 const HashTable* dateTable; 88 const HashTable* mathTable; 89 const HashTable* numberTable; 90 const HashTable* regExpTable; 91 const HashTable* regExpConstructorTable; 92 const HashTable* stringTable; 93 94 RefPtr<Structure> activationStructure; 95 RefPtr<Structure> interruptedExecutionErrorStructure; 96 RefPtr<Structure> staticScopeStructure; 97 RefPtr<Structure> stringStructure; 98 RefPtr<Structure> notAnObjectErrorStubStructure; 99 RefPtr<Structure> notAnObjectStructure; 100 #if !USE(ALTERNATE_JSIMMEDIATE) 101 RefPtr<Structure> numberStructure; 102 #endif 103 104 IdentifierTable* identifierTable; 105 CommonIdentifiers* propertyNames; 106 const ArgList* emptyList; // Lists are supposed to be allocated on the stack to have their elements properly marked, which is not the case here - but this list has nothing to mark. 107 108 SmallStrings smallStrings; 109 110 HashMap<OpaqueJSClass*, OpaqueJSClassContextData*> opaqueJSClassData; 111 112 HashSet<ParserRefCounted*>* newParserObjects; 113 HashCountedSet<ParserRefCounted*>* parserObjectExtraRefCounts; 114 115 Lexer* lexer; 116 Parser* parser; 117 118 JSGlobalObject* head; 119 JSGlobalObject* dynamicGlobalObject; 120 121 bool isSharedInstance; 122 123 struct ClientData { 124 virtual ~ClientData() = 0; 125 }; 126 127 ClientData* clientData; 128 129 HashSet<JSObject*> arrayVisitedElements; 130 131 ScopeNode* scopeNodeBeingReparsed; 132 133 Heap heap; 134 #if ENABLE(ASSEMBLER) poolForSize(size_t n)135 PassRefPtr<ExecutablePool> poolForSize(size_t n) { return m_executableAllocator.poolForSize(n); } 136 #endif 137 private: 138 JSGlobalData(bool isShared = false); 139 #if ENABLE(ASSEMBLER) 140 ExecutableAllocator m_executableAllocator; 141 #endif 142 143 static JSGlobalData*& sharedInstanceInternal(); 144 }; 145 146 } 147 148 #endif 149