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