Changeset 44344 in webkit for trunk/JavaScriptCore/interpreter

Timestamp:

Jun 1, 2009, 10:36:18 PM (16 years ago)

Author:

[email protected]

Message:

2009-06-01 Gavin Barraclough <​[email protected]>

Reviewed by Olliej Hunt.

Change JITStub functions from being static members on the JITStub class to be
global extern "C" functions, and switch their the function signature declaration
in the definition of the functions to be C-macro generated. This makes it easier
to work with the stub functions from assembler code (since the names no longer
require mangling), and by delaring the functions with a macro we can look at
also auto-generating asm thunks to wrap the JITStub functions to perform the
work currently in 'restoreArgumentReference' (as a memory saving).

Making this change also forces us to be a bit more realistic about what is private
on the Register and CallFrame objects. Presently most everything on these classes
is private, and the classes have plenty of friends. We could befriend all the
global functions to perpetuate the delusion of encapsulation, but using friends is
a bit of a sledgehammer solution here - since friends can poke around with all of
the class's privates, and since all the major classes taht operate on Regsiters are
currently friends, right there is currently in practice very little protection at
all. Better to start removing friend delclarations, and exposing just the parts
that need to be exposed.

• interpreter/CallFrame.h: (JSC::ExecState::returnPC): (JSC::ExecState::setCallerFrame): (JSC::ExecState::returnValueRegister): (JSC::ExecState::setArgumentCount): (JSC::ExecState::setCallee): (JSC::ExecState::setCodeBlock):
• interpreter/Interpreter.h:
• interpreter/Register.h: (JSC::Register::Register): (JSC::Register::i):
• jit/JITStubs.cpp: (JSC::): (JSC::JITThunks::JITThunks): (JSC::JITThunks::tryCachePutByID): (JSC::JITThunks::tryCacheGetByID): (JSC::JITStubs::DEFINE_STUB_FUNCTION):
• jit/JITStubs.h: (JSC::JITStubs::):
• runtime/JSFunction.h: (JSC::JSFunction::nativeFunction): (JSC::JSFunction::classInfo):
• runtime/JSGlobalData.h:

Location:

trunk/JavaScriptCore/interpreter

Files:

• CallFrame.h (modified) (3 diffs)
• Interpreter.h (modified) (4 diffs)
• Register.h (modified) (6 diffs)

trunk/JavaScriptCore/interpreter/CallFrame.h

@@ -96 +96 @@
         static const HashTable* stringTable(CallFrame* callFrame) { return callFrame->globalData().stringTable; }
 
-    private:
-        friend class Arguments;
-        friend class JSActivation;
-        friend class JSGlobalObject;
-        friend class Interpreter;
-        friend class JITStubs;
-        friend struct CallFrameClosure;
-
         static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
         Register* registers() { return this; }
@@ -112 +104 @@
         Arguments* optionalCalleeArguments() const { return this[RegisterFile::OptionalCalleeArguments].arguments(); }
         Instruction* returnPC() const { return this[RegisterFile::ReturnPC].vPC(); }
-        int returnValueRegister() const { return this[RegisterFile::ReturnValueRegister].i(); }
 
-        void setArgumentCount(int count) { this[RegisterFile::ArgumentCount] = count; }
-        void setCallee(JSFunction* callee) { this[RegisterFile::Callee] = callee; }
         void setCalleeArguments(Arguments* arguments) { this[RegisterFile::OptionalCalleeArguments] = arguments; }
         void setCallerFrame(CallFrame* callerFrame) { this[RegisterFile::CallerFrame] = callerFrame; }
-        void setCodeBlock(CodeBlock* codeBlock) { this[RegisterFile::CodeBlock] = codeBlock; }
         void setScopeChain(ScopeChainNode* scopeChain) { this[RegisterFile::ScopeChain] = scopeChain; }
 
@@ -136 +124 @@
         }
 
+    private:
+        friend class Arguments;
+        friend class JSActivation;
+        friend class JSGlobalObject;
+        friend class Interpreter;
+        friend struct CallFrameClosure;
+
+        int returnValueRegister() const { return this[RegisterFile::ReturnValueRegister].i(); }
+
+        void setArgumentCount(int count) { this[RegisterFile::ArgumentCount] = count; }
+        void setCallee(JSFunction* callee) { this[RegisterFile::Callee] = callee; }
+        void setCodeBlock(CodeBlock* codeBlock) { this[RegisterFile::CodeBlock] = codeBlock; }
+
         static const intptr_t HostCallFrameFlag = 1;
 

trunk/JavaScriptCore/interpreter/Interpreter.h

@@ -68 +68 @@
     class Interpreter : public WTF::FastAllocBase {
         friend class JIT;
-        friend class JITStubs;
         friend class CachedCall;
     public:
@@ -109 +108 @@
         SamplingTool* sampler() { return m_sampler; }
 
+        NEVER_INLINE JSValue callEval(CallFrame*, RegisterFile*, Register* argv, int argc, int registerOffset, JSValue& exceptionValue);
+        NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset, bool);
+        NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);
+
     private:
         enum ExecutionFlag { Normal, InitializeAndReturn };
@@ -116 +119 @@
         JSValue execute(CallFrameClosure&, JSValue* exception);
 
-        NEVER_INLINE JSValue callEval(CallFrame*, RegisterFile*, Register* argv, int argc, int registerOffset, JSValue& exceptionValue);
         JSValue execute(EvalNode*, CallFrame*, JSObject* thisObject, int globalRegisterOffset, ScopeChainNode*, JSValue* exception);
 
-        NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);
 #if USE(INTERPRETER)
         NEVER_INLINE bool resolve(CallFrame*, Instruction*, JSValue& exceptionValue);
@@ -136 +137 @@
 
         NEVER_INLINE bool unwindCallFrame(CallFrame*&, JSValue, unsigned& bytecodeOffset, CodeBlock*&);
-        NEVER_INLINE HandlerInfo* throwException(CallFrame*&, JSValue&, unsigned bytecodeOffset, bool);
 
         static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, RegisterFile*, CallFrame*, size_t registerOffset, int argc);

trunk/JavaScriptCore/interpreter/Register.h

@@ -31 +31 @@
 
 #include "JSValue.h"
+#include <wtf/Assertions.h>
 #include <wtf/VectorTraits.h>
 
@@ -51 +52 @@
         Register();
         Register(JSValue);
+        Register(Arguments*);
 
         JSValue jsValue() const;
@@ -57 +59 @@
         void mark();
         
+        int32_t i() const;
+        void* v() const;
+
     private:
         friend class ExecState;
         friend class Interpreter;
-        friend class JITStubs;
 
         // Only CallFrame, Interpreter, and JITStubs should use these functions.
@@ -67 +71 @@
 
         Register(JSActivation*);
-        Register(Arguments*);
         Register(CallFrame*);
         Register(CodeBlock*);
@@ -74 +77 @@
         Register(ScopeChainNode*);
         Register(Instruction*);
-
-        intptr_t i() const;
-        void* v() const;
 
         JSActivation* activation() const;
@@ -174 +174 @@
     ALWAYS_INLINE Register::Register(intptr_t i)
     {
+        // See comment on 'i()' below.
+        ASSERT(i == static_cast<int32_t>(i));
         u.i = i;
     }
 
-    ALWAYS_INLINE intptr_t Register::i() const
-    {
-        return u.i;
+    // Read 'i' as a 32-bit integer; we only use it to hold 32-bit values,
+    // and we only write 32-bits when writing the arg count from JIT code.
+    ALWAYS_INLINE int32_t Register::i() const
+    {
+        return static_cast<int32_t>(u.i);
     }