runtime/JSGlobalObject.h

   1 /*
   2  *  Copyright (C) 2007 Eric Seidel <eric@webkit.org>
   3  *  Copyright (C) 2007, 2008, 2009 Apple Inc. All rights reserved.
   4  *
   5  *  This library is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU Library General Public
   7  *  License as published by the Free Software Foundation; either
   8  *  version 2 of the License, or (at your option) any later version.
   9  *
  10  *  This library is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  Library General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU Library General Public License
  16  *  along with this library; see the file COPYING.LIB.  If not, write to
  17  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18  *  Boston, MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #ifndef JSGlobalObject_h
  23 #define JSGlobalObject_h
  24
  25 #include "JSArray.h"
  26 #include "JSGlobalData.h"
  27 #include "JSVariableObject.h"
  28 #include "JSWeakObjectMapRefInternal.h"
  29 #include "NativeFunctionWrapper.h"
  30 #include "NumberPrototype.h"
  31 #include "StringPrototype.h"
  32 #include <wtf/HashSet.h>
  33 #include <wtf/OwnPtr.h>
  34 #include <wtf/RandomNumber.h>
  35
  36 namespace JSC {
  37
  38     class ArrayPrototype;
  39     class BooleanPrototype;
  40     class DatePrototype;
  41     class Debugger;
  42     class ErrorConstructor;
  43     class FunctionPrototype;
  44     class GlobalCodeBlock;
  45     class GlobalEvalFunction;
  46     class NativeErrorConstructor;
  47     class ProgramCodeBlock;
  48     class PrototypeFunction;
  49     class RegExpConstructor;
  50     class RegExpPrototype;
  51     class RegisterFile;
  52
  53     struct ActivationStackNode;
  54     struct HashTable;
  55
  56     typedef Vector<ExecState*, 16> ExecStateStack;
  57
  58     class JSGlobalObject : public JSVariableObject {
  59     protected:
  60         using JSVariableObject::JSVariableObjectData;
  61         typedef HashSet<RefPtr<OpaqueJSWeakObjectMap> > WeakMapSet;
  62
  63         struct JSGlobalObjectData : public JSVariableObjectData {
  64             // We use an explicit destructor function pointer instead of a
  65             // virtual destructor because we want to avoid adding a vtable
  66             // pointer to this struct. Adding a vtable pointer would force the
  67             // compiler to emit costly pointer fixup code when casting from
  68             // JSVariableObjectData* to JSGlobalObjectData*.
  69             typedef void (*Destructor)(void*);
  70
  71             JSGlobalObjectData(Destructor destructor)
  72                 : JSVariableObjectData(&symbolTable, 0)
  73                 , destructor(destructor)
  74                 , registerArraySize(0)
  75                 , globalScopeChain(NoScopeChain())
  76                 , regExpConstructor(0)
  77                 , errorConstructor(0)
  78                 , evalErrorConstructor(0)
  79                 , rangeErrorConstructor(0)
  80                 , referenceErrorConstructor(0)
  81                 , syntaxErrorConstructor(0)
  82                 , typeErrorConstructor(0)
  83                 , URIErrorConstructor(0)
  84                 , evalFunction(0)
  85                 , callFunction(0)
  86                 , applyFunction(0)
  87                 , objectPrototype(0)
  88                 , functionPrototype(0)
  89                 , arrayPrototype(0)
  90                 , booleanPrototype(0)
  91                 , stringPrototype(0)
  92                 , numberPrototype(0)
  93                 , datePrototype(0)
  94                 , regExpPrototype(0)
  95                 , methodCallDummy(0)
  96                 , weakRandom(static_cast<unsigned>(randomNumber() * (std::numeric_limits<unsigned>::max() + 1.0)))
  97             {
  98             }
  99
 100             Destructor destructor;
 101
 102             size_t registerArraySize;
 103
 104             JSGlobalObject* next;
 105             JSGlobalObject* prev;
 106
 107             Debugger* debugger;
 108
 109             ScopeChain globalScopeChain;
 110             Register globalCallFrame[RegisterFile::CallFrameHeaderSize];
 111
 112             int recursion;
 113
 114             RegExpConstructor* regExpConstructor;
 115             ErrorConstructor* errorConstructor;
 116             NativeErrorConstructor* evalErrorConstructor;
 117             NativeErrorConstructor* rangeErrorConstructor;
 118             NativeErrorConstructor* referenceErrorConstructor;
 119             NativeErrorConstructor* syntaxErrorConstructor;
 120             NativeErrorConstructor* typeErrorConstructor;
 121             NativeErrorConstructor* URIErrorConstructor;
 122
 123             GlobalEvalFunction* evalFunction;
 124             NativeFunctionWrapper* callFunction;
 125             NativeFunctionWrapper* applyFunction;
 126
 127             ObjectPrototype* objectPrototype;
 128             FunctionPrototype* functionPrototype;
 129             ArrayPrototype* arrayPrototype;
 130             BooleanPrototype* booleanPrototype;
 131             StringPrototype* stringPrototype;
 132             NumberPrototype* numberPrototype;
 133             DatePrototype* datePrototype;
 134             RegExpPrototype* regExpPrototype;
 135
 136             JSObject* methodCallDummy;
 137
 138             RefPtr<Structure> argumentsStructure;
 139             RefPtr<Structure> arrayStructure;
 140             RefPtr<Structure> booleanObjectStructure;
 141             RefPtr<Structure> callbackConstructorStructure;
 142             RefPtr<Structure> callbackFunctionStructure;
 143             RefPtr<Structure> callbackObjectStructure;
 144             RefPtr<Structure> dateStructure;
 145             RefPtr<Structure> emptyObjectStructure;
 146             RefPtr<Structure> errorStructure;
 147             RefPtr<Structure> functionStructure;
 148             RefPtr<Structure> numberObjectStructure;
 149             RefPtr<Structure> prototypeFunctionStructure;
 150             RefPtr<Structure> regExpMatchesArrayStructure;
 151             RefPtr<Structure> regExpStructure;
 152             RefPtr<Structure> stringObjectStructure;
 153
 154             SymbolTable symbolTable;
 155             unsigned profileGroup;
 156
 157             RefPtr<JSGlobalData> globalData;
 158
 159             HashSet<GlobalCodeBlock*> codeBlocks;
 160             WeakMapSet weakMaps;
 161             WeakRandom weakRandom;
 162         };
 163
 164     public:
 165         void* operator new(size_t, JSGlobalData*);
 166
 167         explicit JSGlobalObject()
 168             : JSVariableObject(JSGlobalObject::createStructure(jsNull()), new JSGlobalObjectData(destroyJSGlobalObjectData))
 169         {
 170             init(this);
 171         }
 172
 173     protected:
 174         JSGlobalObject(NonNullPassRefPtr<Structure> structure, JSGlobalObjectData* data, JSObject* thisValue)
 175             : JSVariableObject(structure, data)
 176         {
 177             init(thisValue);
 178         }
 179
 180     public:
 181         virtual ~JSGlobalObject();
 182
 183         virtual void markChildren(MarkStack&);
 184
 185         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 186         virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
 187         virtual bool hasOwnPropertyForWrite(ExecState*, const Identifier&);
 188         virtual void put(ExecState*, const Identifier&, JSValue, PutPropertySlot&);
 189         virtual void putWithAttributes(ExecState*, const Identifier& propertyName, JSValue value, unsigned attributes);
 190
 191         virtual void defineGetter(ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
 192         virtual void defineSetter(ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
 193
 194         // Linked list of all global objects that use the same JSGlobalData.
 195         JSGlobalObject*& head() { return d()->globalData->head; }
 196         JSGlobalObject* next() { return d()->next; }
 197
 198         // The following accessors return pristine values, even if a script
 199         // replaces the global object's associated property.
 200
 201         RegExpConstructor* regExpConstructor() const { return d()->regExpConstructor; }
 202
 203         ErrorConstructor* errorConstructor() const { return d()->errorConstructor; }
 204         NativeErrorConstructor* evalErrorConstructor() const { return d()->evalErrorConstructor; }
 205         NativeErrorConstructor* rangeErrorConstructor() const { return d()->rangeErrorConstructor; }
 206         NativeErrorConstructor* referenceErrorConstructor() const { return d()->referenceErrorConstructor; }
 207         NativeErrorConstructor* syntaxErrorConstructor() const { return d()->syntaxErrorConstructor; }
 208         NativeErrorConstructor* typeErrorConstructor() const { return d()->typeErrorConstructor; }
 209         NativeErrorConstructor* URIErrorConstructor() const { return d()->URIErrorConstructor; }
 210
 211         GlobalEvalFunction* evalFunction() const { return d()->evalFunction; }
 212
 213         ObjectPrototype* objectPrototype() const { return d()->objectPrototype; }
 214         FunctionPrototype* functionPrototype() const { return d()->functionPrototype; }
 215         ArrayPrototype* arrayPrototype() const { return d()->arrayPrototype; }
 216         BooleanPrototype* booleanPrototype() const { return d()->booleanPrototype; }
 217         StringPrototype* stringPrototype() const { return d()->stringPrototype; }
 218         NumberPrototype* numberPrototype() const { return d()->numberPrototype; }
 219         DatePrototype* datePrototype() const { return d()->datePrototype; }
 220         RegExpPrototype* regExpPrototype() const { return d()->regExpPrototype; }
 221
 222         JSObject* methodCallDummy() const { return d()->methodCallDummy; }
 223
 224         Structure* argumentsStructure() const { return d()->argumentsStructure.get(); }
 225         Structure* arrayStructure() const { return d()->arrayStructure.get(); }
 226         Structure* booleanObjectStructure() const { return d()->booleanObjectStructure.get(); }
 227         Structure* callbackConstructorStructure() const { return d()->callbackConstructorStructure.get(); }
 228         Structure* callbackFunctionStructure() const { return d()->callbackFunctionStructure.get(); }
 229         Structure* callbackObjectStructure() const { return d()->callbackObjectStructure.get(); }
 230         Structure* dateStructure() const { return d()->dateStructure.get(); }
 231         Structure* emptyObjectStructure() const { return d()->emptyObjectStructure.get(); }
 232         Structure* errorStructure() const { return d()->errorStructure.get(); }
 233         Structure* functionStructure() const { return d()->functionStructure.get(); }
 234         Structure* numberObjectStructure() const { return d()->numberObjectStructure.get(); }
 235         Structure* prototypeFunctionStructure() const { return d()->prototypeFunctionStructure.get(); }
 236         Structure* regExpMatchesArrayStructure() const { return d()->regExpMatchesArrayStructure.get(); }
 237         Structure* regExpStructure() const { return d()->regExpStructure.get(); }
 238         Structure* stringObjectStructure() const { return d()->stringObjectStructure.get(); }
 239
 240         void setProfileGroup(unsigned value) { d()->profileGroup = value; }
 241         unsigned profileGroup() const { return d()->profileGroup; }
 242
 243         Debugger* debugger() const { return d()->debugger; }
 244         void setDebugger(Debugger* debugger) { d()->debugger = debugger; }
 245
 246         virtual bool supportsProfiling() const { return false; }
 247
 248         int recursion() { return d()->recursion; }
 249         void incRecursion() { ++d()->recursion; }
 250         void decRecursion() { --d()->recursion; }
 251
 252         ScopeChain& globalScopeChain() { return d()->globalScopeChain; }
 253
 254         virtual bool isGlobalObject() const { return true; }
 255
 256         virtual ExecState* globalExec();
 257
 258         virtual bool shouldInterruptScriptBeforeTimeout() const { return false; }
 259         virtual bool shouldInterruptScript() const { return true; }
 260
 261         virtual bool allowsAccessFrom(const JSGlobalObject*) const { return true; }
 262
 263         virtual bool isDynamicScope(bool& requiresDynamicChecks) const;
 264
 265         HashSet<GlobalCodeBlock*>& codeBlocks() { return d()->codeBlocks; }
 266
 267         void copyGlobalsFrom(RegisterFile&);
 268         void copyGlobalsTo(RegisterFile&);
 269
 270         void resetPrototype(JSValue prototype);
 271
 272         JSGlobalData* globalData() { return d()->globalData.get(); }
 273         JSGlobalObjectData* d() const { return static_cast<JSGlobalObjectData*>(JSVariableObject::d); }
 274
 275         static PassRefPtr<Structure> createStructure(JSValue prototype)
 276         {
 277             return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount);
 278         }
 279
 280         void registerWeakMap(OpaqueJSWeakObjectMap* map)
 281         {
 282             d()->weakMaps.add(map);
 283         }
 284
 285         void deregisterWeakMap(OpaqueJSWeakObjectMap* map)
 286         {
 287             d()->weakMaps.remove(map);
 288         }
 289
 290         double weakRandomNumber() { return d()->weakRandom.get(); }
 291     protected:
 292
 293         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesMarkChildren | OverridesGetPropertyNames | JSVariableObject::StructureFlags;
 294
 295         struct GlobalPropertyInfo {
 296             GlobalPropertyInfo(const Identifier& i, JSValue v, unsigned a)
 297                 : identifier(i)
 298                 , value(v)
 299                 , attributes(a)
 300             {
 301             }
 302
 303             const Identifier identifier;
 304             JSValue value;
 305             unsigned attributes;
 306         };
 307         void addStaticGlobals(GlobalPropertyInfo*, int count);
 308
 309     private:
 310         static void destroyJSGlobalObjectData(void*);
 311
 312         // FIXME: Fold reset into init.
 313         void init(JSObject* thisValue);
 314         void reset(JSValue prototype);
 315
 316         void setRegisters(Register* registers, Register* registerArray, size_t count);
 317
 318         void* operator new(size_t); // can only be allocated with JSGlobalData
 319     };
 320
 321     JSGlobalObject* asGlobalObject(JSValue);
 322
 323     inline JSGlobalObject* asGlobalObject(JSValue value)
 324     {
 325         ASSERT(asObject(value)->isGlobalObject());
 326         return static_cast<JSGlobalObject*>(asObject(value));
 327     }
 328
 329     inline void JSGlobalObject::setRegisters(Register* registers, Register* registerArray, size_t count)
 330     {
 331         JSVariableObject::setRegisters(registers, registerArray);
 332         d()->registerArraySize = count;
 333     }
 334
 335     inline void JSGlobalObject::addStaticGlobals(GlobalPropertyInfo* globals, int count)
 336     {
 337         size_t oldSize = d()->registerArraySize;
 338         size_t newSize = oldSize + count;
 339         Register* registerArray = new Register[newSize];
 340         if (d()->registerArray)
 341             memcpy(registerArray + count, d()->registerArray.get(), oldSize * sizeof(Register));
 342         setRegisters(registerArray + newSize, registerArray, newSize);
 343
 344         for (int i = 0, index = -static_cast<int>(oldSize) - 1; i < count; ++i, --index) {
 345             GlobalPropertyInfo& global = globals[i];
 346             ASSERT(global.attributes & DontDelete);
 347             SymbolTableEntry newEntry(index, global.attributes);
 348             symbolTable().add(global.identifier.ustring().rep(), newEntry);
 349             registerAt(index) = global.value;
 350         }
 351     }
 352
 353     inline bool JSGlobalObject::getOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 354     {
 355         if (JSVariableObject::getOwnPropertySlot(exec, propertyName, slot))
 356             return true;
 357         return symbolTableGet(propertyName, slot);
 358     }
 359
 360     inline bool JSGlobalObject::getOwnPropertyDescriptor(ExecState* exec, const Identifier& propertyName, PropertyDescriptor& descriptor)
 361     {
 362         if (symbolTableGet(propertyName, descriptor))
 363             return true;
 364         return JSVariableObject::getOwnPropertyDescriptor(exec, propertyName, descriptor);
 365     }
 366
 367     inline bool JSGlobalObject::hasOwnPropertyForWrite(ExecState* exec, const Identifier& propertyName)
 368     {
 369         PropertySlot slot;
 370         if (JSVariableObject::getOwnPropertySlot(exec, propertyName, slot))
 371             return true;
 372         bool slotIsWriteable;
 373         return symbolTableGet(propertyName, slot, slotIsWriteable);
 374     }
 375
 376     inline JSValue Structure::prototypeForLookup(ExecState* exec) const
 377     {
 378         if (typeInfo().type() == ObjectType)
 379             return m_prototype;
 380
 381 #if USE(JSVALUE32)
 382         if (typeInfo().type() == StringType)
 383             return exec->lexicalGlobalObject()->stringPrototype();
 384
 385         ASSERT(typeInfo().type() == NumberType);
 386         return exec->lexicalGlobalObject()->numberPrototype();
 387 #else
 388         ASSERT(typeInfo().type() == StringType);
 389         return exec->lexicalGlobalObject()->stringPrototype();
 390 #endif
 391     }
 392
 393     inline StructureChain* Structure::prototypeChain(ExecState* exec) const
 394     {
 395         // We cache our prototype chain so our clients can share it.
 396         if (!isValid(exec, m_cachedPrototypeChain.get())) {
 397             JSValue prototype = prototypeForLookup(exec);
 398             m_cachedPrototypeChain = StructureChain::create(prototype.isNull() ? 0 : asObject(prototype)->structure());
 399         }
 400         return m_cachedPrototypeChain.get();
 401     }
 402
 403     inline bool Structure::isValid(ExecState* exec, StructureChain* cachedPrototypeChain) const
 404     {
 405         if (!cachedPrototypeChain)
 406             return false;
 407
 408         JSValue prototype = prototypeForLookup(exec);
 409         RefPtr<Structure>* cachedStructure = cachedPrototypeChain->head();
 410         while(*cachedStructure && !prototype.isNull()) {
 411             if (asObject(prototype)->structure() != *cachedStructure)
 412                 return false;
 413             ++cachedStructure;
 414             prototype = asObject(prototype)->prototype();
 415         }
 416         return prototype.isNull() && !*cachedStructure;
 417     }
 418
 419     inline JSGlobalObject* ExecState::dynamicGlobalObject()
 420     {
 421         if (this == lexicalGlobalObject()->globalExec())
 422             return lexicalGlobalObject();
 423
 424         // For any ExecState that's not a globalExec, the
 425         // dynamic global object must be set since code is running
 426         ASSERT(globalData().dynamicGlobalObject);
 427         return globalData().dynamicGlobalObject;
 428     }
 429
 430     inline JSObject* constructEmptyObject(ExecState* exec)
 431     {
 432         return new (exec) JSObject(exec->lexicalGlobalObject()->emptyObjectStructure());
 433     }
 434
 435     inline JSObject* constructEmptyObject(ExecState* exec, JSGlobalObject* globalObject)
 436     {
 437         return new (exec) JSObject(globalObject->emptyObjectStructure());
 438     }
 439
 440     inline JSArray* constructEmptyArray(ExecState* exec)
 441     {
 442         return new (exec) JSArray(exec->lexicalGlobalObject()->arrayStructure());
 443     }
 444
 445     inline JSArray* constructEmptyArray(ExecState* exec, JSGlobalObject* globalObject)
 446     {
 447         return new (exec) JSArray(globalObject->arrayStructure());
 448     }
 449
 450     inline JSArray* constructEmptyArray(ExecState* exec, unsigned initialLength)
 451     {
 452         return new (exec) JSArray(exec->lexicalGlobalObject()->arrayStructure(), initialLength);
 453     }
 454
 455     inline JSArray* constructArray(ExecState* exec, JSValue singleItemValue)
 456     {
 457         MarkedArgumentBuffer values;
 458         values.append(singleItemValue);
 459         return new (exec) JSArray(exec->lexicalGlobalObject()->arrayStructure(), values);
 460     }
 461
 462     inline JSArray* constructArray(ExecState* exec, const ArgList& values)
 463     {
 464         return new (exec) JSArray(exec->lexicalGlobalObject()->arrayStructure(), values);
 465     }
 466
 467     class DynamicGlobalObjectScope : public Noncopyable {
 468     public:
 469         DynamicGlobalObjectScope(CallFrame* callFrame, JSGlobalObject* dynamicGlobalObject)
 470             : m_dynamicGlobalObjectSlot(callFrame->globalData().dynamicGlobalObject)
 471             , m_savedDynamicGlobalObject(m_dynamicGlobalObjectSlot)
 472         {
 473             if (!m_dynamicGlobalObjectSlot) {
 474                 m_dynamicGlobalObjectSlot = dynamicGlobalObject;
 475
 476                 // Reset the date cache between JS invocations to force the VM
 477                 // to observe time zone changes.
 478                 callFrame->globalData().resetDateCache();
 479             }
 480         }
 481
 482         ~DynamicGlobalObjectScope()
 483         {
 484             m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
 485         }
 486
 487     private:
 488         JSGlobalObject*& m_dynamicGlobalObjectSlot;
 489         JSGlobalObject* m_savedDynamicGlobalObject;
 490     };
 491
 492 } // namespace JSC
 493
 494 #endif // JSGlobalObject_h