Changeset 28937 in webkit for trunk/JavaScriptCore/wtf/RefPtr.h

Timestamp:

Dec 21, 2007, 1:54:51 PM (17 years ago)

Author:

Darin Adler

Message:

Reviewed by Eric.

• ​http://bugs.webkit.org/show_bug.cgi?id=16561 remove debugger overhead from non-debugged JavaScript execution

1.022x as fast on SunSpider.

• JavaScriptCore.exp: Updated.

• kjs/NodeInfo.h: Renamed SourceElementsStub to SourceElements, since that more accurately describes the role of this object, which is a reference-counted wrapper for a Vector.

• kjs/Parser.cpp: (KJS::Parser::didFinishParsing): Changed parameter type to SourceElements, and use plain assignment instead of set.
• kjs/Parser.h: Changed parameter type of didFinishParsing to a SourceElements. Also changed m_sourceElements; we now use a RefPtr instead of an OwnPtr as well.

• kjs/grammar.y: Got rid of all the calls to release() on SourceElements. That's now handed inside the constructors for various node types, since we now use vector swapping instead.

• kjs/nodes.cpp: (KJS::Node::rethrowException): Added NEVER_INLINE, because this was getting inlined and we want exception handling out of the normal code flow. (KJS::SourceElements::append): Moved here from the header. This now handles creating a BreakpointCheckStatement for each statement in the debugger case. That way we can get breakpoint handling without having it in every execute function. (KJS::BreakpointCheckStatement::BreakpointCheckStatement): Added. (KJS::BreakpointCheckStatement::execute): Added. Contains the code that was formerly in the StatementNode::hitStatement function and the KJS_BREAKPOINT macro. (KJS::BreakpointCheckStatement::streamTo): Added. (KJS::ArgumentListNode::evaluateList): Use KJS_CHECKEXCEPTIONVOID since the return type is void. (KJS::VarStatementNode::execute): Removed KJS_BREAKPOINT. (KJS::BlockNode::BlockNode): Changed parameter type to SourceElements. Changed code to use release since the class now contains a vector rather than a vector point. (KJS::BlockNode::optimizeVariableAccess): Updated since member is now a vector rather than a vector pointer. (KJS::BlockNode::execute): Ditto. (KJS::ExprStatementNode::execute): Removed KJS_BREAKPOINT. (KJS::IfNode::execute): Ditto. (KJS::IfElseNode::execute): Ditto. (KJS::DoWhileNode::execute): Ditto. (KJS::WhileNode::execute): Ditto. (KJS::ContinueNode::execute): Ditto. (KJS::BreakNode::execute): Ditto. (KJS::ReturnNode::execute): Ditto. (KJS::WithNode::execute): Ditto. (KJS::CaseClauseNode::optimizeVariableAccess): Updated since member is now a vector rather than a vector pointer. (KJS::CaseClauseNode::executeStatements): Ditto. (KJS::SwitchNode::execute): Removed KJS_BREAKPOINT. (KJS::ThrowNode::execute): Ditto. (KJS::TryNode::execute): Ditto. (KJS::ScopeNode::ScopeNode): Changed parameter type to SourceElements. (KJS::ProgramNode::ProgramNode): Ditto. (KJS::EvalNode::EvalNode): Ditto. (KJS::FunctionBodyNode::FunctionBodyNode): Ditto. (KJS::ScopeNode::optimizeVariableAccess): Updated since member is now a vector rather than a vector pointer.

• kjs/nodes.h: Removed hitStatement. Renamed SourceElements to StatementVector. Renamed SourceElementsStub to SourceElements and made it derive from ParserRefCounted rather than from Node, hold a vector rather than a pointer to a vector, and changed the release function to swap with another vector rather than the pointer idiom. Updated BlockNode and CaseClauseNode to hold actual vectors instead of pointers to vectors. Added BreakpointCheckStatement.

• kjs/nodes2string.cpp: (KJS::statementListStreamTo): Changed to work on a vector instead of a pointer to a vector. (KJS::BlockNode::streamTo): Ditto. (KJS::CaseClauseNode::streamTo): Ditto.

• wtf/AlwaysInline.h: Added NEVER_INLINE.
• wtf/PassRefPtr.h: Tweaked formatting. Added clear() function that matches the ones in OwnPtr and auto_ptr.
• wtf/RefPtr.h: Ditto.

File:

• trunk/JavaScriptCore/wtf/RefPtr.h (modified) (4 diffs)

trunk/JavaScriptCore/wtf/RefPtr.h

@@ -35 +35 @@
     public:
         RefPtr() : m_ptr(0) {}
-        RefPtr(T *ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
-        RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { if (T *ptr = m_ptr) ptr->ref(); }
+        RefPtr(T* ptr) : m_ptr(ptr) { if (ptr) ptr->ref(); }
+        RefPtr(const RefPtr& o) : m_ptr(o.m_ptr) { if (T* ptr = m_ptr) ptr->ref(); }
         // see comment in PassRefPtr.h for why this takes const reference
         template <typename U> RefPtr(const PassRefPtr<U>&);
@@ -43 +43 @@
         RefPtr(PlacementNewAdoptType) { }
 
-        ~RefPtr() { if (T *ptr = m_ptr) ptr->deref(); }
+        ~RefPtr() { if (T* ptr = m_ptr) ptr->deref(); }
         
-        template <typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T *ptr = m_ptr) ptr->ref(); }
+        template <typename U> RefPtr(const RefPtr<U>& o) : m_ptr(o.get()) { if (T* ptr = m_ptr) ptr->ref(); }
         
-        T *get() const { return m_ptr; }
+        T* get() const { return m_ptr; }
         
+        void clear() { if (T* ptr = m_ptr) ptr->deref(); m_ptr = 0; }
         PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = 0; return tmp; }
 
@@ -57 +58 @@
     
         // This conversion operator allows implicit conversion to bool but not to other integer types.
-        typedef T * (RefPtr::*UnspecifiedBoolType)() const;
+        typedef T* (RefPtr::*UnspecifiedBoolType)() const;
         operator UnspecifiedBoolType() const { return m_ptr ? &RefPtr::get : 0; }
         
         RefPtr& operator=(const RefPtr&);
-        RefPtr& operator=(T *);
+        RefPtr& operator=(T*);
         RefPtr& operator=(const PassRefPtr<T>&);
         template <typename U> RefPtr& operator=(const RefPtr<U>&);
@@ -172 +173 @@
     template <typename T, typename U> inline RefPtr<T> static_pointer_cast(const RefPtr<U>& p)
     { 
-        return RefPtr<T>(static_cast<T *>(p.get())); 
+        return RefPtr<T>(static_cast<T*>(p.get())); 
     }
 
     template <typename T, typename U> inline RefPtr<T> const_pointer_cast(const RefPtr<U>& p)
     { 
-        return RefPtr<T>(const_cast<T *>(p.get())); 
+        return RefPtr<T>(const_cast<T*>(p.get())); 
     }