Changeset 27072 in webkit for trunk/JavaScriptCore/kjs

Timestamp:

Oct 25, 2007, 3:29:55 PM (18 years ago)

Author:

ggaren

Message:

Reviewed by Oliver Hunt.

Rolled out my last patch. It turns out that I needed 2 words, not 1,
so it didn't help.

Location:

trunk/JavaScriptCore/kjs

Files:

• Context.cpp (modified) (1 diff)
• function.cpp (modified) (2 diffs)
• function.h (modified) (2 diffs)

trunk/JavaScriptCore/kjs/Context.cpp

@@ -88 +88 @@
     ActivationImp* activation = static_cast<ActivationImp*>(m_activation);
     if (activation)
-        activation->resetArguments();
+        activation->releaseArguments();
 }
 

trunk/JavaScriptCore/kjs/function.cpp

@@ -391 +391 @@
 // ------------------------------ ActivationImp --------------------------------
 
-void ActivationImp::LazyArgumentsObject::createArgumentsObject(ExecState* exec, ActivationImp* activationImp)
-{
-    setArgumentsObject(new Arguments(exec, function(), arguments, activationImp));
-
-    // The arguments list is only needed to create the arguments object, so 
-    // discard it now. This prevents lists of Lists from building up, waiting 
-    // to be garbage collected.
-    arguments.reset();
-}
-
-void ActivationImp::LazyArgumentsObject::mark()
-{
-    JSObject* o;
-    if (createdArgumentsObject())
-        o = argumentsObject();
-    else
-        o = function();
-
-    if (!o->marked())
-        o->mark();
-}
-
 const ClassInfo ActivationImp::info = {"Activation", 0, 0, 0};
 
+// ECMA 10.1.6
+ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)
+    : _function(function), _arguments(arguments), _argumentsObject(0)
+{
+  // FIXME: Do we need to support enumerating the arguments property?
+}
+
 JSValue* ActivationImp::argumentsGetter(ExecState* exec, JSObject*, const Identifier&, const PropertySlot& slot)
 {
   ActivationImp* thisObj = static_cast<ActivationImp*>(slot.slotBase());
-  return thisObj->m_lazyArgumentsObject.getOrCreate(exec, thisObj);
+
+  // default: return builtin arguments array
+  if (!thisObj->_argumentsObject)
+    thisObj->createArgumentsObject(exec);
+  
+  return thisObj->_argumentsObject;
 }
 
@@ -463 +453 @@
 void ActivationImp::mark()
 {
-    m_lazyArgumentsObject.mark();
+    if (_function && !_function->marked()) 
+        _function->mark();
+    if (_argumentsObject && !_argumentsObject->marked())
+        _argumentsObject->mark();
     JSObject::mark();
+}
+
+void ActivationImp::createArgumentsObject(ExecState* exec)
+{
+  _argumentsObject = new Arguments(exec, _function, _arguments, const_cast<ActivationImp*>(this));
+  // The arguments list is only needed to create the arguments object, so discard it now
+  _arguments.reset();
 }
 

trunk/JavaScriptCore/kjs/function.h

@@ -144 +144 @@
   class ActivationImp : public JSObject {
   public:
-    class LazyArgumentsObject {
-    public:
-        LazyArgumentsObject(FunctionImp* f, const List& a)
-            : arguments(a)
-        {
-            ASSERT(f);
-            setFunction(f);
-        }
-
-        Arguments* getOrCreate(ExecState* exec, ActivationImp* activationImp)
-        {
-            if (!createdArgumentsObject())
-                createArgumentsObject(exec, activationImp);
-            return argumentsObject();
-        }
-
-        void resetArguments() { arguments.reset(); }
-        void mark();
-
-    private:
-        static const uintptr_t TagMask = 1; // Pointer alignment leaves this bit open for tagging.
-        
-        void setArgumentsObject(Arguments* a)
-        { 
-            u.argumentsObject = a;
-            u.bits |= TagMask;
-        }
-
-        Arguments* argumentsObject()
-        {
-            ASSERT(createdArgumentsObject());
-            return reinterpret_cast<Arguments*>(u.bits & ~TagMask);
-        }
-
-        void setFunction(FunctionImp* f) { u.function = f; }
-        FunctionImp* function()
-        {
-            ASSERT(!createdArgumentsObject());
-            return u.function;
-        }
-
-        bool createdArgumentsObject() { return (u.bits & TagMask) != 0; }
-        void createArgumentsObject(ExecState*, ActivationImp*);
-
-        List arguments;
-        union {
-            // The low bit in this union is a flag: 0 means the union holds a 
-            // FunctionImp*; 1 means the union holds an Arguments*.
-            uintptr_t bits;
-            FunctionImp* function;
-            Arguments* argumentsObject;
-        } u;
-    };
-    
-    ActivationImp::ActivationImp(FunctionImp* function, const List& arguments)
-        : m_lazyArgumentsObject(function, arguments)
-    {
-    }
+    ActivationImp(FunctionImp* function, const List& arguments);
 
     virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
@@ -214 +157 @@
     bool isActivation() { return true; }
 
-    void resetArguments() { m_lazyArgumentsObject.resetArguments(); }
+    void releaseArguments() { _arguments.reset(); }
 
   private:
     static PropertySlot::GetValueFunc getArgumentsGetter();
     static JSValue* argumentsGetter(ExecState*, JSObject*, const Identifier&, const PropertySlot& slot);
-    
-    LazyArgumentsObject m_lazyArgumentsObject;
+    void createArgumentsObject(ExecState*);
+
+    FunctionImp* _function;
+    List _arguments;
+    mutable Arguments* _argumentsObject;
   };