Changeset 37428 in webkit

Timestamp:

Oct 8, 2008 10:50:42 AM (16 years ago)

Author:

timothy@apple.com

Message:

Roll out r37427 because it causes an infinite recursion loading about:blank.

​https://bugs.webkit.org/show_bug.cgi?id=21476

Location:

trunk

Files:

• JavaScriptCore/API/JSObjectRef.cpp (modified) (6 diffs)
• JavaScriptCore/API/OpaqueJSString.cpp (modified) (1 diff)
• JavaScriptCore/API/OpaqueJSString.h (modified) (2 diffs)
• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/VM/CTI.cpp (modified) (25 diffs)
• JavaScriptCore/VM/CTI.h (modified) (6 diffs)
• JavaScriptCore/VM/CodeBlock.h (modified) (1 diff)
• JavaScriptCore/VM/CodeGenerator.cpp (modified) (5 diffs)
• JavaScriptCore/VM/CodeGenerator.h (modified) (1 diff)
• JavaScriptCore/VM/Machine.cpp (modified) (315 diffs)
• JavaScriptCore/VM/Machine.h (modified) (4 diffs)
• JavaScriptCore/VM/Register.h (modified) (7 diffs)
• JavaScriptCore/VM/RegisterFile.h (modified) (1 diff)
• JavaScriptCore/kjs/Arguments.h (modified) (4 diffs)
• JavaScriptCore/kjs/DebuggerCallFrame.cpp (modified) (3 diffs)
• JavaScriptCore/kjs/DebuggerCallFrame.h (modified) (2 diffs)
• JavaScriptCore/kjs/ExecState.cpp (modified) (1 diff)
• JavaScriptCore/kjs/ExecState.h (modified) (4 diffs)
• JavaScriptCore/kjs/FunctionConstructor.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSActivation.cpp (modified) (2 diffs)
• JavaScriptCore/kjs/JSActivation.h (modified) (1 diff)
• JavaScriptCore/kjs/JSGlobalObject.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSGlobalObjectFunctions.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSVariableObject.h (modified) (1 diff)
• JavaScriptCore/kjs/Parser.cpp (modified) (1 diff)
• JavaScriptCore/kjs/RegExpConstructor.cpp (modified) (1 diff)
• JavaScriptCore/kjs/RegExpPrototype.cpp (modified) (1 diff)
• JavaScriptCore/kjs/Shell.cpp (modified) (1 diff)
• JavaScriptCore/kjs/StringPrototype.cpp (modified) (2 diffs)
• JavaScriptCore/kjs/identifier.cpp (modified) (1 diff)
• JavaScriptCore/kjs/interpreter.cpp (modified) (2 diffs)
• JavaScriptCore/kjs/nodes.cpp (modified) (5 diffs)
• JavaScriptCore/kjs/nodes.h (modified) (1 diff)
• JavaScriptCore/kjs/regexp.cpp (modified) (3 diffs)
• JavaScriptCore/kjs/regexp.h (modified) (3 diffs)
• JavaScriptCore/profiler/HeavyProfile.h (modified) (1 diff)
• JavaScriptCore/profiler/Profile.h (modified) (1 diff)
• JavaScriptCore/wrec/WREC.cpp (modified) (1 diff)
• JavaScriptCore/wrec/WREC.h (modified) (1 diff)
• WebKit/mac/ChangeLog (modified) (1 diff)
• WebKit/mac/WebView/WebScriptDebugger.mm (modified) (1 diff)

trunk/JavaScriptCore/API/JSObjectRef.cpp

@@ -93 +93 @@
     JSLock lock(exec);
 
-    Identifier nameID = name ? name->identifier(&exec->globalData()) : Identifier(exec, "anonymous");
+    Identifier nameID = name ? name->identifier(exec) : Identifier(exec, "anonymous");
     
     return toRef(new (exec) JSCallbackFunction(exec, callAsFunction, nameID));
@@ -119 +119 @@
     JSLock lock(exec);
 
-    Identifier nameID = name ? name->identifier(&exec->globalData()) : Identifier(exec, "anonymous");
+    Identifier nameID = name ? name->identifier(exec) : Identifier(exec, "anonymous");
     
     ArgList args;
@@ -247 +247 @@
     JSObject* jsObject = toJS(object);
     
-    return jsObject->hasProperty(exec, propertyName->identifier(&exec->globalData()));
+    return jsObject->hasProperty(exec, propertyName->identifier(exec));
 }
 
@@ -258 +258 @@
     JSObject* jsObject = toJS(object);
 
-    JSValue* jsValue = jsObject->get(exec, propertyName->identifier(&exec->globalData()));
+    JSValue* jsValue = jsObject->get(exec, propertyName->identifier(exec));
     if (exec->hadException()) {
         if (exception)
@@ -274 +274 @@
 
     JSObject* jsObject = toJS(object);
-    Identifier name(propertyName->identifier(&exec->globalData()));
+    Identifier name(propertyName->identifier(exec));
     JSValue* jsValue = toJS(value);
 
@@ -334 +334 @@
     JSObject* jsObject = toJS(object);
 
-    bool result = jsObject->deleteProperty(exec, propertyName->identifier(&exec->globalData()));
+    bool result = jsObject->deleteProperty(exec,  propertyName->identifier(exec));
     if (exec->hadException()) {
         if (exception)

trunk/JavaScriptCore/API/OpaqueJSString.cpp

@@ -47 +47 @@
 }
 
+Identifier OpaqueJSString::identifier(ExecState* exec) const
+{
+    return identifier(&exec->globalData());
+}
+
 Identifier OpaqueJSString::identifier(JSGlobalData* globalData) const
 {

trunk/JavaScriptCore/API/OpaqueJSString.h

@@ -30 +30 @@
 
 namespace JSC {
+    class ExecState;
     class Identifier;
     class JSGlobalData;
-}
+};
 
 struct OpaqueJSString : public ThreadSafeShared<OpaqueJSString> {
@@ -52 +53 @@
 
     JSC::UString ustring() const;
+
+    JSC::Identifier identifier(JSC::ExecState*) const;
     JSC::Identifier identifier(JSC::JSGlobalData*) const;
 

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-10-08  Timothy Hatcher  <timothy@apple.com>
+
+        Roll out r37427 because it causes an infinite recursion loading about:blank.
+
+        https://bugs.webkit.org/show_bug.cgi?id=21476
+
 2008-10-08  Darin Adler  <darin@apple.com>
 

trunk/JavaScriptCore/VM/CTI.cpp

@@ -35 +35 @@
 #include "wrec/WREC.h"
 #include "ResultType.h"
-
 #if PLATFORM(MAC)
 #include <sys/sysctl.h>
@@ -45 +44 @@
 
 #if PLATFORM(MAC)
-
-static inline bool isSSE2Present()
+bool isSSE2Present()
 {
     return true; // All X86 Macs are guaranteed to support at least SSE2
 }
-
-#else
-
-static bool isSSE2Present()
+#else COMPILER(MSVC)
+bool isSSE2Present()
 {
     static const int SSE2FeatureBit = 1 << 26;
@@ -77 +73 @@
     return check.present;
 }
-
 #endif
-
-COMPILE_ASSERT(CTI_ARGS_code == 0xC, CTI_ARGS_code_is_C);
-COMPILE_ASSERT(CTI_ARGS_callFrame == 0xE, CTI_ARGS_callFrame_is_E);
 
 #if COMPILER(GCC) && PLATFORM(X86)
@@ -92 +84 @@
     "subl $0x24, %esp" "\n"
     "movl $512, %esi" "\n"
-    "movl 0x38(%esp), %edi" "\n" // Ox38 = 0x0E * 4, 0x0E = CTI_ARGS_callFrame (see assertion above)
-    "call *0x30(%esp)" "\n" // Ox30 = 0x0C * 4, 0x0C = CTI_ARGS_code (see assertion above)
+    "movl 0x38(%esp), %edi" "\n" // Ox38 = 0x0E * 4, 0x0E = CTI_ARGS_r
+    "call *0x30(%esp)" "\n" // Ox30 = 0x0C * 4, 0x0C = CTI_ARGS_code
     "addl $0x24, %esp" "\n"
     "popl %edi" "\n"
@@ -123 +115 @@
             mov ecx, esp;
             mov edi, [esp + 0x38];
-            call [esp + 0x30]; // Ox30 = 0x0C * 4, 0x0C = CTI_ARGS_code (see assertion above)
+            call [esp + 0x30];
             add esp, 0x24;
             pop edi;
@@ -147 +139 @@
 #endif
 
+
 ALWAYS_INLINE bool CTI::isConstant(int src)
 {
@@ -152 +145 @@
 }
 
-ALWAYS_INLINE JSValue* CTI::getConstant(CallFrame* callFrame, int src)
-{
-    return m_codeBlock->constantRegisters[src - m_codeBlock->numVars].jsValue(callFrame);
+ALWAYS_INLINE JSValue* CTI::getConstant(ExecState* exec, int src)
+{
+    return m_codeBlock->constantRegisters[src - m_codeBlock->numVars].jsValue(exec);
 }
 
@@ -162 +155 @@
     // TODO: we want to reuse values that are already in registers if we can - add a register allocator!
     if (isConstant(src)) {
-        JSValue* js = getConstant(m_callFrame, src);
+        JSValue* js = getConstant(m_exec, src);
         m_jit.movl_i32r(reinterpret_cast<unsigned>(js), dst);
     } else
@@ -172 +165 @@
 {
     if (isConstant(src)) {
-        JSValue* js = getConstant(m_callFrame, src);
+        JSValue* js = getConstant(m_exec, src);
         m_jit.movl_i32m(reinterpret_cast<unsigned>(js), offset + sizeof(void*), X86::esp);
     } else {
@@ -194 +187 @@
 {
     if (isConstant(src)) {
-        JSValue* js = getConstant(m_callFrame, src);
+        JSValue* js = getConstant(m_exec, src);
         return JSImmediate::isNumber(js) ? js : 0;
     }
@@ -257 +250 @@
     char which1 = '*';
     if (isConstant(src1)) {
-        JSValue* js = getConstant(m_callFrame, src1);
+        JSValue* js = getConstant(m_exec, src1);
         which1 = 
             JSImmediate::isImmediate(js) ?
@@ -271 +264 @@
     char which2 = '*';
     if (isConstant(src2)) {
-        JSValue* js = getConstant(m_callFrame, src2);
+        JSValue* js = getConstant(m_exec, src2);
         which2 = 
             JSImmediate::isImmediate(js) ?
@@ -453 +446 @@
 }
 
-CTI::CTI(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock)
+CTI::CTI(Machine* machine, ExecState* exec, CodeBlock* codeBlock)
     : m_jit(machine->jitCodeBuffer())
     , m_machine(machine)
-    , m_callFrame(callFrame)
+    , m_exec(exec)
     , m_codeBlock(codeBlock)
     , m_labels(codeBlock ? codeBlock->instructions.size() : 0)
@@ -495 +488 @@
     m_jit.movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::ecx); // newScopeChain
     m_jit.movl_i32m(argCount, RegisterFile::ArgumentCount * static_cast<int>(sizeof(Register)), X86::edx);
-    m_jit.movl_rm(X86::edi, RegisterFile::CallerFrame * static_cast<int>(sizeof(Register)), X86::edx);
+    m_jit.movl_rm(X86::edi, RegisterFile::CallerRegisters * static_cast<int>(sizeof(Register)), X86::edx);
     m_jit.movl_rm(X86::ecx, RegisterFile::ScopeChain * static_cast<int>(sizeof(Register)), X86::edx);
 }
@@ -523 +516 @@
         int thisVal = instruction[i + 3].u.operand;
         if (thisVal == missingThisObjectMarker()) {
-            // FIXME: should this be loaded dynamically off m_callFrame?
-            m_jit.movl_i32m(reinterpret_cast<unsigned>(m_callFrame->globalThisValue()), firstArg * sizeof(Register), X86::edi);
+            // FIXME: should this be loaded dynamically off m_exec?
+            m_jit.movl_i32m(reinterpret_cast<unsigned>(m_exec->globalThisValue()), firstArg * sizeof(Register), X86::edi);
         } else {
             emitGetArg(thisVal, X86::ecx);
@@ -567 +560 @@
     m_jit.movl_mr(OBJECT_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
 
-    // Put the new value of 'callFrame' into edi and onto the stack, too.
-    emitPutCTIParam(X86::edx, CTI_ARGS_callFrame);
+    // Setup the new value of 'r' in edi, and on the stack, too.
+    emitPutCTIParam(X86::edx, CTI_ARGS_r);
     m_jit.movl_rr(X86::edx, X86::edi);
 
@@ -693 +686 @@
 void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
-    StructureID* numberStructureID = m_callFrame->globalData().numberStructureID.get();
+    StructureID* numberStructureID = m_exec->globalData().numberStructureID.get();
     X86Assembler::JmpSrc wasJSNumberCell1, wasJSNumberCell1b, wasJSNumberCell2, wasJSNumberCell2b;
 
@@ -886 +879 @@
             unsigned src = instruction[i + 2].u.operand;
             if (isConstant(src))
-                m_jit.movl_i32r(reinterpret_cast<unsigned>(getConstant(m_callFrame, src)), X86::edx);
+                m_jit.movl_i32r(reinterpret_cast<unsigned>(getConstant(m_exec, src)), X86::edx);
             else
                 emitGetArg(src, X86::edx);
@@ -1246 +1239 @@
 
             // Restore our caller's "r".
-            emitGetArg(RegisterFile::CallerFrame, X86::edi);
-            emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
+            emitGetArg(RegisterFile::CallerRegisters, X86::edi);
+            emitPutCTIParam(X86::edi, CTI_ARGS_r);
 
             // Return.
@@ -1811 +1804 @@
         }
         case op_catch: {
-            emitGetCTIParam(CTI_ARGS_callFrame, X86::edi); // edi := r
+            emitGetCTIParam(CTI_ARGS_r, X86::edi); // edi := r
             emitPutResult(instruction[i + 1].u.operand);
             i += 2;
@@ -2660 +2653 @@
     // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a StructureID that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
-    JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(m_callFrame));
+    JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(m_exec));
     PropertyStorage* protoPropertyStorage = &protoObject->m_propertyStorage;
     m_jit.movl_mr(static_cast<void*>(protoPropertyStorage), X86::edx);
@@ -2703 +2696 @@
     // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a StructureID that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
-    JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(m_callFrame));
+    JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(m_exec));
     PropertyStorage* protoPropertyStorage = &protoObject->m_propertyStorage;
     m_jit.movl_mr(static_cast<void*>(protoPropertyStorage), X86::edx);
@@ -2752 +2745 @@
     JSObject* protoObject = 0;
     for (unsigned i = 0; i<count; ++i) {
-        protoObject = static_cast<JSObject*>(currStructureID->prototypeForLookup(m_callFrame));
+        protoObject = static_cast<JSObject*>(currStructureID->prototypeForLookup(m_exec));
         currStructureID = chainEntries[i].get();
 
@@ -3052 +3045 @@
 #if ENABLE(WREC)
 
-void* CTI::compileRegExp(Machine* machine, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
+void* CTI::compileRegExp(ExecState* exec, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase, bool multiline)
 {
     // TODO: better error messages
@@ -3060 +3053 @@
     }
 
-    X86Assembler jit(machine->jitCodeBuffer());
+    X86Assembler jit(exec->machine()->jitCodeBuffer());
     WRECParser parser(pattern, ignoreCase, multiline, jit);
     

trunk/JavaScriptCore/VM/CTI.h

@@ -48 +48 @@
 #define CTI_ARGS_code 0x0C
 #define CTI_ARGS_registerFile 0x0D
-#define CTI_ARGS_callFrame 0x0E
+#define CTI_ARGS_r 0x0E
 #define CTI_ARGS_exception 0x0F
 #define CTI_ARGS_profilerReference 0x10
 #define CTI_ARGS_globalData 0x11
 #define ARG_registerFile ((RegisterFile*)(ARGS)[CTI_ARGS_registerFile])
-#define ARG_callFrame ((CallFrame*)(ARGS)[CTI_ARGS_callFrame])
+#define ARG_r ((Register*)(ARGS)[CTI_ARGS_r])
 #define ARG_exception ((JSValue**)(ARGS)[CTI_ARGS_exception])
 #define ARG_profilerReference ((Profiler**)(ARGS)[CTI_ARGS_profilerReference])
 #define ARG_globalData ((JSGlobalData*)(ARGS)[CTI_ARGS_globalData])
 
-#define ARG_setCallFrame(newCallFrame) (*(CallFrame**)&(ARGS)[CTI_ARGS_callFrame] = (newCallFrame))
+#define ARG_exec CallFrame::create(ARG_r)
+
+#define ARG_setR(newR) (*(Register**)&(ARGS)[CTI_ARGS_r] = newR)
 
 #define ARG_src1 ((JSValue*)((ARGS)[1]))
@@ -91 +93 @@
 
     class CodeBlock;
+    class ExecState;
     class JSPropertyNameIterator;
     class JSValue;
@@ -247 +250 @@
 
     extern "C" {
-        JSValue* ctiTrampoline(void* code, RegisterFile*, CallFrame*, JSValue** exception, Profiler**, JSGlobalData*);
+        JSValue* ctiTrampoline(void* code, RegisterFile*, Register* callFrame, JSValue** exception, Profiler**, JSGlobalData*);
         void ctiVMThrowTrampoline();
     };
@@ -281 +284 @@
 
     public:
-        static void compile(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compile(Machine* machine, ExecState* exec, CodeBlock* codeBlock)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompile();
         }
 
 #if ENABLE(WREC)
-        static void* compileRegExp(Machine*, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
-#endif
-
-        static void compileGetByIdSelf(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void* compileRegExp(ExecState* exec, const UString& pattern, unsigned* numSubpatterns_ptr, const char** error_ptr, bool ignoreCase = false, bool multiline = false);
+#endif
+
+        static void compileGetByIdSelf(Machine* machine, ExecState* exec, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompileGetByIdSelf(structureID, cachedOffset, returnAddress);
         }
 
-        static void compileGetByIdProto(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, StructureID* prototypeStructureID, size_t cachedOffset, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compileGetByIdProto(Machine* machine, ExecState* exec, CodeBlock* codeBlock, StructureID* structureID, StructureID* prototypeStructureID, size_t cachedOffset, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompileGetByIdProto(structureID, prototypeStructureID, cachedOffset, returnAddress);
         }
 
-        static void compileGetByIdChain(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, StructureIDChain* chain, size_t count, size_t cachedOffset, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compileGetByIdChain(Machine* machine, ExecState* exec, CodeBlock* codeBlock, StructureID* structureID, StructureIDChain* chain, size_t count, size_t cachedOffset, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompileGetByIdChain(structureID, chain, count, cachedOffset, returnAddress);
         }
 
-        static void compilePutByIdReplace(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compilePutByIdReplace(Machine* machine, ExecState* exec, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompilePutByIdReplace(structureID, cachedOffset, returnAddress);
         }
         
-        static void compilePutByIdTransition(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* oldStructureID, StructureID* newStructureID, size_t cachedOffset, StructureIDChain* sIDC, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compilePutByIdTransition(Machine* machine, ExecState* exec, CodeBlock* codeBlock, StructureID* oldStructureID, StructureID* newStructureID, size_t cachedOffset, StructureIDChain* sIDC, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             cti.privateCompilePutByIdTransition(oldStructureID, newStructureID, cachedOffset, sIDC, returnAddress);
         }
 
-        static void* compileArrayLengthTrampoline(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void* compileArrayLengthTrampoline(Machine* machine, ExecState* exec, CodeBlock* codeBlock)
+        {
+            CTI cti(machine, exec, codeBlock);
             return cti.privateCompileArrayLengthTrampoline();
         }
 
-        static void* compileStringLengthTrampoline(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void* compileStringLengthTrampoline(Machine* machine, ExecState* exec, CodeBlock* codeBlock)
+        {
+            CTI cti(machine, exec, codeBlock);
             return cti.privateCompileStringLengthTrampoline();
         }
@@ -336 +339 @@
         static void patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress);
 
-        static void compilePatchGetArrayLength(Machine* machine, CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress)
-        {
-            CTI cti(machine, callFrame, codeBlock);
+        static void compilePatchGetArrayLength(Machine* machine, ExecState* exec, CodeBlock* codeBlock, void* returnAddress)
+        {
+            CTI cti(machine, exec, codeBlock);
             return cti.privateCompilePatchGetArrayLength(returnAddress);
         }
 
-        inline static JSValue* execute(void* code, RegisterFile* registerFile, CallFrame* callFrame, JSGlobalData* globalData, JSValue** exception)
-        {
-            return ctiTrampoline(code, registerFile, callFrame, exception, Profiler::enabledProfilerReference(), globalData);
+        inline static JSValue* execute(void* code, RegisterFile* registerFile, Register* r, JSGlobalData* globalData, JSValue** exception)
+        {
+            return ctiTrampoline(code, registerFile, r, exception, Profiler::enabledProfilerReference(), globalData);
         }
 
     private:
-        CTI(Machine*, CallFrame*, CodeBlock*);
+        CTI(Machine*, ExecState*, CodeBlock*);
         
         bool isConstant(int src);
-        JSValue* getConstant(CallFrame*, int src);
+        JSValue* getConstant(ExecState*, int src);
 
         void privateCompileMainPass();
@@ -427 +430 @@
         X86Assembler m_jit;
         Machine* m_machine;
-        CallFrame* m_callFrame;
+        ExecState* m_exec;
         CodeBlock* m_codeBlock;
 

trunk/JavaScriptCore/VM/CodeBlock.h

@@ -162 +162 @@
                 
                 SourceCode source = makeSource(evalSource);
-                evalNode = exec->globalData().parser->parse<EvalNode>(exec, source, &errLine, &errMsg);
+                evalNode = exec->parser()->parse<EvalNode>(exec, source, &errLine, &errMsg);
                 if (evalNode) {
                     if (evalSource.size() < maxCacheableSourceLength && (*scopeChain->begin())->isVariableObject() && cacheMap.size() < maxCacheEntries)

trunk/JavaScriptCore/VM/CodeGenerator.cpp

@@ -719 +719 @@
             && src1->isTemporary()
             && static_cast<unsigned>(src2->index()) < m_codeBlock->constantRegisters.size()
-            && m_codeBlock->constantRegisters[src2->index()].jsValue(m_scopeChain->globalObject()->globalExec())->isString()) {
-            const UString& value = static_cast<JSString*>(m_codeBlock->constantRegisters[src2->index()].jsValue(m_scopeChain->globalObject()->globalExec()))->value();
+            && m_codeBlock->constantRegisters[src2->index()].jsValue(globalExec())->isString()) {
+            const UString& value = static_cast<JSString*>(m_codeBlock->constantRegisters[src2->index()].jsValue(globalExec()))->value();
             if (value == "undefined") {
                 rewindUnaryOp();
@@ -783 +783 @@
     // Later we can do the extra work to handle that like the other cases.
     if (number == HashTraits<double>::emptyValue() || HashTraits<double>::isDeletedValue(number))
-        return emitLoad(dst, jsNumber(globalData(), number));
+        return emitLoad(dst, jsNumber(globalExec(), number));
     JSValue*& valueInMap = m_numberMap.add(number, 0).first->second;
     if (!valueInMap)
-        valueInMap = jsNumber(globalData(), number);
+        valueInMap = jsNumber(globalExec(), number);
     return emitLoad(dst, valueInMap);
 }
@@ -794 +794 @@
     JSString*& valueInMap = m_stringMap.add(identifier.ustring().rep(), 0).first->second;
     if (!valueInMap)
-        valueInMap = jsOwnedString(globalData(), identifier.ustring());
+        valueInMap = jsOwnedString(globalExec(), identifier.ustring());
     return emitLoad(dst, valueInMap);
 }
@@ -818 +818 @@
     emitOpcode(op_unexpected_load);
     instructions().append(dst->index());
-    instructions().append(addUnexpectedConstant(jsNumber(globalData(), d)));
+    instructions().append(addUnexpectedConstant(jsNumber(globalExec(), d)));
     return dst;
 }
@@ -1189 +1189 @@
     emitExpressionInfo(divot, startOffset, endOffset);
     RefPtr<RegisterID> funcProto = newTemporary();
-    emitGetById(funcProto.get(), func, globalData()->propertyNames->prototype);
+    emitGetById(funcProto.get(), func, globalExec()->propertyNames().prototype);
 
     // Generate code for arguments.

trunk/JavaScriptCore/VM/CodeGenerator.h

@@ -321 +321 @@
         CodeType codeType() const { return m_codeType; }
 
+        ExecState* globalExec() { return m_scopeChain->globalObject()->globalExec(); }
+
     private:
         void emitOpcode(OpcodeID);

trunk/JavaScriptCore/VM/Machine.cpp

@@ -163 +163 @@
 }
 
-static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static inline bool jsLess(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
@@ -173 +173 @@
         return n1 < n2;
 
-    Machine* machine = callFrame->machine();
+    Machine* machine = exec->machine();
     if (machine->isJSString(v1) && machine->isJSString(v2))
         return static_cast<const JSString*>(v1)->value() < static_cast<const JSString*>(v2)->value();
@@ -179 +179 @@
     JSValue* p1;
     JSValue* p2;
-    bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
-    bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
+    bool wasNotString1 = v1->getPrimitiveNumber(exec, n1, p1);
+    bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
 
     if (wasNotString1 | wasNotString2)
@@ -188 +188 @@
 }
 
-static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static inline bool jsLessEq(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
@@ -198 +198 @@
         return n1 <= n2;
 
-    Machine* machine = callFrame->machine();
+    Machine* machine = exec->machine();
     if (machine->isJSString(v1) && machine->isJSString(v2))
         return !(static_cast<const JSString*>(v2)->value() < static_cast<const JSString*>(v1)->value());
@@ -204 +204 @@
     JSValue* p1;
     JSValue* p2;
-    bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
-    bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
+    bool wasNotString1 = v1->getPrimitiveNumber(exec, n1, p1);
+    bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
 
     if (wasNotString1 | wasNotString2)
@@ -213 +213 @@
 }
 
-static NEVER_INLINE JSValue* jsAddSlowCase(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static NEVER_INLINE JSValue* jsAddSlowCase(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     // exception for the Date exception in defaultValue()
-    JSValue* p1 = v1->toPrimitive(callFrame);
-    JSValue* p2 = v2->toPrimitive(callFrame);
+    JSValue* p1 = v1->toPrimitive(exec);
+    JSValue* p2 = v2->toPrimitive(exec);
 
     if (p1->isString() || p2->isString()) {
-        RefPtr<UString::Rep> value = concatenate(p1->toString(callFrame).rep(), p2->toString(callFrame).rep());
+        RefPtr<UString::Rep> value = concatenate(p1->toString(exec).rep(), p2->toString(exec).rep());
         if (!value)
-            return throwOutOfMemoryError(callFrame);
-        return jsString(callFrame, value.release());
-    }
-
-    return jsNumber(callFrame, p1->toNumber(callFrame) + p2->toNumber(callFrame));
+            return throwOutOfMemoryError(exec);
+        return jsString(exec, value.release());
+    }
+
+    return jsNumber(exec, p1->toNumber(exec) + p2->toNumber(exec));
 }
 
@@ -238 +238 @@
 //    4000    Add case: 3 5
 
-static ALWAYS_INLINE JSValue* jsAdd(CallFrame* callFrame, JSValue* v1, JSValue* v2)
+static ALWAYS_INLINE JSValue* jsAdd(ExecState* exec, JSValue* v1, JSValue* v2)
 {
     double left;
@@ -245 +245 @@
     bool rightIsNumber = fastIsNumber(v2, right);
     if (rightIsNumber && fastIsNumber(v1, left))
-        return jsNumber(callFrame, left + right);
+        return jsNumber(exec, left + right);
     
     bool leftIsString = v1->isString();
@@ -251 +251 @@
         RefPtr<UString::Rep> value = concatenate(static_cast<JSString*>(v1)->value().rep(), static_cast<JSString*>(v2)->value().rep());
         if (!value)
-            return throwOutOfMemoryError(callFrame);
-        return jsString(callFrame, value.release());
+            return throwOutOfMemoryError(exec);
+        return jsString(exec, value.release());
     }
 
@@ -261 +261 @@
 
         if (!value)
-            return throwOutOfMemoryError(callFrame);
-        return jsString(callFrame, value.release());
+            return throwOutOfMemoryError(exec);
+        return jsString(exec, value.release());
     }
 
     // All other cases are pretty uncommon
-    return jsAddSlowCase(callFrame, v1, v2);
-}
-
-static JSValue* jsTypeStringForValue(CallFrame* callFrame, JSValue* v)
+    return jsAddSlowCase(exec, v1, v2);
+}
+
+static JSValue* jsTypeStringForValue(ExecState* exec, JSValue* v)
 {
     if (v->isUndefined())
-        return jsNontrivialString(callFrame, "undefined");
+        return jsNontrivialString(exec, "undefined");
     if (v->isBoolean())
-        return jsNontrivialString(callFrame, "boolean");
+        return jsNontrivialString(exec, "boolean");
     if (v->isNumber())
-        return jsNontrivialString(callFrame, "number");
+        return jsNontrivialString(exec, "number");
     if (v->isString())
-        return jsNontrivialString(callFrame, "string");
+        return jsNontrivialString(exec, "string");
     if (v->isObject()) {
         // Return "undefined" for objects that should be treated
         // as null when doing comparisons.
         if (static_cast<JSObject*>(v)->structureID()->typeInfo().masqueradesAsUndefined())
-            return jsNontrivialString(callFrame, "undefined");
+            return jsNontrivialString(exec, "undefined");
         CallData callData;
         if (static_cast<JSObject*>(v)->getCallData(callData) != CallTypeNone)
-            return jsNontrivialString(callFrame, "function");
-    }
-    return jsNontrivialString(callFrame, "object");
+            return jsNontrivialString(exec, "function");
+    }
+    return jsNontrivialString(exec, "object");
 }
 
@@ -319 +319 @@
 }
 
-NEVER_INLINE bool Machine::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolve(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
 
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ScopeChainNode* scopeChain = this->scopeChain(r);
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     Identifier& ident = codeBlock->identifiers[property];
     do {
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
-            exceptionValue = callFrame->globalData().exception;
+        if (o->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
+            exceptionValue = exec->exception();
             if (exceptionValue)
                 return false;
-            callFrame[dst] = result;
+            r[dst] = result;
             return true;
         }
     } while (++iter != end);
-    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
-{
-    CodeBlock* codeBlock = callFrame->codeBlock();
+NEVER_INLINE bool Machine::resolveSkip(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
+{
+    CodeBlock* codeBlock = this->codeBlock(r);
 
     int dst = (vPC + 1)->u.operand;
@@ -355 +355 @@
     int skip = (vPC + 3)->u.operand + codeBlock->needsFullScopeChain;
 
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ScopeChainNode* scopeChain = this->scopeChain(r);
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -367 +367 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
-            exceptionValue = callFrame->globalData().exception;
+        if (o->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
+            exceptionValue = exec->exception();
             if (exceptionValue)
                 return false;
-            callFrame[dst] = result;
+            r[dst] = result;
             return true;
         }
     } while (++iter != end);
-    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolveGlobal(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
@@ -390 +390 @@
 
     if (structureID == globalObject->structureID()) {
-        callFrame[dst] = globalObject->getDirectOffset(offset);
+        r[dst] = globalObject->getDirectOffset(offset);
         return true;
     }
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     Identifier& ident = codeBlock->identifiers[property];
     PropertySlot slot(globalObject);
-    if (globalObject->getPropertySlot(callFrame, ident, slot)) {
-        JSValue* result = slot.getValue(callFrame, ident);
+    if (globalObject->getPropertySlot(exec, ident, slot)) {
+        JSValue* result = slot.getValue(exec, ident);
         if (slot.isCacheable()) {
             if (vPC[4].u.structureID)
@@ -405 +405 @@
             vPC[4] = globalObject->structureID();
             vPC[5] = slot.cachedOffset();
-            callFrame[dst] = result;
+            r[dst] = result;
             return true;
         }
 
-        exceptionValue = callFrame->globalData().exception;
+        exceptionValue = exec->exception();
         if (exceptionValue)
             return false;
-        callFrame[dst] = result;
+        r[dst] = result;
         return true;
     }
 
-    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
     return false;
 }
 
-ALWAYS_INLINE static JSValue* inlineResolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain)
+ALWAYS_INLINE static JSValue* inlineResolveBase(ExecState* exec, Identifier& property, ScopeChainNode* scopeChain)
 {
     ScopeChainIterator iter = scopeChain->begin();
@@ -432 +432 @@
     while (true) {
         base = *iter;
-        if (next == end || base->getPropertySlot(callFrame, property, slot))
+        if (next == end || base->getPropertySlot(exec, property, slot))
             return base;
 
@@ -443 +443 @@
 }
 
-NEVER_INLINE void Machine::resolveBase(CallFrame* callFrame, Instruction* vPC)
+NEVER_INLINE void Machine::resolveBase(ExecState* exec, Instruction* vPC, Register* r)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
-    callFrame[dst] = inlineResolveBase(callFrame, callFrame->codeBlock()->identifiers[property], callFrame->scopeChain());
-}
-
-NEVER_INLINE bool Machine::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+    CodeBlock* codeBlock = this->codeBlock(r);
+    ScopeChainNode* scopeChain = this->scopeChain(r);
+    r[dst] = inlineResolveBase(exec, codeBlock->identifiers[property], scopeChain);
+}
+
+NEVER_INLINE bool Machine::resolveBaseAndProperty(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
@@ -456 +458 @@
     int property = (vPC + 3)->u.operand;
 
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ScopeChainNode* scopeChain = this->scopeChain(r);
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -464 +466 @@
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     Identifier& ident = codeBlock->identifiers[property];
     JSObject* base;
@@ -470 +472 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
-            exceptionValue = callFrame->globalData().exception;
+        if (base->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
+            exceptionValue = exec->exception();
             if (exceptionValue)
                 return false;
-            callFrame[propDst] = result;
-            callFrame[baseDst] = base;
+            r[propDst] = result;
+            r[baseDst] = base;
             return true;
         }
@@ -482 +484 @@
     } while (iter != end);
 
-    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolveBaseAndFunc(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
@@ -492 +494 @@
     int property = (vPC + 3)->u.operand;
 
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ScopeChainNode* scopeChain = this->scopeChain(r);
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -500 +502 @@
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     Identifier& ident = codeBlock->identifiers[property];
     JSObject* base;
@@ -506 +508 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(callFrame, ident, slot)) {            
+        if (base->getPropertySlot(exec, ident, slot)) {            
             // ECMA 11.2.3 says that if we hit an activation the this value should be null.
             // However, section 10.2.3 says that in the case where the value provided
@@ -514 +516 @@
             // that in host objects you always get a valid object for this.
             // We also handle wrapper substitution for the global object at the same time.
-            JSObject* thisObj = base->toThisObject(callFrame);
-            JSValue* result = slot.getValue(callFrame, ident);
-            exceptionValue = callFrame->globalData().exception;
+            JSObject* thisObj = base->toThisObject(exec);
+            JSValue* result = slot.getValue(exec, ident);
+            exceptionValue = exec->exception();
             if (exceptionValue)
                 return false;
 
-            callFrame[baseDst] = thisObj;
-            callFrame[funcDst] = result;
+            r[baseDst] = thisObj;
+            r[funcDst] = result;
             return true;
         }
@@ -527 +529 @@
     } while (iter != end);
 
-    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
     return false;
 }
 
-ALWAYS_INLINE CallFrame* Machine::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)
-{
-    Register* r = callFrame->registers();
+ALWAYS_INLINE Register* slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* r, size_t registerOffset, int argc)
+{
     Register* newEnd = r + registerOffset + newCodeBlock->numCalleeRegisters;
 
@@ -565 +566 @@
     }
 
-    return callFrame;
-}
-
-static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
+    return r;
+}
+
+static NEVER_INLINE bool isNotObject(ExecState* exec, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
 {
     if (value->isObject())
         return false;
-    exceptionData = createInvalidParamError(callFrame, forInstanceOf ? "instanceof" : "in" , value, vPC, codeBlock);
+    exceptionData = createInvalidParamError(exec, forInstanceOf ? "instanceof" : "in" , value, vPC, codeBlock);
     return true;
 }
 
-NEVER_INLINE JSValue* Machine::callEval(CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, int argv, int argc, JSValue*& exceptionValue)
+NEVER_INLINE JSValue* Machine::callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, Register* r, int argv, int argc, JSValue*& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
 
-    JSValue* program = callFrame[argv + 1].jsValue(callFrame);
+    JSValue* program = r[argv + 1].jsValue(exec);
 
     if (!program->isString())
@@ -588 +589 @@
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(callFrame, scopeChain->globalObject()->evalFunction());
+        (*profiler)->willExecute(exec, scopeChain->globalObject()->evalFunction());
 
     UString programSource = static_cast<JSString*>(program)->value();
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
-    RefPtr<EvalNode> evalNode = codeBlock->evalCodeCache.get(callFrame, programSource, scopeChain, exceptionValue);
+    CodeBlock* codeBlock = this->codeBlock(r);
+    RefPtr<EvalNode> evalNode = codeBlock->evalCodeCache.get(exec, programSource, scopeChain, exceptionValue);
 
     JSValue* result = 0;
     if (evalNode)
-        result = callFrame->globalData().machine->execute(evalNode.get(), callFrame, thisObj, callFrame->registers() - registerFile->start() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
+        result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - registerFile->start() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
 
     if (*profiler)
-        (*profiler)->didExecute(callFrame, scopeChain->globalObject()->evalFunction());
+        (*profiler)->didExecute(exec, scopeChain->globalObject()->evalFunction());
 
     return result;
@@ -652 +653 @@
 #ifndef NDEBUG
 
-void Machine::dumpCallFrame(const RegisterFile* registerFile, CallFrame* callFrame)
-{
-    JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject();
-
-    CodeBlock* codeBlock = callFrame->codeBlock();
+void Machine::dumpCallFrame(const RegisterFile* registerFile, const Register* r)
+{
+    JSGlobalObject* globalObject = scopeChain(r)->globalObject();
+
+    CodeBlock* codeBlock = this->codeBlock(r);
     codeBlock->dump(globalObject->globalExec());
 
-    dumpRegisters(registerFile, callFrame);
-}
-
-void Machine::dumpRegisters(const RegisterFile* registerFile, CallFrame* callFrame)
+    dumpRegisters(registerFile, r);
+}
+
+void Machine::dumpRegisters(const RegisterFile* registerFile, const Register* r)
 {
     printf("Register frame: \n\n");
@@ -669 +670 @@
     printf("----------------------------------------------------\n");
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     const Register* it;
     const Register* end;
@@ -683 +684 @@
     }
     
-    it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->numParameters;
+    it = r - RegisterFile::CallFrameHeaderSize - codeBlock->numParameters;
     printf("[this]                     | %10p | %10p \n", it, (*it).v()); ++it;
     end = it + max(codeBlock->numParameters - 1, 0); // - 1 to skip "this"
@@ -739 +740 @@
 #endif
 
+//#if !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
+
 bool Machine::isOpcode(Opcode opcode)
 {
@@ -750 +753 @@
 }
 
-NEVER_INLINE bool Machine::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
+//#endif
+
+NEVER_INLINE bool Machine::unwindCallFrame(ExecState*& exec, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock, Register*& r)
 {
     CodeBlock* oldCodeBlock = codeBlock;
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
-
-    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
-        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
-        if (callFrame->callee())
+    ScopeChainNode* scopeChain = this->scopeChain(r);
+
+    if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
+        DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
+        if (r[RegisterFile::Callee].jsValue(exec))
             debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->lastLine());
         else
@@ -764 +769 @@
 
     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {
-        if (callFrame->callee())
-            profiler->didExecute(callFrame, callFrame->callee());
+        if (r[RegisterFile::Callee].jsValue(exec))
+            profiler->didExecute(exec, static_cast<JSObject*>(r[RegisterFile::Callee].jsValue(exec)));
         else
-            profiler->didExecute(callFrame, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
+            profiler->didExecute(exec, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
     }
 
@@ -774 +779 @@
         while (!scopeChain->object->isObject(&JSActivation::info))
             scopeChain = scopeChain->pop();
-        static_cast<JSActivation*>(scopeChain->object)->copyRegisters(callFrame->optionalCalleeArguments());
-    } else if (Arguments* arguments = callFrame->optionalCalleeArguments()) {
+        JSActivation* activation = static_cast<JSActivation*>(scopeChain->object);
+        ASSERT(activation->isObject(&JSActivation::info));
+
+        Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+        ASSERT(!arguments || arguments->isObject(&Arguments::info));
+
+        activation->copyRegisters(arguments);
+    } else if (Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue())) {
+        ASSERT(arguments->isObject(&Arguments::info));
         if (!arguments->isTornOff())
             arguments->copyRegisters();
@@ -783 +795 @@
         scopeChain->deref();
 
-    void* returnPC = callFrame->returnPC();
-    callFrame = callFrame->callerFrame();
-    if (callFrame->hasHostCallFrameFlag())
+    void* returnPC = r[RegisterFile::ReturnPC].v();
+    r = r[RegisterFile::CallerRegisters].r();
+    exec = CallFrame::create(r);
+    if (isHostCallFrame(r))
         return false;
 
-    codeBlock = callFrame->codeBlock();
+    codeBlock = this->codeBlock(r);
     vPC = vPCForPC(codeBlock, returnPC);
     return true;
 }
 
-NEVER_INLINE Instruction* Machine::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
+NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue*& exceptionValue, const Instruction* vPC, Register*& r, bool explicitThrow)
 {
     // Set up the exception object
     
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     if (exceptionValue->isObject()) {
         JSObject* exception = static_cast<JSObject*>(exceptionValue);
         if (exception->isNotAnObjectErrorStub()) {
-            exception = createNotAnObjectError(callFrame, static_cast<JSNotAnObjectErrorStub*>(exception), vPC, codeBlock);
+            exception = createNotAnObjectError(exec, static_cast<JSNotAnObjectErrorStub*>(exception), vPC, codeBlock);
             exceptionValue = exception;
         } else {
-            if (!exception->hasProperty(callFrame, Identifier(callFrame, "line")) && 
-                !exception->hasProperty(callFrame, Identifier(callFrame, "sourceId")) && 
-                !exception->hasProperty(callFrame, Identifier(callFrame, "sourceURL")) && 
-                !exception->hasProperty(callFrame, Identifier(callFrame, expressionBeginOffsetPropertyName)) && 
-                !exception->hasProperty(callFrame, Identifier(callFrame, expressionCaretOffsetPropertyName)) && 
-                !exception->hasProperty(callFrame, Identifier(callFrame, expressionEndOffsetPropertyName))) {
+            if (!exception->hasProperty(exec, Identifier(exec, "line")) && 
+                !exception->hasProperty(exec, Identifier(exec, "sourceId")) && 
+                !exception->hasProperty(exec, Identifier(exec, "sourceURL")) && 
+                !exception->hasProperty(exec, Identifier(exec, expressionBeginOffsetPropertyName)) && 
+                !exception->hasProperty(exec, Identifier(exec, expressionCaretOffsetPropertyName)) && 
+                !exception->hasProperty(exec, Identifier(exec, expressionEndOffsetPropertyName))) {
                 if (explicitThrow) {
                     int startOffset = 0;
@@ -815 +828 @@
                     int divotPoint = 0;
                     int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
-                    exception->putWithAttributes(callFrame, Identifier(callFrame, "line"), jsNumber(callFrame, line), ReadOnly | DontDelete);
+                    exception->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, line), ReadOnly | DontDelete);
                     
                     // We only hit this path for error messages and throw statements, which don't have a specific failure position
                     // So we just give the full range of the error/throw statement.
-                    exception->putWithAttributes(callFrame, Identifier(callFrame, expressionBeginOffsetPropertyName), jsNumber(callFrame, divotPoint - startOffset), ReadOnly | DontDelete);
-                    exception->putWithAttributes(callFrame, Identifier(callFrame, expressionEndOffsetPropertyName), jsNumber(callFrame, divotPoint + endOffset), ReadOnly | DontDelete);
+                    exception->putWithAttributes(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
+                    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
                 } else
-                    exception->putWithAttributes(callFrame, Identifier(callFrame, "line"), jsNumber(callFrame, codeBlock->lineNumberForVPC(vPC)), ReadOnly | DontDelete);
-                exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceId"), jsNumber(callFrame, codeBlock->ownerNode->sourceID()), ReadOnly | DontDelete);
-                exception->putWithAttributes(callFrame, Identifier(callFrame, "sourceURL"), jsOwnedString(callFrame, codeBlock->ownerNode->sourceURL()), ReadOnly | DontDelete);
+                    exception->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, codeBlock->lineNumberForVPC(vPC)), ReadOnly | DontDelete);
+                exception->putWithAttributes(exec, Identifier(exec, "sourceId"), jsNumber(exec, codeBlock->ownerNode->sourceID()), ReadOnly | DontDelete);
+                exception->putWithAttributes(exec, Identifier(exec, "sourceURL"), jsOwnedString(exec, codeBlock->ownerNode->sourceURL()), ReadOnly | DontDelete);
             }
             
             if (exception->isWatchdogException()) {
-                while (unwindCallFrame(callFrame, exceptionValue, vPC, codeBlock)) {
+                while (unwindCallFrame(exec, exceptionValue, vPC, codeBlock, r)) {
                     // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.
                 }
@@ -836 +849 @@
     }
 
-    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
-        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
+    if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
+        ScopeChainNode* scopeChain = this->scopeChain(r);
+        DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
         debugger->exception(debuggerCallFrame, codeBlock->ownerNode->sourceID(), codeBlock->lineNumberForVPC(vPC));
     }
@@ -847 +861 @@
 
     while (!codeBlock->getHandlerForVPC(vPC, handlerVPC, scopeDepth)) {
-        if (!unwindCallFrame(callFrame, exceptionValue, vPC, codeBlock))
+        if (!unwindCallFrame(exec, exceptionValue, vPC, codeBlock, r))
             return 0;
     }
@@ -853 +867 @@
     // Now unwind the scope chain within the exception handler's call frame.
 
-    ScopeChain sc(callFrame->scopeChain());
+    ScopeChain sc(this->scopeChain(r));
     int scopeDelta = depth(codeBlock, sc) - scopeDepth;
     ASSERT(scopeDelta >= 0);
     while (scopeDelta--)
         sc.pop();
-    callFrame->setScopeChain(sc.node());
+    r[RegisterFile::ScopeChain] = sc.node();
 
     return handlerVPC;
 }
 
-class DynamicGlobalObjectScope : Noncopyable {
+class DynamicGlobalObjectScope {
 public:
-    DynamicGlobalObjectScope(CallFrame* callFrame, JSGlobalObject* dynamicGlobalObject) 
-        : m_dynamicGlobalObjectSlot(callFrame->globalData().dynamicGlobalObject)
-        , m_savedDynamicGlobalObject(m_dynamicGlobalObjectSlot)
+    DynamicGlobalObjectScope(ExecState* exec, JSGlobalObject* dynamicGlobalObject) 
+        : m_exec(exec)
+        , m_savedGlobalObject(exec->globalData().dynamicGlobalObject)
     {
-        m_dynamicGlobalObjectSlot = dynamicGlobalObject;
+        exec->globalData().dynamicGlobalObject = dynamicGlobalObject;
     }
 
     ~DynamicGlobalObjectScope()
     {
-        m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
+        m_exec->globalData().dynamicGlobalObject = m_savedGlobalObject;
     }
 
 private:
-    JSGlobalObject*& m_dynamicGlobalObjectSlot;
-    JSGlobalObject* m_savedDynamicGlobalObject;
+    ExecState* m_exec;
+    JSGlobalObject* m_savedGlobalObject;
 };
 
-JSValue* Machine::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
-{
-    ASSERT(!scopeChain->globalData->exception);
+JSValue* Machine::execute(ProgramNode* programNode, ExecState* exec, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
+{
+    ASSERT(!exec->hadException());
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
@@ -896 +910 @@
     Register* newEnd = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->numCalleeRegisters;
     if (!m_registerFile.grow(newEnd)) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject());
+    DynamicGlobalObjectScope globalObjectScope(exec, scopeChain->globalObject());
 
     JSGlobalObject* lastGlobalObject = m_registerFile.globalObject();
-    JSGlobalObject* globalObject = callFrame->dynamicGlobalObject();
+    JSGlobalObject* globalObject = exec->dynamicGlobalObject();
     globalObject->copyGlobalsTo(m_registerFile);
 
-    CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize);
-    newCallFrame[codeBlock->thisRegister] = thisObj;
-    newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0);
+    Register* r = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize;
+    r[codeBlock->thisRegister] = thisObj;
+    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(0), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain)
@@ -915 +929 @@
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(callFrame, programNode->sourceURL(), programNode->lineNo());
+        (*profiler)->willExecute(exec, programNode->sourceURL(), programNode->lineNo());
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, callFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, callFrame, scopeChain->globalData, exception);
+        CTI::compile(this, exec, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, callFrame, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
 #endif
     m_reentryDepth--;
@@ -930 +944 @@
 
     if (*profiler)
-        (*profiler)->didExecute(callFrame, programNode->sourceURL(), programNode->lineNo());
+        (*profiler)->didExecute(exec, programNode->sourceURL(), programNode->lineNo());
 
     if (m_reentryDepth && lastGlobalObject && globalObject != lastGlobalObject)
@@ -940 +954 @@
 }
 
-JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
-{
-    ASSERT(!scopeChain->globalData->exception);
+JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, ExecState* exec, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
+{
+    ASSERT(!exec->hadException());
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
@@ -953 +967 @@
 
     if (!m_registerFile.grow(oldEnd + argc)) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject());
-
-    CallFrame* newCallFrame = CallFrame::create(oldEnd);
+    DynamicGlobalObjectScope globalObjectScope(exec, exec->globalData().dynamicGlobalObject ? exec->globalData().dynamicGlobalObject : scopeChain->globalObject());
+
+    Register* argv = oldEnd;
     size_t dst = 0;
-    newCallFrame[0] = thisObj;
+    argv[dst] = thisObj;
+
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        newCallFrame[++dst] = *it;
+        argv[++dst] = *it;
 
     CodeBlock* codeBlock = &functionBodyNode->byteCode(scopeChain);
-    callFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc);
-    if (UNLIKELY(!callFrame)) {
-        *exception = createStackOverflowError(callFrame);
+    Register* r = slideRegisterWindowForCall(codeBlock, &m_registerFile, argv, argc + RegisterFile::CallFrameHeaderSize, argc);
+    if (UNLIKELY(!r)) {
+        *exception = createStackOverflowError(exec);
         m_registerFile.shrink(oldEnd);
         return jsNull();
     }
     // a 0 codeBlock indicates a built-in caller
-    callFrame->init(codeBlock, 0, scopeChain, newCallFrame->addHostCallFrameFlag(), 0, argc, function);
+    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(exec->registers()), 0, argc, function);
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(callFrame, function);
+        (*profiler)->willExecute(exec, function);
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, callFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, callFrame, scopeChain->globalData, exception);
+        CTI::compile(this, exec, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, callFrame, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
 #endif
     m_reentryDepth--;
@@ -996 +1011 @@
 }
 
-JSValue* Machine::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
-{
-    return execute(evalNode, callFrame, thisObj, m_registerFile.size() + evalNode->byteCode(scopeChain).numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception);
-}
-
-JSValue* Machine::execute(EvalNode* evalNode, CallFrame* callFrame, JSObject* thisObj, int registerOffset, ScopeChainNode* scopeChain, JSValue** exception)
-{
-    ASSERT(!scopeChain->globalData->exception);
+JSValue* Machine::execute(EvalNode* evalNode, ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception)
+{
+    return execute(evalNode, exec, thisObj, m_registerFile.size() + evalNode->byteCode(scopeChain).numParameters + RegisterFile::CallFrameHeaderSize, scopeChain, exception);
+}
+
+JSValue* Machine::execute(EvalNode* evalNode, ExecState* exec, JSObject* thisObj, int registerOffset, ScopeChainNode* scopeChain, JSValue** exception)
+{
+    ASSERT(!exec->hadException());
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject());
+    DynamicGlobalObjectScope globalObjectScope(exec, exec->globalData().dynamicGlobalObject ? exec->globalData().dynamicGlobalObject : scopeChain->globalObject());
 
     EvalCodeBlock* codeBlock = &evalNode->byteCode(scopeChain);
@@ -1031 +1046 @@
         for (Node::VarStack::const_iterator it = varStack.begin(); it != varStackEnd; ++it) {
             const Identifier& ident = (*it).first;
-            if (!variableObject->hasProperty(callFrame, ident)) {
+            if (!variableObject->hasProperty(exec, ident)) {
                 PutPropertySlot slot;
-                variableObject->put(callFrame, ident, jsUndefined(), slot);
+                variableObject->put(exec, ident, jsUndefined(), slot);
             }
         }
@@ -1041 +1056 @@
         for (Node::FunctionStack::const_iterator it = functionStack.begin(); it != functionStackEnd; ++it) {
             PutPropertySlot slot;
-            variableObject->put(callFrame, (*it)->m_ident, (*it)->makeFunction(callFrame, scopeChain), slot);
+            variableObject->put(exec, (*it)->m_ident, (*it)->makeFunction(exec, scopeChain), slot);
         }
 
@@ -1049 +1064 @@
     Register* newEnd = m_registerFile.start() + registerOffset + codeBlock->numCalleeRegisters;
     if (!m_registerFile.grow(newEnd)) {
-        *exception = createStackOverflowError(callFrame);
+        *exception = createStackOverflowError(exec);
         return jsNull();
     }
 
-    CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + registerOffset);
+    Register* r = m_registerFile.start() + registerOffset;
 
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame[codeBlock->thisRegister] = thisObj;
-    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0);
+    r[codeBlock->thisRegister] = thisObj;
+    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(exec->registers()), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain)
@@ -1064 +1079 @@
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(newCallFrame, evalNode->sourceURL(), evalNode->lineNo());
+        (*profiler)->willExecute(exec, evalNode->sourceURL(), evalNode->lineNo());
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, newCallFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
+        CTI::compile(this, exec, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
 #endif
     m_reentryDepth--;
@@ -1079 +1094 @@
 
     if (*profiler)
-        (*profiler)->didExecute(callFrame, evalNode->sourceURL(), evalNode->lineNo());
+        (*profiler)->didExecute(exec, evalNode->sourceURL(), evalNode->lineNo());
 
     m_registerFile.shrink(oldEnd);
@@ -1085 +1100 @@
 }
 
-NEVER_INLINE void Machine::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
-{
-    Debugger* debugger = callFrame->dynamicGlobalObject()->debugger();
+NEVER_INLINE void Machine::debug(ExecState* exec, Register* r, DebugHookID debugHookID, int firstLine, int lastLine)
+{
+    Debugger* debugger = exec->dynamicGlobalObject()->debugger();
     if (!debugger)
         return;
 
+    CodeBlock* codeBlock = this->codeBlock(r);
+    ScopeChainNode* scopeChain = this->scopeChain(r);
+    DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, 0);
+
     switch (debugHookID) {
         case DidEnterCallFrame:
-            debugger->callEvent(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
+            debugger->callEvent(debuggerCallFrame, codeBlock->ownerNode->sourceID(), firstLine);
             return;
         case WillLeaveCallFrame:
-            debugger->returnEvent(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
+            debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
             return;
         case WillExecuteStatement:
-            debugger->atStatement(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
+            debugger->atStatement(debuggerCallFrame, codeBlock->ownerNode->sourceID(), firstLine);
             return;
         case WillExecuteProgram:
-            debugger->willExecuteProgram(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
+            debugger->willExecuteProgram(debuggerCallFrame, codeBlock->ownerNode->sourceID(), firstLine);
             return;
         case DidExecuteProgram:
-            debugger->didExecuteProgram(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
+            debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
             return;
         case DidReachBreakpoint:
-            debugger->didReachBreakpoint(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
+            debugger->didReachBreakpoint(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
             return;
     }
@@ -1198 +1217 @@
 }
 
-NEVER_INLINE ScopeChainNode* Machine::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
+NEVER_INLINE ScopeChainNode* Machine::createExceptionScope(ExecState* exec, const Instruction* vPC, Register* r)
 {
     int dst = (++vPC)->u.operand;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = this->codeBlock(r);
     Identifier& property = codeBlock->identifiers[(++vPC)->u.operand];
-    JSValue* value = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-    JSObject* scope = new (callFrame) JSStaticScopeObject(callFrame, property, value, DontDelete);
-    callFrame[dst] = scope;
-
-    return callFrame->scopeChain()->push(scope);
-}
-
-static StructureIDChain* cachePrototypeChain(CallFrame* callFrame, StructureID* structureID)
-{
-    JSValue* prototype = structureID->prototypeForLookup(callFrame);
+    JSValue* value = r[(++vPC)->u.operand].jsValue(exec);
+    JSObject* scope = new (exec) JSStaticScopeObject(exec, property, value, DontDelete);
+    r[dst] = scope;
+
+    return scopeChain(r)->push(scope);
+}
+
+static StructureIDChain* cachePrototypeChain(ExecState* exec, StructureID* structureID)
+{
+    JSValue* prototype = structureID->prototypeForLookup(exec);
     if (JSImmediate::isImmediate(prototype))
         return 0;
@@ -1220 +1239 @@
 }
 
-NEVER_INLINE void Machine::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Machine::tryCachePutByID(ExecState* exec, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
@@ -1272 +1291 @@
         StructureIDChain* chain = structureID->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(callFrame, structureID);
+            chain = cachePrototypeChain(exec, structureID);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
@@ -1297 +1316 @@
 }
 
-NEVER_INLINE void Machine::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Machine::tryCacheGetByID(ExecState* exec, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
@@ -1309 +1328 @@
     }
 
-    if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
+    if (isJSArray(baseValue) && propertyName == exec->propertyNames().length) {
         vPC[0] = getOpcode(op_get_array_length);
         return;
     }
 
-    if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) {
+    if (isJSString(baseValue) && propertyName == exec->propertyNames().length) {
         vPC[0] = getOpcode(op_get_string_length);
         return;
@@ -1356 +1375 @@
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
+    if (slot.slotBase() == structureID->prototypeForLookup(exec)) {
         ASSERT(slot.slotBase()->isObject());
 
@@ -1380 +1399 @@
     JSObject* o = static_cast<JSObject*>(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
+        JSValue* v = o->structureID()->prototypeForLookup(exec);
 
         // If we didn't find base in baseValue's prototype chain, then baseValue
@@ -1404 +1423 @@
     StructureIDChain* chain = structureID->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(callFrame, structureID);
+        chain = cachePrototypeChain(exec, structureID);
     ASSERT(chain);
 
@@ -1422 +1441 @@
 }
 
-JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
+JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, Register* r, JSValue** exception)
 {
     // One-time initialization of our address tables. We have to put this code
@@ -1447 +1466 @@
 #endif
 
-    JSGlobalData* globalData = &callFrame->globalData();
+#define exec CallFrame::create(r)
+
+    JSGlobalData* globalData = &exec->globalData();
     JSValue* exceptionValue = 0;
     Instruction* handlerVPC = 0;
 
-    Instruction* vPC = callFrame->codeBlock()->instructions.begin();
+    Instruction* vPC = this->codeBlock(r)->instructions.begin();
     Profiler** enabledProfilerReference = Profiler::enabledProfilerReference();
     unsigned tickCount = m_ticksUntilNextTimeoutCheck + 1;
@@ -1469 +1490 @@
 #define CHECK_FOR_TIMEOUT() \
     if (!--tickCount) { \
-        if ((exceptionValue = checkTimeout(callFrame->dynamicGlobalObject()))) \
+        if ((exceptionValue = checkTimeout(exec->dynamicGlobalObject()))) \
             goto vm_throw; \
         tickCount = m_ticksUntilNextTimeoutCheck; \
@@ -1475 +1496 @@
 
 #if HAVE(COMPUTED_GOTO)
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto *vPC->u.opcode
+    #define NEXT_OPCODE MACHINE_SAMPLING_sample(this->codeBlock(r), vPC); goto *vPC->u.opcode
 #if DUMP_OPCODE_STATS
     #define BEGIN_OPCODE(opcode) opcode: OpcodeStats::recordInstruction(opcode);
@@ -1483 +1504 @@
     NEXT_OPCODE;
 #else
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto interpreterLoopStart
+    #define NEXT_OPCODE MACHINE_SAMPLING_sample(this->codeBlock(r), vPC); goto interpreterLoopStart
 #if DUMP_OPCODE_STATS
     #define BEGIN_OPCODE(opcode) case opcode: OpcodeStats::recordInstruction(opcode);
@@ -1501 +1522 @@
         */
         int dst = (++vPC)->u.operand;
-        callFrame[dst] = constructEmptyObject(callFrame);
+        r[dst] = constructEmptyObject(exec);
 
         ++vPC;
@@ -1517 +1538 @@
         int firstArg = (++vPC)->u.operand;
         int argCount = (++vPC)->u.operand;
-        ArgList args(callFrame->registers() + firstArg, argCount);
-        callFrame[dst] = constructArray(callFrame, args);
+        ArgList args(r + firstArg, argCount);
+        r[dst] = constructArray(exec, args);
 
         ++vPC;
@@ -1532 +1553 @@
         int dst = (++vPC)->u.operand;
         int regExp = (++vPC)->u.operand;
-        callFrame[dst] = new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexps[regExp]);
+        r[dst] = new (globalData) RegExpObject(scopeChain(r)->globalObject()->regExpStructure(), codeBlock(r)->regexps[regExp]);
 
         ++vPC;
@@ -1544 +1565 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = callFrame[src];
+        r[dst] = r[src];
 
         ++vPC;
@@ -1557 +1578 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else {
-            JSValue* result = jsBoolean(equalSlowCase(callFrame, src1, src2));
+            JSValue* result = jsBoolean(equalSlowCase(exec, src1, src2));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1577 +1598 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
 
         if (src->isUndefinedOrNull()) {
-            callFrame[dst] = jsBoolean(true);
+            r[dst] = jsBoolean(true);
             ++vPC;
             NEXT_OPCODE;
         }
         
-        callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        r[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_OPCODE;
@@ -1597 +1618 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = jsBoolean(src1 != src2);
+            r[dst] = jsBoolean(src1 != src2);
         else {
-            JSValue* result = jsBoolean(!equalSlowCase(callFrame, src1, src2));
+            JSValue* result = jsBoolean(!equalSlowCase(exec, src1, src2));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1617 +1638 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
 
         if (src->isUndefinedOrNull()) {
-            callFrame[dst] = jsBoolean(false);
+            r[dst] = jsBoolean(false);
             ++vPC;
             NEXT_OPCODE;
         }
         
-        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !static_cast<JSCell*>(src)->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        r[dst] = jsBoolean(JSImmediate::isImmediate(src) || !static_cast<JSCell*>(src)->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_OPCODE;
@@ -1637 +1658 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         if (JSImmediate::areBothImmediate(src1, src2))
-            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
-            callFrame[dst] = jsBoolean(false);
+            r[dst] = jsBoolean(false);
         else
-            callFrame[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
+            r[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
 
         ++vPC;
@@ -1657 +1678 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
 
         if (JSImmediate::areBothImmediate(src1, src2))
-            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
-            callFrame[dst] = jsBoolean(true);
+            r[dst] = jsBoolean(true);
         else
-            callFrame[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
+            r[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
 
         ++vPC;
@@ -1678 +1699 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* result = jsBoolean(jsLess(callFrame, src1, src2));
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* result = jsBoolean(jsLess(exec, src1, src2));
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1695 +1716 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* result = jsBoolean(jsLessEq(callFrame, src1, src2));
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* result = jsBoolean(jsLessEq(exec, src1, src2));
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1711 +1732 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValue* v = r[srcDst].jsValue(exec);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
+            r[srcDst] = JSImmediate::incImmediateNumber(v);
         else {
-            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) + 1);
+            JSValue* result = jsNumber(exec, v->toNumber(exec) + 1);
             VM_CHECK_EXCEPTION();
-            callFrame[srcDst] = result;
+            r[srcDst] = result;
         }
 
@@ -1730 +1751 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValue* v = r[srcDst].jsValue(exec);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
+            r[srcDst] = JSImmediate::decImmediateNumber(v);
         else {
-            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) - 1);
+            JSValue* result = jsNumber(exec, v->toNumber(exec) - 1);
             VM_CHECK_EXCEPTION();
-            callFrame[srcDst] = result;
+            r[srcDst] = result;
         }
 
@@ -1751 +1772 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValue* v = r[srcDst].jsValue(exec);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            callFrame[dst] = v;
-            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
+            r[dst] = v;
+            r[srcDst] = JSImmediate::incImmediateNumber(v);
         } else {
-            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
+            JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = number;
-            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() + 1);
+            r[dst] = number;
+            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() + 1);
         }
 
@@ -1774 +1795 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = callFrame[srcDst].jsValue(callFrame);
+        JSValue* v = r[srcDst].jsValue(exec);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            callFrame[dst] = v;
-            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
+            r[dst] = v;
+            r[srcDst] = JSImmediate::decImmediateNumber(v);
         } else {
-            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
+            JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = number;
-            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() - 1);
+            r[dst] = number;
+            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() - 1);
         }
 
@@ -1797 +1818 @@
         int src = (++vPC)->u.operand;
 
-        JSValue* srcVal = callFrame[src].jsValue(callFrame);
+        JSValue* srcVal = r[src].jsValue(exec);
 
         if (LIKELY(JSImmediate::isNumber(srcVal) || static_cast<JSCell*>(srcVal)->structureID()->typeInfo().type() == NumberType)) {
-            callFrame[dst] = callFrame[src];
+            r[dst] = r[src];
         } else {
-            JSValue* result = srcVal->toJSNumber(callFrame);
+            JSValue* result = srcVal->toJSNumber(exec);
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1817 +1838 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
         double v;
         if (fastIsNumber(src, v))
-            callFrame[dst] = jsNumber(callFrame, -v);
+            r[dst] = jsNumber(exec, -v);
         else {
-            JSValue* result = jsNumber(callFrame, -src->toNumber(callFrame));
+            JSValue* result = jsNumber(exec, -src->toNumber(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1838 +1859 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            callFrame[dst] = JSImmediate::addImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::addImmediateNumbers(src1, src2);
         else {
-            JSValue* result = jsAdd(callFrame, src1, src2);
+            JSValue* result = jsAdd(exec, src1, src2);
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
         vPC += 2;
@@ -1857 +1878 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         double left;
         double right;
         if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left * right);
+            r[dst] = jsNumber(exec, left * right);
         else {
-            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) * src2->toNumber(callFrame));
+            JSValue* result = jsNumber(exec, src1->toNumber(exec) * src2->toNumber(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1880 +1901 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* dividend = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* divisor = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* dividend = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* divisor = r[(++vPC)->u.operand].jsValue(exec);
         double left;
         double right;
         if (fastIsNumber(dividend, left) && fastIsNumber(divisor, right))
-            callFrame[dst] = jsNumber(callFrame, left / right);
+            r[dst] = jsNumber(exec, left / right);
         else {
-            JSValue* result = jsNumber(callFrame, dividend->toNumber(callFrame) / divisor->toNumber(callFrame));
+            JSValue* result = jsNumber(exec, dividend->toNumber(exec) / divisor->toNumber(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
         ++vPC;
@@ -1905 +1926 @@
         int divisor = (++vPC)->u.operand;
 
-        JSValue* dividendValue = callFrame[dividend].jsValue(callFrame);
-        JSValue* divisorValue = callFrame[divisor].jsValue(callFrame);
+        JSValue* dividendValue = r[dividend].jsValue(exec);
+        JSValue* divisorValue = r[divisor].jsValue(exec);
 
         if (JSImmediate::areBothImmediateNumbers(dividendValue, divisorValue) && divisorValue != JSImmediate::from(0)) {
-            callFrame[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
+            r[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
             ++vPC;
             NEXT_OPCODE;
         }
 
-        double d = dividendValue->toNumber(callFrame);
-        JSValue* result = jsNumber(callFrame, fmod(d, divisorValue->toNumber(callFrame)));
+        double d = dividendValue->toNumber(exec);
+        JSValue* result = jsNumber(exec, fmod(d, divisorValue->toNumber(exec)));
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1929 +1950 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         double left;
         double right;
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            callFrame[dst] = JSImmediate::subImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::subImmediateNumbers(src1, src2);
         else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left - right);
+            r[dst] = jsNumber(exec, left - right);
         else {
-            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) - src2->toNumber(callFrame));
+            JSValue* result = jsNumber(exec, src1->toNumber(exec) - src2->toNumber(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
         vPC += 2;
@@ -1953 +1974 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            callFrame[dst] = jsNumber(callFrame, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
+            r[dst] = jsNumber(exec, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            callFrame[dst] = jsNumber(callFrame, left << (right & 0x1f));
+            r[dst] = jsNumber(exec, left << (right & 0x1f));
         else {
-            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -1978 +1999 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            callFrame[dst] = jsNumber(callFrame, left >> (right & 0x1f));
+            r[dst] = jsNumber(exec, left >> (right & 0x1f));
         else {
-            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -2003 +2024 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
         if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
-            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else {
-            JSValue* result = jsNumber(callFrame, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -2024 +2045 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::andImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::andImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left & right);
+            r[dst] = jsNumber(exec, left & right);
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) & src2->toInt32(callFrame));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) & src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -2049 +2070 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left ^ right);
+            r[dst] = jsNumber(exec, left ^ right);
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) ^ src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -2074 +2095 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            callFrame[dst] = JSImmediate::orImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::orImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            callFrame[dst] = jsNumber(callFrame, left | right);
+            r[dst] = jsNumber(exec, left | right);
         else {
-            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) | src2->toInt32(callFrame));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) | src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
 
@@ -2098 +2119 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
         int32_t value;
         if (fastToInt32(src, value))
-            callFrame[dst] = jsNumber(callFrame, ~value);
+            r[dst] = jsNumber(exec, ~value);
         else {
-            JSValue* result = jsNumber(callFrame, ~src->toInt32(callFrame));
+            JSValue* result = jsNumber(exec, ~src->toInt32(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = result;
+            r[dst] = result;
         }
         ++vPC;
@@ -2118 +2139 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsBoolean(!callFrame[src].jsValue(callFrame)->toBoolean(callFrame));
+        JSValue* result = jsBoolean(!r[src].jsValue(exec)->toBoolean(exec));
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
 
         ++vPC;
@@ -2143 +2164 @@
         int baseProto = (++vPC)->u.operand;
 
-        JSValue* baseVal = callFrame[base].jsValue(callFrame);
-
-        if (isNotObject(callFrame, true, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
+        JSValue* baseVal = r[base].jsValue(exec);
+
+        if (isNotObject(exec, true, codeBlock(r), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
-        callFrame[dst] = jsBoolean(baseObj->structureID()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false);
+        r[dst] = jsBoolean(baseObj->structureID()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(exec, r[value].jsValue(exec), r[baseProto].jsValue(exec)) : false);
 
         ++vPC;
@@ -2162 +2183 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame));
+        r[dst] = jsTypeStringForValue(exec, r[src].jsValue(exec));
 
         ++vPC;
@@ -2176 +2197 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* v = callFrame[src].jsValue(callFrame);
-        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        JSValue* v = r[src].jsValue(exec);
+        r[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
 
         ++vPC;
@@ -2191 +2212 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isBoolean());
+        r[dst] = jsBoolean(r[src].jsValue(exec)->isBoolean());
 
         ++vPC;
@@ -2205 +2226 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isNumber());
+        r[dst] = jsBoolean(r[src].jsValue(exec)->isNumber());
 
         ++vPC;
@@ -2219 +2240 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isString());
+        r[dst] = jsBoolean(r[src].jsValue(exec)->isString());
 
         ++vPC;
@@ -2233 +2254 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(jsIsObjectType(callFrame[src].jsValue(callFrame)));
+        r[dst] = jsBoolean(jsIsObjectType(r[src].jsValue(exec)));
 
         ++vPC;
@@ -2247 +2268 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(jsIsFunctionType(callFrame[src].jsValue(callFrame)));
+        r[dst] = jsBoolean(jsIsFunctionType(r[src].jsValue(exec)));
 
         ++vPC;
@@ -2265 +2286 @@
         int base = (++vPC)->u.operand;
 
-        JSValue* baseVal = callFrame[base].jsValue(callFrame);
-        if (isNotObject(callFrame, false, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
+        JSValue* baseVal = r[base].jsValue(exec);
+        if (isNotObject(exec, false, codeBlock(r), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
 
-        JSValue* propName = callFrame[property].jsValue(callFrame);
+        JSValue* propName = r[property].jsValue(exec);
 
         uint32_t i;
         if (propName->getUInt32(i))
-            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, i));
+            r[dst] = jsBoolean(baseObj->hasProperty(exec, i));
         else {
-            Identifier property(callFrame, propName->toString(callFrame));
+            Identifier property(exec, propName->toString(exec));
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, property));
+            r[dst] = jsBoolean(baseObj->hasProperty(exec, property));
         }
 
@@ -2292 +2313 @@
            dst. If the property is not found, raises an exception.
         */
-        if (UNLIKELY(!resolve(callFrame, vPC, exceptionValue)))
+        if (UNLIKELY(!resolve(exec, vPC, r, exceptionValue)))
             goto vm_throw;
 
@@ -2305 +2326 @@
          value to register dst. If the property is not found, raises an exception.
          */
-        if (UNLIKELY(!resolveSkip(callFrame, vPC, exceptionValue)))
+        if (UNLIKELY(!resolveSkip(exec, vPC, r, exceptionValue)))
             goto vm_throw;
 
@@ -2320 +2341 @@
            cache the new structureID and offset
          */
-        if (UNLIKELY(!resolveGlobal(callFrame, vPC, exceptionValue)))
+        if (UNLIKELY(!resolveGlobal(exec, vPC, r,  exceptionValue)))
             goto vm_throw;
         
@@ -2337 +2358 @@
         int index = (++vPC)->u.operand;
 
-        callFrame[dst] = scope->registerAt(index);
+        r[dst] = scope->registerAt(index);
         ++vPC;
         NEXT_OPCODE;
@@ -2351 +2372 @@
         int value = (++vPC)->u.operand;
         
-        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
+        scope->registerAt(index) = r[value].jsValue(exec);
         ++vPC;
         NEXT_OPCODE;
@@ -2363 +2384 @@
         int dst = (++vPC)->u.operand;
         int index = (++vPC)->u.operand;
-        int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain;
-
-        ScopeChainNode* scopeChain = callFrame->scopeChain();
+        int skip = (++vPC)->u.operand + codeBlock(r)->needsFullScopeChain;
+
+        ScopeChainNode* scopeChain = this->scopeChain(r);
         ScopeChainIterator iter = scopeChain->begin();
         ScopeChainIterator end = scopeChain->end();
@@ -2376 +2397 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        callFrame[dst] = scope->registerAt(index);
+        r[dst] = scope->registerAt(index);
         ++vPC;
         NEXT_OPCODE;
@@ -2385 +2406 @@
          */
         int index = (++vPC)->u.operand;
-        int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain;
+        int skip = (++vPC)->u.operand + codeBlock(r)->needsFullScopeChain;
         int value = (++vPC)->u.operand;
 
-        ScopeChainNode* scopeChain = callFrame->scopeChain();
+        ScopeChainNode* scopeChain = this->scopeChain(r);
         ScopeChainIterator iter = scopeChain->begin();
         ScopeChainIterator end = scopeChain->end();
@@ -2399 +2420 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
+        scope->registerAt(index) = r[value].jsValue(exec);
         ++vPC;
         NEXT_OPCODE;
@@ -2411 +2432 @@
            will be the global object) is stored in register dst.
         */
-        resolveBase(callFrame, vPC);
+        resolveBase(exec, vPC, r);
 
         vPC += 3;
@@ -2428 +2449 @@
            avoids duplicate hash lookups.
         */
-        if (UNLIKELY(!resolveBaseAndProperty(callFrame, vPC, exceptionValue)))
+        if (UNLIKELY(!resolveBaseAndProperty(exec, vPC, r, exceptionValue)))
             goto vm_throw;
 
@@ -2449 +2470 @@
            calls but not for other property lookup.
         */
-        if (UNLIKELY(!resolveBaseAndFunc(callFrame, vPC, exceptionValue)))
+        if (UNLIKELY(!resolveBaseAndFunc(exec, vPC, r, exceptionValue)))
             goto vm_throw;
 
@@ -2465 +2486 @@
         int property = vPC[3].u.operand;
 
-        CodeBlock* codeBlock = callFrame->codeBlock();
+        CodeBlock* codeBlock = this->codeBlock(r);
         Identifier& ident = codeBlock->identifiers[property];
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(callFrame, ident, slot);
+        JSValue* result = baseValue->get(exec, ident, slot);
         VM_CHECK_EXCEPTION();
 
-        tryCacheGetByID(callFrame, codeBlock, vPC, baseValue, ident, slot);
-
-        callFrame[dst] = result;
+        tryCacheGetByID(exec, codeBlock, vPC, baseValue, ident, slot);
+
+        r[dst] = result;
         vPC += 8;
         NEXT_OPCODE;
@@ -2486 +2507 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2498 +2519 @@
                 int offset = vPC[5].u.operand;
 
-                ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
-                callFrame[dst] = baseObject->getDirectOffset(offset);
+                ASSERT(baseObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
+                r[dst] = baseObject->getDirectOffset(offset);
 
                 vPC += 8;
@@ -2506 +2527 @@
         }
 
-        uncacheGetByID(callFrame->codeBlock(), vPC);
+        uncacheGetByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2517 +2538 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2524 +2545 @@
 
             if (LIKELY(baseCell->structureID() == structureID)) {
-                ASSERT(structureID->prototypeForLookup(callFrame)->isObject());
-                JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(callFrame));
+                ASSERT(structureID->prototypeForLookup(exec)->isObject());
+                JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(exec));
                 StructureID* protoStructureID = vPC[5].u.structureID;
 
@@ -2532 +2553 @@
                     int offset = vPC[6].u.operand;
 
-                    ASSERT(protoObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == protoObject->getDirectOffset(offset));
-                    callFrame[dst] = protoObject->getDirectOffset(offset);
+                    ASSERT(protoObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == protoObject->getDirectOffset(offset));
+                    r[dst] = protoObject->getDirectOffset(offset);
 
                     vPC += 8;
@@ -2541 +2562 @@
         }
 
-        uncacheGetByID(callFrame->codeBlock(), vPC);
+        uncacheGetByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2552 +2573 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2565 +2586 @@
                 JSObject* baseObject = static_cast<JSObject*>(baseCell);
                 while (1) {
-                    baseObject = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(callFrame));
+                    baseObject = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(exec));
                     if (UNLIKELY(baseObject->structureID() != (*it).get()))
                         break;
@@ -2573 +2594 @@
                         int offset = vPC[7].u.operand;
 
-                        ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
-                        callFrame[dst] = baseObject->getDirectOffset(offset);
+                        ASSERT(baseObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
+                        r[dst] = baseObject->getDirectOffset(offset);
 
                         vPC += 8;
@@ -2583 +2604 @@
         }
 
-        uncacheGetByID(callFrame->codeBlock(), vPC);
+        uncacheGetByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2596 +2617 @@
         int property = vPC[3].u.operand;
 
-        Identifier& ident = callFrame->codeBlock()->identifiers[property];
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        Identifier& ident = codeBlock(r)->identifiers[property];
+        JSValue* baseValue = r[base].jsValue(exec);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(callFrame, ident, slot);
+        JSValue* result = baseValue->get(exec, ident, slot);
         VM_CHECK_EXCEPTION();
 
-        callFrame[dst] = result;
+        r[dst] = result;
         vPC += 8;
         NEXT_OPCODE;
@@ -2615 +2636 @@
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
         if (LIKELY(isJSArray(baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = jsNumber(callFrame, static_cast<JSArray*>(baseValue)->length());
+            r[dst] = jsNumber(exec, static_cast<JSArray*>(baseValue)->length());
             vPC += 8;
             NEXT_OPCODE;
         }
 
-        uncacheGetByID(callFrame->codeBlock(), vPC);
+        uncacheGetByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2635 +2656 @@
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
         if (LIKELY(isJSString(baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = jsNumber(callFrame, static_cast<JSString*>(baseValue)->value().size());
+            r[dst] = jsNumber(exec, static_cast<JSString*>(baseValue)->value().size());
             vPC += 8;
             NEXT_OPCODE;
         }
 
-        uncacheGetByID(callFrame->codeBlock(), vPC);
+        uncacheGetByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2660 +2681 @@
         int value = vPC[3].u.operand;
 
-        CodeBlock* codeBlock = callFrame->codeBlock();
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        CodeBlock* codeBlock = this->codeBlock(r);
+        JSValue* baseValue = r[base].jsValue(exec);
         Identifier& ident = codeBlock->identifiers[property];
         PutPropertySlot slot;
-        baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
+        baseValue->put(exec, ident, r[value].jsValue(exec), slot);
         VM_CHECK_EXCEPTION();
 
-        tryCachePutByID(callFrame, codeBlock, vPC, baseValue, slot);
+        tryCachePutByID(exec, codeBlock, vPC, baseValue, slot);
 
         vPC += 8;
@@ -2684 +2705 @@
          */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
         
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2697 +2718 @@
                 RefPtr<StructureID>* it = vPC[6].u.structureIDChain->head();
 
-                JSObject* proto = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(callFrame));
+                JSObject* proto = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(exec));
                 while (!proto->isNull()) {
                     if (UNLIKELY(proto->structureID() != (*it).get())) {
-                        uncachePutByID(callFrame->codeBlock(), vPC);
+                        uncachePutByID(codeBlock(r), vPC);
                         NEXT_OPCODE;
                     }
                     ++it;
-                    proto = static_cast<JSObject*>(proto->structureID()->prototypeForLookup(callFrame));
+                    proto = static_cast<JSObject*>(proto->structureID()->prototypeForLookup(exec));
                 }
 
@@ -2711 +2732 @@
                 int value = vPC[3].u.operand;
                 unsigned offset = vPC[7].u.operand;
-                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifiers[vPC[2].u.operand])) == offset);
-                baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame));
+                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(codeBlock(r)->identifiers[vPC[2].u.operand])) == offset);
+                baseObject->putDirectOffset(offset, r[value].jsValue(exec));
 
                 vPC += 8;
@@ -2719 +2740 @@
         }
         
-        uncachePutByID(callFrame->codeBlock(), vPC);
+        uncachePutByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2734 +2755 @@
         */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2746 +2767 @@
                 unsigned offset = vPC[5].u.operand;
                 
-                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifiers[vPC[2].u.operand])) == offset);
-                baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame));
+                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(codeBlock(r)->identifiers[vPC[2].u.operand])) == offset);
+                baseObject->putDirectOffset(offset, r[value].jsValue(exec));
 
                 vPC += 8;
@@ -2754 +2775 @@
         }
 
-        uncachePutByID(callFrame->codeBlock(), vPC);
+        uncachePutByID(codeBlock(r), vPC);
         NEXT_OPCODE;
     }
@@ -2770 +2791 @@
         int value = vPC[3].u.operand;
 
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
-        Identifier& ident = callFrame->codeBlock()->identifiers[property];
+        JSValue* baseValue = r[base].jsValue(exec);
+        Identifier& ident = codeBlock(r)->identifiers[property];
         PutPropertySlot slot;
-        baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
+        baseValue->put(exec, ident, r[value].jsValue(exec), slot);
         VM_CHECK_EXCEPTION();
 
@@ -2791 +2812 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame);
-        Identifier& ident = callFrame->codeBlock()->identifiers[property];
-        JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
+        JSObject* baseObj = r[base].jsValue(exec)->toObject(exec);
+        Identifier& ident = codeBlock(r)->identifiers[property];
+        JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2811 +2832 @@
         int property = (++vPC)->u.operand;
         
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* subscript = r[property].jsValue(exec);
 
         JSValue* result;
@@ -2824 +2845 @@
                     result = jsArray->getIndex(i);
                 else
-                    result = jsArray->JSArray::get(callFrame, i);
+                    result = jsArray->JSArray::get(exec, i);
             } else if (isJSString(baseValue) && static_cast<JSString*>(baseValue)->canGetIndex(i))
-                result = static_cast<JSString*>(baseValue)->getIndex(&callFrame->globalData(), i);
+                result = static_cast<JSString*>(baseValue)->getIndex(&exec->globalData(), i);
             else
-                result = baseValue->get(callFrame, i);
+                result = baseValue->get(exec, i);
         } else {
-            Identifier property(callFrame, subscript->toString(callFrame));
-            result = baseValue->get(callFrame, property);
+            Identifier property(exec, subscript->toString(exec));
+            result = baseValue->get(exec, property);
         }
 
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2854 +2875 @@
         int value = (++vPC)->u.operand;
 
-        JSValue* baseValue = callFrame[base].jsValue(callFrame);
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
+        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* subscript = r[property].jsValue(exec);
 
         unsigned i;
@@ -2864 +2885 @@
                 JSArray* jsArray = static_cast<JSArray*>(baseValue);
                 if (jsArray->canSetIndex(i))
-                    jsArray->setIndex(i, callFrame[value].jsValue(callFrame));
+                    jsArray->setIndex(i, r[value].jsValue(exec));
                 else
-                    jsArray->JSArray::put(callFrame, i, callFrame[value].jsValue(callFrame));
+                    jsArray->JSArray::put(exec, i, r[value].jsValue(exec));
             } else
-                baseValue->put(callFrame, i, callFrame[value].jsValue(callFrame));
+                baseValue->put(exec, i, r[value].jsValue(exec));
         } else {
-            Identifier property(callFrame, subscript->toString(callFrame));
-            if (!globalData->exception) { // Don't put to an object if toString threw an exception.
+            Identifier property(exec, subscript->toString(exec));
+            if (!exec->hadException()) { // Don't put to an object if toString threw an exception.
                 PutPropertySlot slot;
-                baseValue->put(callFrame, property, callFrame[value].jsValue(callFrame), slot);
+                baseValue->put(exec, property, r[value].jsValue(exec), slot);
             }
         }
@@ -2893 +2914 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame); // may throw
-
-        JSValue* subscript = callFrame[property].jsValue(callFrame);
+        JSObject* baseObj = r[base].jsValue(exec)->toObject(exec); // may throw
+
+        JSValue* subscript = r[property].jsValue(exec);
         JSValue* result;
         uint32_t i;
         if (subscript->getUInt32(i))
-            result = jsBoolean(baseObj->deleteProperty(callFrame, i));
+            result = jsBoolean(baseObj->deleteProperty(exec, i));
         else {
             VM_CHECK_EXCEPTION();
-            Identifier property(callFrame, subscript->toString(callFrame));
+            Identifier property(exec, subscript->toString(exec));
             VM_CHECK_EXCEPTION();
-            result = jsBoolean(baseObj->deleteProperty(callFrame, property));
+            result = jsBoolean(baseObj->deleteProperty(exec, property));
         }
 
         VM_CHECK_EXCEPTION();
-        callFrame[dst] = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2928 +2949 @@
         int value = (++vPC)->u.operand;
 
-        callFrame[base].jsValue(callFrame)->put(callFrame, property, callFrame[value].jsValue(callFrame));
+        r[base].jsValue(exec)->put(exec, property, r[value].jsValue(exec));
 
         ++vPC;
@@ -2975 +2996 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
+        if (r[cond].jsValue(exec)->toBoolean(exec)) {
             vPC += target;
             CHECK_FOR_TIMEOUT();
@@ -2992 +3013 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
+        if (r[cond].jsValue(exec)->toBoolean(exec)) {
             vPC += target;
             NEXT_OPCODE;
@@ -3008 +3029 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (!callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
+        if (!r[cond].jsValue(exec)->toBoolean(exec)) {
             vPC += target;
             NEXT_OPCODE;
@@ -3027 +3048 @@
            the JS timeout is reached.
          */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int target = (++vPC)->u.operand;
         
-        bool result = jsLess(callFrame, src1, src2);
+        bool result = jsLess(exec, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3054 +3075 @@
            the JS timeout is reached.
         */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int target = (++vPC)->u.operand;
         
-        bool result = jsLessEq(callFrame, src1, src2);
+        bool result = jsLessEq(exec, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3078 +3099 @@
            result of the comparison is false.
         */
-        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
-        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
         int target = (++vPC)->u.operand;
 
-        bool result = jsLess(callFrame, src1, src2);
+        bool result = jsLess(exec, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3104 +3125 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
         if (!JSImmediate::isNumber(scrutinee))
             vPC += defaultOffset;
         else {
             int32_t value = JSImmediate::getTruncatedInt32(scrutinee);
-            vPC += callFrame->codeBlock()->immediateSwitchJumpTables[tableIndex].offsetForValue(value, defaultOffset);
+            vPC += codeBlock(r)->immediateSwitchJumpTables[tableIndex].offsetForValue(value, defaultOffset);
         }
         NEXT_OPCODE;
@@ -3124 +3145 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
         if (!scrutinee->isString())
             vPC += defaultOffset;
@@ -3132 +3153 @@
                 vPC += defaultOffset;
             else
-                vPC += callFrame->codeBlock()->characterSwitchJumpTables[tableIndex].offsetForValue(value->data()[0], defaultOffset);
+                vPC += codeBlock(r)->characterSwitchJumpTables[tableIndex].offsetForValue(value->data()[0], defaultOffset);
         }
         NEXT_OPCODE;
@@ -3147 +3168 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
         if (!scrutinee->isString())
             vPC += defaultOffset;
         else 
-            vPC += callFrame->codeBlock()->stringSwitchJumpTables[tableIndex].offsetForValue(static_cast<JSString*>(scrutinee)->value().rep(), defaultOffset);
+            vPC += codeBlock(r)->stringSwitchJumpTables[tableIndex].offsetForValue(static_cast<JSString*>(scrutinee)->value().rep(), defaultOffset);
         NEXT_OPCODE;
     }
@@ -3165 +3186 @@
         int func = (++vPC)->u.operand;
 
-        callFrame[dst] = callFrame->codeBlock()->functions[func]->makeFunction(callFrame, callFrame->scopeChain());
+        r[dst] = codeBlock(r)->functions[func]->makeFunction(exec, scopeChain(r));
 
         ++vPC;
@@ -3181 +3202 @@
         int func = (++vPC)->u.operand;
 
-        callFrame[dst] = callFrame->codeBlock()->functionExpressions[func]->makeFunction(callFrame, callFrame->scopeChain());
+        r[dst] = codeBlock(r)->functionExpressions[func]->makeFunction(exec, scopeChain(r));
 
         ++vPC;
@@ -3205 +3226 @@
         ++vPC; // registerOffset
 
-        JSValue* funcVal = callFrame[func].jsValue(callFrame);
-        JSValue* baseVal = callFrame[thisVal].jsValue(callFrame);
-
-        ScopeChainNode* scopeChain = callFrame->scopeChain();
+        JSValue* funcVal = r[func].jsValue(exec);
+        JSValue* baseVal = r[thisVal].jsValue(exec);
+
+        ScopeChainNode* scopeChain = this->scopeChain(r);
         if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
-            JSObject* thisObject = static_cast<JSObject*>(callFrame[callFrame->codeBlock()->thisRegister].jsValue(callFrame));
-            JSValue* result = callEval(callFrame, thisObject, scopeChain, registerFile, firstArg, argCount, exceptionValue);
+            JSObject* thisObject = static_cast<JSObject*>(r[codeBlock(r)->thisRegister].jsValue(exec));
+            JSValue* result = callEval(exec, thisObject, scopeChain, registerFile, r, firstArg, argCount, exceptionValue);
             if (exceptionValue)
                 goto vm_throw;
 
-            callFrame[dst] = result;
+            r[dst] = result;
 
             ++vPC;
@@ -3225 +3246 @@
         // value.
         vPC -= 6;
-        callFrame[thisVal] = baseVal->toThisObject(callFrame);
+        r[thisVal] = baseVal->toThisObject(exec);
 
 #if HAVE(COMPUTED_GOTO)
@@ -3279 +3300 @@
         int registerOffset = (++vPC)->u.operand;
 
-        JSValue* v = callFrame[func].jsValue(callFrame);
+        JSValue* v = r[func].jsValue(exec);
 
         CallData callData;
@@ -3289 +3310 @@
             CodeBlock* newCodeBlock = &functionBodyNode->byteCode(callDataScopeChain);
 
-            callFrame[firstArg] = thisVal == missingThisObjectMarker() ? callFrame->globalThisValue() : callFrame[thisVal].jsValue(callFrame);
+            r[firstArg] = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue(exec);
             
-            CallFrame* previousCallFrame = callFrame;
-
-            callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
-            if (UNLIKELY(!callFrame)) {
-                callFrame = previousCallFrame;
-                exceptionValue = createStackOverflowError(callFrame);
+            Register* savedR = r;
+
+            r = slideRegisterWindowForCall(newCodeBlock, registerFile, r, registerOffset, argCount);
+            if (UNLIKELY(!r)) {
+                r = savedR;
+                exceptionValue = createStackOverflowError(CallFrame::create(r));
                 goto vm_throw;
             }
 
-            callFrame->init(newCodeBlock, vPC + 1, callDataScopeChain, previousCallFrame, dst, argCount, static_cast<JSFunction*>(v));
+            initializeCallFrame(r, newCodeBlock, vPC + 1, callDataScopeChain, savedR, dst, argCount, v);
     
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
 
             vPC = newCodeBlock->instructions.begin();
@@ -3315 +3336 @@
 
         if (callType == CallTypeHost) {
-            JSValue* thisValue = thisVal == missingThisObjectMarker() ? callFrame->globalThisValue() : callFrame[thisVal].jsValue(callFrame);
-            ArgList args(callFrame->registers() + firstArg + 1, argCount - 1);
-
-            ScopeChainNode* scopeChain = callFrame->scopeChain();
-            CallFrame* newCallFrame = CallFrame::create(callFrame->registers() + registerOffset);
-            newCallFrame->init(0, vPC + 1, scopeChain, callFrame, dst, argCount, static_cast<JSFunction*>(v));
+            JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue(exec);
+            ArgList args(r + firstArg + 1, argCount - 1);
+
+            ScopeChainNode* scopeChain = this->scopeChain(r);
+            initializeCallFrame(r + registerOffset, 0, vPC + 1, scopeChain, r, dst, argCount, v);
+            ExecState* callFrame = CallFrame::create(r + registerOffset);
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(newCallFrame, static_cast<JSFunction*>(v));
+                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
 
             MACHINE_SAMPLING_callingHostFunction();
 
-            JSValue* returnValue = callData.native.function(newCallFrame, static_cast<JSFunction*>(v), thisValue, args);
+            JSValue* returnValue = callData.native.function(callFrame, static_cast<JSObject*>(v), thisValue, args);
             VM_CHECK_EXCEPTION();
 
-            newCallFrame[dst] = returnValue;
+            r[dst] = returnValue;
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSFunction*>(v));
+                (*enabledProfilerReference)->didExecute(CallFrame::create(r), static_cast<JSObject*>(v));
 
             ++vPC;
@@ -3341 +3362 @@
         ASSERT(callType == CallTypeNone);
 
-        exceptionValue = createNotAFunctionError(callFrame, v, vPC, callFrame->codeBlock());
+        exceptionValue = createNotAFunctionError(exec, v, vPC, codeBlock(r));
         goto vm_throw;
     }
     BEGIN_OPCODE(op_tear_off_activation) {
         int src = (++vPC)->u.operand;
-        ASSERT(callFrame->codeBlock()->needsFullScopeChain);
-        JSActivation* activation = static_cast<JSActivation*>(callFrame[src].getJSValue());
+        JSActivation* activation = static_cast<JSActivation*>(r[src].getJSValue());
+        ASSERT(codeBlock(r)->needsFullScopeChain);
         ASSERT(activation->isObject(&JSActivation::info));
 
+        Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+        ASSERT(!arguments || arguments->isObject(&Arguments::info));
+        activation->copyRegisters(arguments);
+
         ++vPC;
         NEXT_OPCODE;
     }
     BEGIN_OPCODE(op_tear_off_arguments) {
-        ASSERT(callFrame->codeBlock()->usesArguments && !callFrame->codeBlock()->needsFullScopeChain);
-
-        callFrame->optionalCalleeArguments()->copyRegisters();
+        Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+        ASSERT(codeBlock(r)->usesArguments && !codeBlock(r)->needsFullScopeChain);
+        ASSERT(arguments->isObject(&Arguments::info));
+
+        arguments->copyRegisters();
 
         ++vPC;
@@ -3374 +3401 @@
 
         if (*enabledProfilerReference)
-            (*enabledProfilerReference)->didExecute(callFrame, callFrame->callee());
-
-        if (callFrame->codeBlock()->needsFullScopeChain)
-            callFrame->scopeChain()->deref();
-
-        JSValue* returnValue = callFrame[result].jsValue(callFrame);
-
-        vPC = callFrame->returnPC();
-        int dst = callFrame->returnValueRegister();
-        callFrame = callFrame->callerFrame();
+            (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(r[RegisterFile::Callee].jsValue(exec)));
+
+        if (codeBlock(r)->needsFullScopeChain)
+            scopeChain(r)->deref();
+
+        JSValue* returnValue = r[result].jsValue(exec);
+
+        vPC = r[RegisterFile::ReturnPC].vPC();
+        int dst = r[RegisterFile::ReturnValueRegister].i();
+        r = r[RegisterFile::CallerRegisters].r();
         
-        if (callFrame->hasHostCallFrameFlag())
+        if (isHostCallFrame(r))
             return returnValue;
 
-        callFrame[dst] = returnValue;
+        r[dst] = returnValue;
 
         NEXT_OPCODE;
@@ -3404 +3431 @@
 
         size_t i = 0;
-        CodeBlock* codeBlock = callFrame->codeBlock();
+        CodeBlock* codeBlock = this->codeBlock(r);
         
         for (size_t count = codeBlock->numVars; i < count; ++i)
-            callFrame[i] = jsUndefined();
+            r[i] = jsUndefined();
 
         for (size_t count = codeBlock->constantRegisters.size(), j = 0; j < count; ++i, ++j)
-            callFrame[i] = codeBlock->constantRegisters[j];
+            r[i] = codeBlock->constantRegisters[j];
 
         ++vPC;
@@ -3429 +3456 @@
 
         size_t i = 0;
-        CodeBlock* codeBlock = callFrame->codeBlock();
+        CodeBlock* codeBlock = this->codeBlock(r);
 
         for (size_t count = codeBlock->numVars; i < count; ++i)
-            callFrame[i] = jsUndefined();
+            r[i] = jsUndefined();
 
         for (size_t count = codeBlock->constantRegisters.size(), j = 0; j < count; ++i, ++j)
-            callFrame[i] = codeBlock->constantRegisters[j];
+            r[i] = codeBlock->constantRegisters[j];
 
         int dst = (++vPC)->u.operand;
-        JSActivation* activation = new (globalData) JSActivation(callFrame, static_cast<FunctionBodyNode*>(codeBlock->ownerNode));
-        callFrame[dst] = activation;
-        callFrame->setScopeChain(callFrame->scopeChain()->copy()->push(activation));
+        JSActivation* activation = new (globalData) JSActivation(exec, static_cast<FunctionBodyNode*>(codeBlock->ownerNode), r);
+        r[dst] = activation;
+        r[RegisterFile::ScopeChain] = scopeChain(r)->copy()->push(activation);
 
         ++vPC;
@@ -3447 +3474 @@
     BEGIN_OPCODE(op_convert_this) {
         int thisRegister = (++vPC)->u.operand;
-        JSValue* thisVal = callFrame[thisRegister].getJSValue();
+        JSValue* thisVal = r[thisRegister].getJSValue();
         if (thisVal->needsThisConversion())
-            callFrame[thisRegister] = thisVal->toThisObject(callFrame);
+            r[thisRegister] = thisVal->toThisObject(exec);
 
         ++vPC;
@@ -3465 +3492 @@
         */
 
-        Arguments* arguments = new (globalData) Arguments(callFrame);
-        callFrame->setCalleeArguments(arguments);
-        callFrame[RegisterFile::ArgumentsRegister] = arguments;
+        Arguments* arguments = new (globalData) Arguments(exec, r);
+        r[RegisterFile::OptionalCalleeArguments] = arguments;
+        r[RegisterFile::ArgumentsRegister] = arguments;
         
         ++vPC;
@@ -3494 +3521 @@
         int registerOffset = (++vPC)->u.operand;
 
-        JSValue* v = callFrame[constr].jsValue(callFrame);
+        JSValue* v = r[constr].jsValue(exec);
 
         ConstructData constructData;
@@ -3501 +3528 @@
         if (constructType == ConstructTypeJS) {
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
 
             ScopeChainNode* callDataScopeChain = constructData.js.scopeChain;
@@ -3508 +3535 @@
 
             StructureID* structure;
-            JSValue* prototype = callFrame[constrProto].jsValue(callFrame);
+            JSValue* prototype = r[constrProto].jsValue(exec);
             if (prototype->isObject())
                 structure = static_cast<JSObject*>(prototype)->inheritorID();
@@ -3515 +3542 @@
             JSObject* newObject = new (globalData) JSObject(structure);
 
-            callFrame[firstArg] = newObject; // "this" value
-
-            CallFrame* previousCallFrame = callFrame;
-
-            callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
-            if (UNLIKELY(!callFrame)) {
-                callFrame = previousCallFrame;
-                exceptionValue = createStackOverflowError(callFrame);
+            r[firstArg] = newObject; // "this" value
+
+            Register* savedR = r;
+
+            r = slideRegisterWindowForCall(newCodeBlock, registerFile, r, registerOffset, argCount);
+            if (UNLIKELY(!r)) {
+                r = savedR;
+                exceptionValue = createStackOverflowError(CallFrame::create(r));
                 goto vm_throw;
             }
 
-            callFrame->init(newCodeBlock, vPC + 1, callDataScopeChain, previousCallFrame, dst, argCount, static_cast<JSFunction*>(v));
+            initializeCallFrame(r, newCodeBlock, vPC + 1, callDataScopeChain, savedR, dst, argCount, v);
     
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(v));
 
             vPC = newCodeBlock->instructions.begin();
@@ -3541 +3568 @@
 
         if (constructType == ConstructTypeHost) {
-            ArgList args(callFrame->registers() + firstArg + 1, argCount - 1);
-
-            ScopeChainNode* scopeChain = callFrame->scopeChain();
-            CallFrame::create(callFrame->registers() + registerOffset)->init(0, vPC + 1, scopeChain, callFrame, dst, argCount, static_cast<JSFunction*>(v));
-            callFrame = CallFrame::create(callFrame->registers() + registerOffset);
+            ArgList args(r + firstArg + 1, argCount - 1);
+
+            ScopeChainNode* scopeChain = this->scopeChain(r);
+            initializeCallFrame(r + registerOffset, 0, vPC + 1, scopeChain, r, dst, argCount, v);
+            r += registerOffset;
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
 
             MACHINE_SAMPLING_callingHostFunction();
 
-            JSValue* returnValue = constructData.native.function(callFrame, static_cast<JSObject*>(v), args);
-            callFrame = CallFrame::create(callFrame->registers() - registerOffset);
+            JSValue* returnValue = constructData.native.function(exec, static_cast<JSObject*>(v), args);
+            r -= registerOffset;
 
             VM_CHECK_EXCEPTION();
-            callFrame[dst] = returnValue;
+            r[dst] = returnValue;
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(v));
 
             ++vPC;
@@ -3567 +3594 @@
         ASSERT(constructType == ConstructTypeNone);
 
-        exceptionValue = createNotAConstructorError(callFrame, v, vPC, callFrame->codeBlock());
+        exceptionValue = createNotAConstructorError(exec, v, vPC, codeBlock(r));
         goto vm_throw;
     }
@@ -3578 +3605 @@
 
         int dst = vPC[1].u.operand;;
-        if (LIKELY(callFrame[dst].jsValue(callFrame)->isObject())) {
+        if (LIKELY(r[dst].jsValue(exec)->isObject())) {
             vPC += 3;
             NEXT_OPCODE;
@@ -3584 +3611 @@
 
         int override = vPC[2].u.operand;
-        callFrame[dst] = callFrame[override];
+        r[dst] = r[override];
 
         vPC += 3;
@@ -3596 +3623 @@
         */
         int scope = (++vPC)->u.operand;
-        JSValue* v = callFrame[scope].jsValue(callFrame);
-        JSObject* o = v->toObject(callFrame);
+        JSValue* v = r[scope].jsValue(exec);
+        JSObject* o = v->toObject(exec);
         VM_CHECK_EXCEPTION();
 
-        callFrame->setScopeChain(callFrame->scopeChain()->push(o));
+        r[RegisterFile::ScopeChain] = scopeChain(r)->push(o);
 
         ++vPC;
@@ -3610 +3637 @@
            Removes the top item from the current scope chain.
         */
-        callFrame->setScopeChain(callFrame->scopeChain()->pop());
+        r[RegisterFile::ScopeChain] = scopeChain(r)->pop();
 
         ++vPC;
@@ -3626 +3653 @@
         int base = (++vPC)->u.operand;
 
-        callFrame[dst] = JSPropertyNameIterator::create(callFrame, callFrame[base].jsValue(callFrame));
+        r[dst] = JSPropertyNameIterator::create(exec, r[base].jsValue(exec));
         ++vPC;
         NEXT_OPCODE;
@@ -3643 +3670 @@
         int target = (++vPC)->u.operand;
 
-        JSPropertyNameIterator* it = callFrame[iter].propertyNameIterator();
-        if (JSValue* temp = it->next(callFrame)) {
+        JSPropertyNameIterator* it = r[iter].jsPropertyNameIterator();
+        if (JSValue* temp = it->next(exec)) {
             CHECK_FOR_TIMEOUT();
-            callFrame[dst] = temp;
+            r[dst] = temp;
             vPC += target;
             NEXT_OPCODE;
@@ -3665 +3692 @@
         int target = (++vPC)->u.operand;
 
-        ScopeChainNode* tmp = callFrame->scopeChain();
+        ScopeChainNode* tmp = scopeChain(r);
         while (count--)
             tmp = tmp->pop();
-        callFrame->setScopeChain(tmp);
+        r[RegisterFile::ScopeChain] = tmp;
 
         vPC += target;
@@ -3684 +3711 @@
            in dst for GC.
          */
-        callFrame->setScopeChain(createExceptionScope(callFrame, vPC));
+        r[RegisterFile::ScopeChain] = createExceptionScope(exec, vPC, r);
 
         vPC += 4;
@@ -3700 +3727 @@
         */
         ASSERT(exceptionValue);
-        ASSERT(!globalData->exception);
+        ASSERT(!exec->hadException());
         int ex = (++vPC)->u.operand;
-        callFrame[ex] = exceptionValue;
+        r[ex] = exceptionValue;
         exceptionValue = 0;
 
@@ -3720 +3747 @@
 
         int ex = (++vPC)->u.operand;
-        exceptionValue = callFrame[ex].jsValue(callFrame);
-
-        handlerVPC = throwException(callFrame, exceptionValue, vPC, true);
+        exceptionValue = r[ex].jsValue(exec);
+
+        handlerVPC = throwException(exec, exceptionValue, vPC, r, true);
         if (!handlerVPC) {
             *exception = exceptionValue;
@@ -3747 +3774 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = callFrame->codeBlock()->unexpectedConstants[src];
+        r[dst] = codeBlock(r)->unexpectedConstants[src];
 
         ++vPC;
@@ -3764 +3791 @@
         int message = (++vPC)->u.operand;
 
-        CodeBlock* codeBlock = callFrame->codeBlock();
-        callFrame[dst] = Error::create(callFrame, (ErrorType)type, codeBlock->unexpectedConstants[message]->toString(callFrame), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
+        CodeBlock* codeBlock = this->codeBlock(r);
+        r[dst] = Error::create(exec, (ErrorType)type, codeBlock->unexpectedConstants[message]->toString(exec), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
 
         ++vPC;
@@ -3777 +3804 @@
         */
 
-        if (callFrame->codeBlock()->needsFullScopeChain) {
-            ScopeChainNode* scopeChain = callFrame->scopeChain();
+        if (codeBlock(r)->needsFullScopeChain) {
+            ScopeChainNode* scopeChain = this->scopeChain(r);
             ASSERT(scopeChain->refCount > 1);
             scopeChain->deref();
         }
         int result = (++vPC)->u.operand;
-        return callFrame[result].jsValue(callFrame);
+        return r[result].jsValue(exec);
     }
     BEGIN_OPCODE(op_put_getter) {
@@ -3800 +3827 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(callFrame[base].jsValue(callFrame)->isObject());
-        JSObject* baseObj = static_cast<JSObject*>(callFrame[base].jsValue(callFrame));
-        Identifier& ident = callFrame->codeBlock()->identifiers[property];
-        ASSERT(callFrame[function].jsValue(callFrame)->isObject());
-        baseObj->defineGetter(callFrame, ident, static_cast<JSObject*>(callFrame[function].jsValue(callFrame)));
+        ASSERT(r[base].jsValue(exec)->isObject());
+        JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue(exec));
+        Identifier& ident = codeBlock(r)->identifiers[property];
+        ASSERT(r[function].jsValue(exec)->isObject());
+        baseObj->defineGetter(exec, ident, static_cast<JSObject*>(r[function].jsValue(exec)));
 
         ++vPC;
@@ -3824 +3851 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(callFrame[base].jsValue(callFrame)->isObject());
-        JSObject* baseObj = static_cast<JSObject*>(callFrame[base].jsValue(callFrame));
-        Identifier& ident = callFrame->codeBlock()->identifiers[property];
-        ASSERT(callFrame[function].jsValue(callFrame)->isObject());
-        baseObj->defineSetter(callFrame, ident, static_cast<JSObject*>(callFrame[function].jsValue(callFrame)));
+        ASSERT(r[base].jsValue(exec)->isObject());
+        JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue(exec));
+        Identifier& ident = codeBlock(r)->identifiers[property];
+        ASSERT(r[function].jsValue(exec)->isObject());
+        baseObj->defineSetter(exec, ident, static_cast<JSObject*>(r[function].jsValue(exec)));
 
         ++vPC;
@@ -3841 +3868 @@
         int retAddrDst = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        callFrame[retAddrDst] = vPC + 1;
+        r[retAddrDst] = vPC + 1;
 
         vPC += target;
@@ -3854 +3881 @@
         */
         int retAddrSrc = (++vPC)->u.operand;
-        vPC = callFrame[retAddrSrc].vPC();
+        vPC = r[retAddrSrc].vPC();
         NEXT_OPCODE;
     }
@@ -3867 +3894 @@
         int lastLine = (++vPC)->u.operand;
 
-        debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
+        debug(exec, r, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 
         ++vPC;
@@ -3879 +3906 @@
             exceptionValue = createInterruptedExecutionException(globalData);
         }
-        handlerVPC = throwException(callFrame, exceptionValue, vPC, false);
+        handlerVPC = throwException(exec, exceptionValue, vPC, r, false);
         if (!handlerVPC) {
             *exception = exceptionValue;
@@ -3895 +3922 @@
     #undef VM_CHECK_EXCEPTION
     #undef CHECK_FOR_TIMEOUT
-}
-
-JSValue* Machine::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
-{
-    CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
-    if (!functionCallFrame)
+    #undef exec
+}
+
+JSValue* Machine::retrieveArguments(ExecState* exec, JSFunction* function) const
+{
+    Register* r = this->callFrame(exec, function);
+    if (!r)
         return jsNull();
 
-    CodeBlock* codeBlock = functionCallFrame->codeBlock();
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     if (codeBlock->usesArguments) {
         ASSERT(codeBlock->codeType == FunctionCode);
         SymbolTable& symbolTable = static_cast<FunctionBodyNode*>(codeBlock->ownerNode)->symbolTable();
-        int argumentsIndex = symbolTable.get(functionCallFrame->propertyNames().arguments.ustring().rep()).getIndex();
-        return functionCallFrame[argumentsIndex].jsValue(callFrame);
-    }
-
-    Arguments* arguments = functionCallFrame->optionalCalleeArguments();
+        int argumentsIndex = symbolTable.get(exec->propertyNames().arguments.ustring().rep()).getIndex();
+        return r[argumentsIndex].jsValue(exec);
+    }
+
+    Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
     if (!arguments) {
-        arguments = new (functionCallFrame) Arguments(functionCallFrame);
+        arguments = new (exec) Arguments(exec, r);
         arguments->copyRegisters();
-        callFrame->setCalleeArguments(arguments);
-    }
+        r[RegisterFile::OptionalCalleeArguments] = arguments;
+    }
+    ASSERT(arguments->isObject(&Arguments::info));
 
     return arguments;
 }
 
-JSValue* Machine::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
-{
-    CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
-    if (!functionCallFrame)
+JSValue* Machine::retrieveCaller(ExecState* exec, InternalFunction* function) const
+{
+    Register* r = this->callFrame(exec, function);
+    if (!r)
         return jsNull();
 
-    CallFrame* callerFrame = functionCallFrame->callerFrame();
-    if (callerFrame->hasHostCallFrameFlag())
+    Register* callerR = r[RegisterFile::CallerRegisters].r();
+    if (isHostCallFrame(callerR))
         return jsNull();
 
-    JSValue* caller = callerFrame->callee();
+    JSValue* caller = callerR[RegisterFile::Callee].jsValue(exec);
     if (!caller)
         return jsNull();
@@ -3938 +3967 @@
 }
 
-void Machine::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
+void Machine::retrieveLastCaller(ExecState* exec, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
 {
     function = 0;
@@ -3944 +3973 @@
     sourceURL = UString();
 
-    CallFrame* callerFrame = callFrame->callerFrame();
-    if (callerFrame->hasHostCallFrameFlag())
+    Register* r = exec->registers();
+    Register* callerR = r[RegisterFile::CallerRegisters].r();
+    if (isHostCallFrame(callerR))
         return;
 
-    CodeBlock* callerCodeBlock = callerFrame->codeBlock();
+    CodeBlock* callerCodeBlock = codeBlock(callerR);
     if (!callerCodeBlock)
         return;
 
-    Instruction* vPC = vPCForPC(callerCodeBlock, callFrame->returnPC());
+    Instruction* vPC = vPCForPC(callerCodeBlock, r[RegisterFile::ReturnPC].v());
     lineNumber = callerCodeBlock->lineNumberForVPC(vPC - 1);
     sourceID = callerCodeBlock->ownerNode->sourceID();
     sourceURL = callerCodeBlock->ownerNode->sourceURL();
-    function = callerFrame->callee();
-}
-
-CallFrame* Machine::findFunctionCallFrame(CallFrame* callFrame, InternalFunction* function)
-{
-    for (CallFrame* candidate = callFrame; candidate; candidate = candidate->callerFrame()->removeHostCallFrameFlag()) {
-        if (candidate->callee() == function)
-            return candidate;
-    }
+
+    JSValue* caller = callerR[RegisterFile::Callee].getJSValue();
+    if (!caller)
+        return;
+
+    function = caller;
+}
+
+Register* Machine::callFrame(ExecState* exec, InternalFunction* function) const
+{
+    for (Register* r = exec->registers(); r; r = stripHostCallFrameBit(r[RegisterFile::CallerRegisters].r()))
+        if (r[RegisterFile::Callee].getJSValue() == function)
+            return r;
     return 0;
 }
 
-void Machine::getArgumentsData(CallFrame* callFrame, JSFunction*& function, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc)
-{
-    function = callFrame->callee();
+void Machine::getArgumentsData(Register* callFrame, JSFunction*& function, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc)
+{
+    function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].getJSValue());
+    ASSERT(function->inherits(&JSFunction::info));
     
     CodeBlock* codeBlock = &function->m_body->generatedByteCode();
     int numParameters = codeBlock->numParameters;
-    argc = callFrame->argumentCount();
+    argc = callFrame[RegisterFile::ArgumentCount].i();
 
     if (argc <= numParameters)
-        argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters + 1; // + 1 to skip "this"
+        argv = callFrame - RegisterFile::CallFrameHeaderSize - numParameters + 1; // + 1 to skip "this"
     else
-        argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters - argc + 1; // + 1 to skip "this"
+        argv = callFrame - RegisterFile::CallFrameHeaderSize - numParameters - argc + 1; // + 1 to skip "this"
 
     argc -= 1; // - 1 to skip "this"
@@ -3992 +4027 @@
 }
 
-NEVER_INLINE void Machine::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Machine::tryCTICachePutByID(ExecState* exec, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
@@ -4034 +4069 @@
         StructureIDChain* chain = structureID->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(callFrame, structureID);
+            chain = cachePrototypeChain(exec, structureID);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
@@ -4044 +4079 @@
         vPC[7] = slot.cachedOffset();
         codeBlock->refStructureIDs(vPC);
-        CTI::compilePutByIdTransition(this, callFrame, codeBlock, structureID->previousID(), structureID, slot.cachedOffset(), chain, returnAddress);
+        CTI::compilePutByIdTransition(this, exec, codeBlock, structureID->previousID(), structureID, slot.cachedOffset(), chain, returnAddress);
         return;
     }
@@ -4054 +4089 @@
 
 #if USE(CTI_REPATCH_PIC)
-    UNUSED_PARAM(callFrame);
+    UNUSED_PARAM(exec);
     CTI::patchPutByIdReplace(codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #else
-    CTI::compilePutByIdReplace(this, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+    CTI::compilePutByIdReplace(this, exec, codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #endif
 }
 
-void* Machine::getCTIArrayLengthTrampoline(CallFrame* callFrame, CodeBlock* codeBlock)
+void* Machine::getCTIArrayLengthTrampoline(ExecState* exec, CodeBlock* codeBlock)
 {
     if (!m_ctiArrayLengthTrampoline)
-        m_ctiArrayLengthTrampoline = CTI::compileArrayLengthTrampoline(this, callFrame, codeBlock);
+        m_ctiArrayLengthTrampoline = CTI::compileArrayLengthTrampoline(this, exec, codeBlock);
         
     return m_ctiArrayLengthTrampoline;
 }
 
-void* Machine::getCTIStringLengthTrampoline(CallFrame* callFrame, CodeBlock* codeBlock)
+void* Machine::getCTIStringLengthTrampoline(ExecState* exec, CodeBlock* codeBlock)
 {
     if (!m_ctiStringLengthTrampoline)
-        m_ctiStringLengthTrampoline = CTI::compileStringLengthTrampoline(this, callFrame, codeBlock);
+        m_ctiStringLengthTrampoline = CTI::compileStringLengthTrampoline(this, exec, codeBlock);
         
     return m_ctiStringLengthTrampoline;
 }
 
-NEVER_INLINE void Machine::tryCTICacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Machine::tryCTICacheGetByID(ExecState* exec, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // FIXME: Write a test that proves we need to check for recursion here just
@@ -4088 +4123 @@
     }
 
-    if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
+    if (isJSArray(baseValue) && propertyName == exec->propertyNames().length) {
 #if USE(CTI_REPATCH_PIC)
-        CTI::compilePatchGetArrayLength(this, callFrame, codeBlock, returnAddress);
+        CTI::compilePatchGetArrayLength(this, exec, codeBlock, returnAddress);
 #else
-        ctiRepatchCallByReturnAddress(returnAddress, getCTIArrayLengthTrampoline(callFrame, codeBlock));
+        ctiRepatchCallByReturnAddress(returnAddress, getCTIArrayLengthTrampoline(exec, codeBlock));
 #endif
         return;
     }
-    if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) {
+    if (isJSString(baseValue) && propertyName == exec->propertyNames().length) {
         // The tradeoff of compiling an repatched inline string length access routine does not seem
         // to pay off, so we currently only do this for arrays.
-        ctiRepatchCallByReturnAddress(returnAddress, getCTIStringLengthTrampoline(callFrame, codeBlock));
+        ctiRepatchCallByReturnAddress(returnAddress, getCTIStringLengthTrampoline(exec, codeBlock));
         return;
     }
@@ -4135 +4170 @@
         CTI::patchGetByIdSelf(codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #else
-        CTI::compileGetByIdSelf(this, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdSelf(this, exec, codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #endif
         return;
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
+    if (slot.slotBase() == structureID->prototypeForLookup(exec)) {
         ASSERT(slot.slotBase()->isObject());
 
@@ -4159 +4194 @@
         codeBlock->refStructureIDs(vPC);
 
-        CTI::compileGetByIdProto(this, callFrame, codeBlock, structureID, slotBaseObject->structureID(), slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdProto(this, exec, codeBlock, structureID, slotBaseObject->structureID(), slot.cachedOffset(), returnAddress);
         return;
     }
@@ -4166 +4201 @@
     JSObject* o = static_cast<JSObject*>(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
+        JSValue* v = o->structureID()->prototypeForLookup(exec);
 
         // If we didn't find slotBase in baseValue's prototype chain, then baseValue
@@ -4191 +4226 @@
     StructureIDChain* chain = structureID->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(callFrame, structureID);
+        chain = cachePrototypeChain(exec, structureID);
 
     ASSERT(chain);
@@ -4201 +4236 @@
     codeBlock->refStructureIDs(vPC);
 
-    CTI::compileGetByIdChain(this, callFrame, codeBlock, structureID, chain, count, slot.cachedOffset(), returnAddress);
+    CTI::compileGetByIdChain(this, exec, codeBlock, structureID, chain, count, slot.cachedOffset(), returnAddress);
 }
 
@@ -4256 +4291 @@
 {
     JSValue* v1 = ARG_src1;
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSObject* result = v1->toThisObject(callFrame);
+    ExecState* exec = ARG_exec;
+
+    JSObject* result = v1->toThisObject(exec);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4265 +4300 @@
 void Machine::cti_op_end(CTI_ARGS)
 {
-    ScopeChainNode* scopeChain = ARG_callFrame->scopeChain();
+    Register* r = ARG_r;
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
     ASSERT(scopeChain->refCount > 1);
     scopeChain->deref();
@@ -4282 +4318 @@
         return jsNumber(ARG_globalData, left + right);
     
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     bool leftIsString = v1->isString();
@@ -4288 +4324 @@
         RefPtr<UString::Rep> value = concatenate(static_cast<JSString*>(v1)->value().rep(), static_cast<JSString*>(v2)->value().rep());
         if (UNLIKELY(!value)) {
-            throwOutOfMemoryError(callFrame);
+            throwOutOfMemoryError(exec);
             VM_THROW_EXCEPTION();
         }
@@ -4301 +4337 @@
 
         if (UNLIKELY(!value)) {
-            throwOutOfMemoryError(callFrame);
+            throwOutOfMemoryError(exec);
             VM_THROW_EXCEPTION();
         }
@@ -4308 +4344 @@
 
     // All other cases are pretty uncommon
-    JSValue* result = jsAddSlowCase(callFrame, v1, v2);
+    JSValue* result = jsAddSlowCase(exec, v1, v2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4317 +4353 @@
     JSValue* v = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) + 1);
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, v->toNumber(exec) + 1);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4325 +4361 @@
 void Machine::cti_timeout_check(CTI_ARGS)
 {
-    if (ARG_globalData->machine->checkTimeout(ARG_callFrame->dynamicGlobalObject())) {
+    if (ARG_globalData->machine->checkTimeout(ARG_exec->dynamicGlobalObject())) {
         ARG_globalData->exception = createInterruptedExecutionException(ARG_globalData);
         VM_THROW_EXCEPTION_AT_END();
@@ -4335 +4371 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    CallFrame* callFrame = ARG_callFrame;
-
-    bool result = jsLess(callFrame, src1, src2);
+    ExecState* exec = ARG_exec;
+
+    bool result = jsLess(exec, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4346 +4382 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    CallFrame* callFrame = ARG_callFrame;
-
-    bool result = jsLessEq(callFrame, src1, src2);
+    ExecState* exec = ARG_exec;
+
+    bool result = jsLessEq(exec, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4355 +4391 @@
 JSValue* Machine::cti_op_new_object(CTI_ARGS)
 {
-    return constructEmptyObject(ARG_callFrame);;
+    return constructEmptyObject(ARG_exec);;
 }
 
 void Machine::cti_op_put_by_id(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     PutPropertySlot slot;
-    ARG_src1->put(callFrame, ident, ARG_src3, slot);
+    ARG_src1->put(exec, ident, ARG_src3, slot);
 
     ctiRepatchCallByReturnAddress(CTI_RETURN_ADDRESS, (void*)cti_op_put_by_id_second);
@@ -4373 +4409 @@
 void Machine::cti_op_put_by_id_second(CTI_ARGS)
 {
+    ExecState* exec = ARG_exec;
+    Identifier& ident = *ARG_id2;
+
+    JSValue* baseValue = ARG_src1;
     PutPropertySlot slot;
-    ARG_src1->put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
-    ARG_globalData->machine->tryCTICachePutByID(ARG_callFrame, ARG_callFrame->codeBlock(), CTI_RETURN_ADDRESS, ARG_src1, slot);
+    baseValue->put(exec, ident, ARG_src3, slot);
+
+    Register* r = ARG_r;
+    ARG_globalData->machine->tryCTICachePutByID(exec, codeBlock(r), CTI_RETURN_ADDRESS, baseValue, slot);
+
     VM_CHECK_EXCEPTION_AT_END();
 }
@@ -4381 +4424 @@
 void Machine::cti_op_put_by_id_generic(CTI_ARGS)
 {
+    ExecState* exec = ARG_exec;
+    Identifier& ident = *ARG_id2;
+
     PutPropertySlot slot;
-    ARG_src1->put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
+    ARG_src1->put(exec, ident, ARG_src3, slot);
+
     VM_CHECK_EXCEPTION_AT_END();
 }
@@ -4388 +4435 @@
 void Machine::cti_op_put_by_id_fail(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     PutPropertySlot slot;
-    ARG_src1->put(callFrame, ident, ARG_src3, slot);
+    ARG_src1->put(exec, ident, ARG_src3, slot);
 
     // should probably uncachePutByID() ... this would mean doing a vPC lookup - might be worth just bleeding this until the end.
@@ -4402 +4449 @@
 JSValue* Machine::cti_op_get_by_id(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValue* result = baseValue->get(exec, ident, slot);
 
     ctiRepatchCallByReturnAddress(CTI_RETURN_ADDRESS, (void*)cti_op_get_by_id_second);
@@ -4417 +4464 @@
 JSValue* Machine::cti_op_get_by_id_second(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
-
-    ARG_globalData->machine->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), CTI_RETURN_ADDRESS, baseValue, ident, slot);
+    JSValue* result = baseValue->get(exec, ident, slot);
+
+    Register* r = ARG_r;
+    ARG_globalData->machine->tryCTICacheGetByID(exec, codeBlock(r), CTI_RETURN_ADDRESS, baseValue, ident, slot);
 
     VM_CHECK_EXCEPTION_AT_END();
@@ -4432 +4480 @@
 JSValue* Machine::cti_op_get_by_id_generic(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValue* result = baseValue->get(exec, ident, slot);
 
     VM_CHECK_EXCEPTION_AT_END();
@@ -4445 +4493 @@
 JSValue* Machine::cti_op_get_by_id_fail(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(callFrame, ident, slot);
+    JSValue* result = baseValue->get(exec, ident, slot);
 
     // should probably uncacheGetByID() ... this would mean doing a vPC lookup - might be worth just bleeding this until the end.
@@ -4461 +4509 @@
 JSValue* Machine::cti_op_instanceof(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     JSValue* value = ARG_src1;
     JSValue* baseVal = ARG_src2;
@@ -4475 +4523 @@
 
     if (!baseVal->isObject()) {
-        CallFrame* callFrame = ARG_callFrame;
-        CodeBlock* codeBlock = callFrame->codeBlock();
+        Register* r = ARG_r;
+        CodeBlock* codeBlock = Machine::codeBlock(r);
         ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
         unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-        ARG_globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+        ARG_globalData->exception = createInvalidParamError(exec, "instanceof", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
         VM_THROW_EXCEPTION();
     }
@@ -4487 +4535 @@
 
     if (!proto->isObject()) {
-        throwError(callFrame, TypeError, "instanceof called on an object with an invalid prototype property.");
+        throwError(exec, TypeError, "instanceof called on an object with an invalid prototype property.");
         VM_THROW_EXCEPTION();
     }
@@ -4494 +4542 @@
         return jsBoolean(false);
 
-    JSValue* result = jsBoolean(static_cast<JSObject*>(baseCell)->hasInstance(callFrame, valueCell, protoCell));
+    JSValue* result = jsBoolean(static_cast<JSObject*>(baseCell)->hasInstance(exec, valueCell, protoCell));
     VM_CHECK_EXCEPTION_AT_END();
 
@@ -4502 +4550 @@
 JSValue* Machine::cti_op_del_by_id(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Identifier& ident = *ARG_id2;
     
-    JSObject* baseObj = ARG_src1->toObject(callFrame);
-
-    JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
+    JSObject* baseObj = ARG_src1->toObject(exec);
+
+    JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4522 +4570 @@
         return jsNumber(ARG_globalData, left * right);
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) * src2->toNumber(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) * src2->toNumber(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4530 +4578 @@
 JSValue* Machine::cti_op_new_func(CTI_ARGS)
 {
-    return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
+    return ARG_func1->makeFunction(ARG_exec, Machine::scopeChain(ARG_r));
 }
 
@@ -4541 +4589 @@
 
     if (UNLIKELY(*ARG_profilerReference != 0))
-        (*ARG_profilerReference)->willExecute(ARG_callFrame, static_cast<JSFunction*>(ARG_src1));
+        (*ARG_profilerReference)->willExecute(CallFrame::create(ARG_r), static_cast<JSObject*>(ARG_src1));
 
     ScopeChainNode* callDataScopeChain = static_cast<JSFunction*>(ARG_src1)->m_scopeChain.node();
     CodeBlock* newCodeBlock = &static_cast<JSFunction*>(ARG_src1)->m_body->byteCode(callDataScopeChain);
 
-    CallFrame* callFrame = slideRegisterWindowForCall(newCodeBlock, ARG_registerFile, ARG_callFrame, ARG_int2, ARG_int3);
-    if (UNLIKELY(!callFrame)) {
-        ARG_globalData->exception = createStackOverflowError(ARG_callFrame);
+    Register* r = slideRegisterWindowForCall(newCodeBlock, ARG_registerFile, ARG_r, ARG_int2, ARG_int3);
+    if (UNLIKELY(!r)) {
+        ARG_globalData->exception = createStackOverflowError(CallFrame::create(ARG_r));
         VM_THROW_EXCEPTION_2();
     }
 
-    VoidPtrPair pair = { newCodeBlock, callFrame };
+    VoidPtrPair pair = { newCodeBlock, r };
     return pair;
 }
@@ -4558 +4606 @@
 void* Machine::cti_vm_compile(CTI_ARGS)
 {
-    CodeBlock* codeBlock = ARG_callFrame->codeBlock();
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
+
     if (!codeBlock->ctiCode)
-        CTI::compile(ARG_globalData->machine, ARG_callFrame, codeBlock);
+        CTI::compile(ARG_globalData->machine, CallFrame::create(r), codeBlock);
+
     return codeBlock->ctiCode;
 }
@@ -4566 +4617 @@
 JSValue* Machine::cti_op_push_activation(CTI_ARGS)
 {
-    JSActivation* activation = new (ARG_globalData) JSActivation(ARG_callFrame, static_cast<FunctionBodyNode*>(ARG_callFrame->codeBlock()->ownerNode));
-    ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->copy()->push(activation));
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+
+    JSActivation* activation = new (ARG_globalData) JSActivation(exec, static_cast<FunctionBodyNode*>(codeBlock->ownerNode), r);
+    r[RegisterFile::ScopeChain] = scopeChain->copy()->push(activation);
     return activation;
 }
@@ -4583 +4639 @@
         int registerOffset = ARG_int2;
         int argCount = ARG_int3;
-        CallFrame* previousCallFrame = ARG_callFrame;
-        CallFrame* callFrame = CallFrame::create(previousCallFrame->registers() + registerOffset);
-
-        callFrame->init(0, ARG_instr4 + 1, previousCallFrame->scopeChain(), previousCallFrame, 0, argCount, static_cast<JSFunction*>(funcVal));
-        ARG_setCallFrame(callFrame);
+        Register* savedR = ARG_r;
+        Register* r = savedR + registerOffset;
+
+        initializeCallFrame(r, 0, ARG_instr4 + 1, scopeChain(savedR), savedR, 0, argCount, funcVal);
+        ARG_setR(r);
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->willExecute(callFrame, static_cast<JSFunction*>(funcVal));
-
-        Register* argv = ARG_callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
+            (*ARG_profilerReference)->willExecute(CallFrame::create(r), static_cast<JSObject*>(funcVal));
+
+        Register* argv = r - RegisterFile::CallFrameHeaderSize - argCount;
         ArgList argList(argv + 1, argCount - 1);
 
         CTI_MACHINE_SAMPLING_callingHostFunction();
 
-        JSValue* returnValue = callData.native.function(callFrame, static_cast<JSFunction*>(funcVal), argv[0].jsValue(callFrame), argList);
-        ARG_setCallFrame(previousCallFrame);
+        JSValue* returnValue = callData.native.function(CallFrame::create(r), static_cast<JSObject*>(funcVal), argv[0].jsValue(CallFrame::create(r)), argList);
+        ARG_setR(savedR);
         VM_CHECK_EXCEPTION();
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->didExecute(previousCallFrame, static_cast<JSFunction*>(funcVal));
+            (*ARG_profilerReference)->didExecute(CallFrame::create(savedR), static_cast<JSObject*>(funcVal));
 
         return returnValue;
@@ -4609 +4665 @@
     ASSERT(callType == CallTypeNone);
 
-    ARG_globalData->exception = createNotAFunctionError(ARG_callFrame, funcVal, ARG_instr4, ARG_callFrame->codeBlock());
+    ARG_globalData->exception = createNotAFunctionError(CallFrame::create(ARG_r), funcVal, ARG_instr4, codeBlock(ARG_r));
     VM_THROW_EXCEPTION();
 }
@@ -4615 +4671 @@
 void Machine::cti_op_create_arguments(CTI_ARGS)
 {
-    Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame);
-    ARG_callFrame->setCalleeArguments(arguments);
-    ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+
+    Arguments* arguments = new (ARG_globalData) Arguments(exec, r);
+    r[RegisterFile::OptionalCalleeArguments] = arguments;
+    r[RegisterFile::ArgumentsRegister] = arguments;
 }
 
 void Machine::cti_op_tear_off_activation(CTI_ARGS)
 {
-    ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain);
-    ASSERT(ARG_src1->isObject(&JSActivation::info));
-    static_cast<JSActivation*>(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
+    Register* r = ARG_r;
+
+    JSActivation* activation = static_cast<JSActivation*>(ARG_src1);
+    ASSERT(codeBlock(r)->needsFullScopeChain);
+    ASSERT(activation->isObject(&JSActivation::info));
+
+    Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+    ASSERT(!arguments || arguments->isObject(&Arguments::info));
+    activation->copyRegisters(arguments);
 }
 
 void Machine::cti_op_tear_off_arguments(CTI_ARGS)
 {
-    ASSERT(ARG_callFrame->codeBlock()->usesArguments && !ARG_callFrame->codeBlock()->needsFullScopeChain);
-    ARG_callFrame->optionalCalleeArguments()->copyRegisters();
+    Register* r = ARG_r;
+
+    Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+    ASSERT(codeBlock(r)->usesArguments && !codeBlock(r)->needsFullScopeChain);
+    ASSERT(arguments->isObject(&Arguments::info));
+
+    arguments->copyRegisters();
 }
 
 void Machine::cti_op_ret_profiler(CTI_ARGS)
 {
+    ExecState* exec = ARG_exec;
+
+    Register* r = ARG_r;
     ASSERT(*ARG_profilerReference);
-    (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_callFrame->callee());
+    (*ARG_profilerReference)->didExecute(exec, static_cast<JSObject*>(r[RegisterFile::Callee].jsValue(exec)));
 }
 
 void Machine::cti_op_ret_scopeChain(CTI_ARGS)
 {
-    ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain);
-    ARG_callFrame->scopeChain()->deref();
+    Register* r = ARG_r;
+    ASSERT(codeBlock(r)->needsFullScopeChain);
+    scopeChain(r)->deref();
 }
 
 JSValue* Machine::cti_op_new_array(CTI_ARGS)
 {
-    ArgList argList(ARG_registers1, ARG_int2);
-    return constructArray(ARG_callFrame, argList);
+    ArgList argsList(ARG_registers1, ARG_int2);
+    return constructArray(ARG_exec, argsList);
 }
 
 JSValue* Machine::cti_op_resolve(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -4664 +4739 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+        if (o->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
             VM_CHECK_EXCEPTION_AT_END();
             return result;
@@ -4671 +4746 @@
     } while (++iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
     VM_THROW_EXCEPTION();
 }
@@ -4681 +4756 @@
 {
     RegisterFile* registerFile = ARG_registerFile;
-    CallFrame* callFrame = ARG_callFrame;
+    Register* r = ARG_r;
 
     JSFunction* constructor = static_cast<JSFunction*>(ARG_src1);
@@ -4695 +4770 @@
 
     if (*ARG_profilerReference)
-        (*ARG_profilerReference)->willExecute(callFrame, constructor);
+        (*ARG_profilerReference)->willExecute(CallFrame::create(r), constructor);
 
     ScopeChainNode* callDataScopeChain = constructor->m_scopeChain.node();
@@ -4708 +4783 @@
     JSObject* newObject = new (ARG_globalData) JSObject(structure);
 
-    callFrame[firstArg] = newObject; // "this" value
-
-    callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
-    if (UNLIKELY(!callFrame)) {
-        ARG_globalData->exception = createStackOverflowError(ARG_callFrame);
+    r[firstArg] = newObject; // "this" value
+
+    r = slideRegisterWindowForCall(newCodeBlock, registerFile, r, registerOffset, argCount);
+    if (UNLIKELY(!r)) {
+        ARG_globalData->exception = createStackOverflowError(CallFrame::create(ARG_r));
         VM_THROW_EXCEPTION_2();
     }
 
-    VoidPtrPair pair = { newCodeBlock, callFrame };
+    VoidPtrPair pair = { newCodeBlock, r };
     return pair;
 }
@@ -4722 +4797 @@
 JSValue* Machine::cti_op_construct_NotJSConstruct(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
 
     JSValue* constrVal = ARG_src1;
@@ -4735 +4811 @@
     if (constructType == ConstructTypeHost) {
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->willExecute(callFrame, constructor);
-
-        ArgList argList(callFrame->registers() + firstArg + 1, argCount - 1);
+            (*ARG_profilerReference)->willExecute(exec, constructor);
+
+        ArgList argList(r + firstArg + 1, argCount - 1);
 
         CTI_MACHINE_SAMPLING_callingHostFunction();
 
-        JSValue* returnValue = constructData.native.function(callFrame, constructor, argList);
+        JSValue* returnValue = constructData.native.function(exec, constructor, argList);
         VM_CHECK_EXCEPTION();
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->didExecute(callFrame, constructor);
+            (*ARG_profilerReference)->didExecute(exec, constructor);
 
         return returnValue;
@@ -4752 +4828 @@
     ASSERT(constructType == ConstructTypeNone);
 
-    ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, ARG_instr6, callFrame->codeBlock());
+    exec->setException(createNotAConstructorError(exec, constrVal, ARG_instr6, codeBlock(r)));
     VM_THROW_EXCEPTION();
 }
@@ -4758 +4834 @@
 JSValue* Machine::cti_op_get_by_val(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Machine* machine = ARG_globalData->machine;
 
@@ -4774 +4850 @@
                 result = jsArray->getIndex(i);
             else
-                result = jsArray->JSArray::get(callFrame, i);
+                result = jsArray->JSArray::get(exec, i);
         } else if (machine->isJSString(baseValue) && static_cast<JSString*>(baseValue)->canGetIndex(i))
             result = static_cast<JSString*>(baseValue)->getIndex(ARG_globalData, i);
         else
-            result = baseValue->get(callFrame, i);
+            result = baseValue->get(exec, i);
     } else {
-        Identifier property(callFrame, subscript->toString(callFrame));
-        result = baseValue->get(callFrame, property);
+        Identifier property(exec, subscript->toString(exec));
+        result = baseValue->get(exec, property);
     }
 
@@ -4790 +4866 @@
 VoidPtrPair Machine::cti_op_resolve_func(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -4805 +4882 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(callFrame, ident, slot)) {            
+        if (base->getPropertySlot(exec, ident, slot)) {            
             // ECMA 11.2.3 says that if we hit an activation the this value should be null.
             // However, section 10.2.3 says that in the case where the value provided
@@ -4813 +4890 @@
             // that in host objects you always get a valid object for this.
             // We also handle wrapper substitution for the global object at the same time.
-            JSObject* thisObj = base->toThisObject(callFrame);
-            JSValue* result = slot.getValue(callFrame, ident);
+            JSObject* thisObj = base->toThisObject(exec);
+            JSValue* result = slot.getValue(exec, ident);
             VM_CHECK_EXCEPTION_AT_END();
 
@@ -4823 +4900 @@
     } while (iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
     VM_THROW_EXCEPTION_2();
 }
@@ -4840 +4917 @@
         return jsNumber(ARG_globalData, left - right);
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) - src2->toNumber(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) - src2->toNumber(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4848 +4925 @@
 void Machine::cti_op_put_by_val(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     Machine* machine = ARG_globalData->machine;
 
@@ -4864 +4941 @@
                 jsArray->setIndex(i, value);
             else
-                jsArray->JSArray::put(callFrame, i, value);
+                jsArray->JSArray::put(exec, i, value);
         } else
-            baseValue->put(callFrame, i, value);
+            baseValue->put(exec, i, value);
     } else {
-        Identifier property(callFrame, subscript->toString(callFrame));
+        Identifier property(exec, subscript->toString(exec));
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
-            baseValue->put(callFrame, property, value, slot);
+            baseValue->put(exec, property, value, slot);
         }
     }
@@ -4880 +4957 @@
 void Machine::cti_op_put_by_val_array(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     JSValue* baseValue = ARG_src1;
@@ -4889 +4966 @@
 
     if (LIKELY(i >= 0))
-        static_cast<JSArray*>(baseValue)->JSArray::put(callFrame, i, value);
+        static_cast<JSArray*>(baseValue)->JSArray::put(exec, i, value);
     else {
-        Identifier property(callFrame, JSImmediate::from(i)->toString(callFrame));
+        Identifier property(exec, JSImmediate::from(i)->toString(exec));
         // FIXME: can toString throw an exception here?
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
-            baseValue->put(callFrame, property, value, slot);
+            baseValue->put(exec, property, value, slot);
         }
     }
@@ -4904 +4981 @@
 JSValue* Machine::cti_op_lesseq(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsBoolean(jsLessEq(exec, ARG_src1, ARG_src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4914 +4991 @@
     JSValue* src1 = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    bool result = src1->toBoolean(callFrame);
+    ExecState* exec = ARG_exec;
+
+    bool result = src1->toBoolean(exec);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4929 +5006 @@
         return jsNumber(ARG_globalData, -v);
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, -src->toNumber(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, -src->toNumber(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4937 +5014 @@
 JSValue* Machine::cti_op_resolve_base(CTI_ARGS)
 {
-    return inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain());
+    return inlineResolveBase(ARG_exec, *ARG_id1, scopeChain(ARG_r));
 }
 
 JSValue* Machine::cti_op_resolve_skip(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
 
     int skip = ARG_int2;
@@ -4958 +5036 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+        if (o->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
             VM_CHECK_EXCEPTION_AT_END();
             return result;
@@ -4965 +5043 @@
     } while (++iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
     VM_THROW_EXCEPTION();
 }
@@ -4974 +5052 @@
 JSValue* Machine::cti_op_resolve_global(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(ARG_src1);
     Identifier& ident = *ARG_id2;
@@ -4981 +5059 @@
 
     PropertySlot slot(globalObject);
-    if (globalObject->getPropertySlot(callFrame, ident, slot)) {
-        JSValue* result = slot.getValue(callFrame, ident);
+    if (globalObject->getPropertySlot(exec, ident, slot)) {
+        JSValue* result = slot.getValue(exec, ident);
         if (slot.isCacheable()) {
             if (vPC[4].u.structureID)
@@ -4996 +5074 @@
     }
     
-    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPC, callFrame->codeBlock());
+    Register* r = ARG_r;
+    exec->setException(createUndefinedVariableError(exec, ident, vPC, codeBlock(r)));    
     VM_THROW_EXCEPTION();
 }
@@ -5010 +5089 @@
         return jsNumber(ARG_globalData, left / right);
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) / src2->toNumber(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) / src2->toNumber(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5020 +5099 @@
     JSValue* v = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) - 1);
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, v->toNumber(exec) - 1);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5030 +5109 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    CallFrame* callFrame = ARG_callFrame;
-
-    bool result = jsLess(callFrame, src1, src2);
+    ExecState* exec = ARG_exec;
+
+    bool result = jsLess(exec, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5041 +5120 @@
     JSValue* src = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* result = jsBoolean(!src->toBoolean(callFrame));
+    ExecState* exec = ARG_exec;
+
+    JSValue* result = jsBoolean(!src->toBoolean(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5052 +5131 @@
     JSValue* src1 = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    bool result = src1->toBoolean(callFrame);
+    ExecState* exec = ARG_exec;
+
+    bool result = src1->toBoolean(exec);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5063 +5142 @@
     JSValue* v = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* number = v->toJSNumber(callFrame);
+    ExecState* exec = ARG_exec;
+
+    JSValue* number = v->toJSNumber(exec);
     VM_CHECK_EXCEPTION_2();
 
@@ -5077 +5156 @@
     JSValue* src2 = ARG_src2;
 
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
-    JSValue* result = jsBoolean(equalSlowCaseInline(callFrame, src1, src2));
+    JSValue* result = jsBoolean(equalSlowCaseInline(exec, src1, src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5097 +5176 @@
         return jsNumber(ARG_globalData, left << (right & 0x1f));
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5113 +5192 @@
         return jsNumber(ARG_globalData, left & right);
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) & src2->toInt32(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) & src2->toInt32(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5131 +5210 @@
         return jsNumber(ARG_globalData, left >> (right & 0x1f));
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5145 +5224 @@
         return jsNumber(ARG_globalData, ~value);
             
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsNumber(ARG_globalData, ~src->toInt32(callFrame));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsNumber(ARG_globalData, ~src->toInt32(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5153 +5232 @@
 VoidPtrPair Machine::cti_op_resolve_with_base(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -5168 +5248 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(callFrame, ident, slot)) {
-            JSValue* result = slot.getValue(callFrame, ident);
+        if (base->getPropertySlot(exec, ident, slot)) {
+            JSValue* result = slot.getValue(exec, ident);
             VM_CHECK_EXCEPTION_AT_END();
 
@@ -5178 +5258 @@
     } while (iter != end);
 
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
     VM_THROW_EXCEPTION_2();
 }
@@ -5187 +5267 @@
 JSValue* Machine::cti_op_new_func_exp(CTI_ARGS)
 {
-    return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
+    return ARG_funcexp1->makeFunction(ARG_exec, scopeChain(ARG_r));
 }
 
@@ -5195 +5275 @@
     JSValue* divisorValue = ARG_src2;
 
-    CallFrame* callFrame = ARG_callFrame;
-    double d = dividendValue->toNumber(callFrame);
-    JSValue* result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(callFrame)));
+    ExecState* exec = ARG_exec;
+    double d = dividendValue->toNumber(exec);
+    JSValue* result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(exec)));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5204 +5284 @@
 JSValue* Machine::cti_op_less(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsBoolean(jsLess(exec, ARG_src1, ARG_src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5217 +5297 @@
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
 
-    CallFrame* callFrame = ARG_callFrame;
-    JSValue* result = jsBoolean(!equalSlowCaseInline(callFrame, src1, src2));
+    ExecState* exec = ARG_exec;
+    JSValue* result = jsBoolean(!equalSlowCaseInline(exec, src1, src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5227 +5307 @@
     JSValue* v = ARG_src1;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* number = v->toJSNumber(callFrame);
+    ExecState* exec = ARG_exec;
+
+    JSValue* number = v->toJSNumber(exec);
     VM_CHECK_EXCEPTION_2();
 
@@ -5241 +5321 @@
     JSValue* shift = ARG_src2;
 
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
         return JSImmediate::rightShiftImmediateNumbers(val, shift);
     else {
-        JSValue* result = jsNumber(ARG_globalData, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
+        JSValue* result = jsNumber(ARG_globalData, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
         VM_CHECK_EXCEPTION_AT_END();
         return result;
@@ -5257 +5337 @@
     JSValue* src2 = ARG_src2;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
+    ExecState* exec = ARG_exec;
+
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) ^ src2->toInt32(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5266 +5346 @@
 JSValue* Machine::cti_op_new_regexp(CTI_ARGS)
 {
-    return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
+    return new (ARG_globalData) RegExpObject(scopeChain(ARG_r)->globalObject()->regExpStructure(), ARG_regexp1);
 }
 
@@ -5274 +5354 @@
     JSValue* src2 = ARG_src2;
 
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) | src2->toInt32(callFrame));
+    ExecState* exec = ARG_exec;
+
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) | src2->toInt32(exec));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5283 +5363 @@
 JSValue* Machine::cti_op_call_eval(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     RegisterFile* registerFile = ARG_registerFile;
-    CodeBlock* codeBlock = callFrame->codeBlock();
-    ScopeChainNode* scopeChain = callFrame->scopeChain();
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
+    ScopeChainNode* scopeChain = Machine::scopeChain(r);
 
     Machine* machine = ARG_globalData->machine;
@@ -5296 +5377 @@
 
     if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
-        JSObject* thisObject = static_cast<JSObject*>(callFrame[codeBlock->thisRegister].jsValue(callFrame));
+        JSObject* thisObject = static_cast<JSObject*>(r[codeBlock->thisRegister].jsValue(exec));
         JSValue* exceptionValue = 0;
-        JSValue* result = machine->callEval(callFrame, thisObject, scopeChain, registerFile, registerOffset - RegisterFile::CallFrameHeaderSize - argCount, argCount, exceptionValue);
+        JSValue* result = machine->callEval(exec, thisObject, scopeChain, registerFile,  r, registerOffset - RegisterFile::CallFrameHeaderSize - argCount, argCount, exceptionValue);
         VM_CHECK_EXCEPTION_ARG(exceptionValue);
         return result;
@@ -5308 +5389 @@
 void* Machine::cti_op_throw(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
 
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
@@ -5317 +5399 @@
     ASSERT(exceptionValue);
 
-    Instruction* handlerVPC = ARG_globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, true);
+    Instruction* handlerVPC = ARG_globalData->machine->throwException(exec, exceptionValue, codeBlock->instructions.begin() + vPCIndex, r, true);
 
     if (!handlerVPC) {
@@ -5324 +5406 @@
     }
 
-    ARG_setCallFrame(callFrame);
-    void* catchRoutine = callFrame->codeBlock()->nativeExceptionCodeForHandlerVPC(handlerVPC);
+    ARG_setR(r);
+    void* catchRoutine = Machine::codeBlock(r)->nativeExceptionCodeForHandlerVPC(handlerVPC);
     ASSERT(catchRoutine);
     ctiSetReturnAddress(&CTI_RETURN_ADDRESS, catchRoutine);
@@ -5333 +5415 @@
 JSPropertyNameIterator* Machine::cti_op_get_pnames(CTI_ARGS)
 {
-    return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
+    return JSPropertyNameIterator::create(ARG_exec, ARG_src1);
 }
 
@@ -5339 +5421 @@
 {
     JSPropertyNameIterator* it = ARG_pni1;
-    JSValue* temp = it->next(ARG_callFrame);
+    JSValue* temp = it->next(ARG_exec);
     if (!temp)
         it->invalidate();
@@ -5347 +5429 @@
 void Machine::cti_op_push_scope(CTI_ARGS)
 {
-    JSObject* o = ARG_src1->toObject(ARG_callFrame);
+    ExecState* exec = ARG_exec;
+    JSValue* v = ARG_src1;
+
+    JSObject* o = v->toObject(exec);
     VM_CHECK_EXCEPTION_VOID();
-    ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
+
+    Register* r = ARG_r;
+    r[RegisterFile::ScopeChain] = scopeChain(r)->push(o);
 }
 
 void Machine::cti_op_pop_scope(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    callFrame->setScopeChain(callFrame->scopeChain()->pop());
+    Register* r = ARG_r;
+    r[RegisterFile::ScopeChain] = scopeChain(r)->pop();
 }
 
 JSValue* Machine::cti_op_typeof(CTI_ARGS)
 {
-    return jsTypeStringForValue(ARG_callFrame, ARG_src1);
+    return jsTypeStringForValue(ARG_exec, ARG_src1);
 }
 
@@ -5421 +5508 @@
 {
     JSValue* src = ARG_src1;
-    CallFrame* callFrame = ARG_callFrame;
-
-    JSValue* result = src->toJSNumber(callFrame);
+    ExecState* exec = ARG_exec;
+
+    JSValue* result = src->toJSNumber(exec);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5430 +5517 @@
 JSValue* Machine::cti_op_in(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     JSValue* baseVal = ARG_src2;
 
     if (!baseVal->isObject()) {
-        CallFrame* callFrame = ARG_callFrame;
-        CodeBlock* codeBlock = callFrame->codeBlock();
+        Register* r = ARG_r;
+        CodeBlock* codeBlock = Machine::codeBlock(r);
         ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
         unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-        ARG_globalData->exception = createInvalidParamError(callFrame, "in", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+        exec->setException(createInvalidParamError(exec, "in", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock));
         VM_THROW_EXCEPTION();
     }
@@ -5447 +5534 @@
     uint32_t i;
     if (propName->getUInt32(i))
-        return jsBoolean(baseObj->hasProperty(callFrame, i));
-
-    Identifier property(callFrame, propName->toString(callFrame));
+        return jsBoolean(baseObj->hasProperty(exec, i));
+
+    Identifier property(exec, propName->toString(exec));
     VM_CHECK_EXCEPTION();
-    return jsBoolean(baseObj->hasProperty(callFrame, property));
+    return jsBoolean(baseObj->hasProperty(exec, property));
 }
 
 JSValue* Machine::cti_op_push_new_scope(CTI_ARGS)
 {
-    JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_callFrame, *ARG_id1, ARG_src2, DontDelete);
-
-    CallFrame* callFrame = ARG_callFrame;
-    callFrame->setScopeChain(callFrame->scopeChain()->push(scope));
+    JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_exec, *ARG_id1, ARG_src2, DontDelete);
+
+    Register* r = ARG_r;
+    r[RegisterFile::ScopeChain] = scopeChain(r)->push(scope);
     return scope;
 }
@@ -5466 +5553 @@
 {
     unsigned count = ARG_int1;
-    CallFrame* callFrame = ARG_callFrame;
-
-    ScopeChainNode* tmp = callFrame->scopeChain();
+    Register* r = ARG_r;
+
+    ScopeChainNode* tmp = scopeChain(r);
     while (count--)
         tmp = tmp->pop();
-    callFrame->setScopeChain(tmp);
+    r[RegisterFile::ScopeChain] = tmp;
 }
 
 void Machine::cti_op_put_by_index(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
     unsigned property = ARG_int2;
 
-    ARG_src1->put(callFrame, property, ARG_src3);
+    ARG_src1->put(exec, property, ARG_src3);
 }
 
@@ -5486 +5573 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
 
     if (JSImmediate::isNumber(scrutinee)) {
@@ -5501 +5588 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
 
     void* result = codeBlock->characterSwitchJumpTables[tableIndex].ctiDefault;
@@ -5519 +5606 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
 
     void* result = codeBlock->stringSwitchJumpTables[tableIndex].ctiDefault;
@@ -5534 +5621 @@
 JSValue* Machine::cti_op_del_by_val(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     JSValue* baseValue = ARG_src1;
-    JSObject* baseObj = baseValue->toObject(callFrame); // may throw
+    JSObject* baseObj = baseValue->toObject(exec); // may throw
 
     JSValue* subscript = ARG_src2;
@@ -5543 +5630 @@
     uint32_t i;
     if (subscript->getUInt32(i))
-        result = jsBoolean(baseObj->deleteProperty(callFrame, i));
+        result = jsBoolean(baseObj->deleteProperty(exec, i));
     else {
         VM_CHECK_EXCEPTION();
-        Identifier property(callFrame, subscript->toString(callFrame));
+        Identifier property(exec, subscript->toString(exec));
         VM_CHECK_EXCEPTION();
-        result = jsBoolean(baseObj->deleteProperty(callFrame, property));
+        result = jsBoolean(baseObj->deleteProperty(exec, property));
     }
 
@@ -5557 +5644 @@
 void Machine::cti_op_put_getter(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     ASSERT(ARG_src1->isObject());
@@ -5563 +5650 @@
     Identifier& ident = *ARG_id2;
     ASSERT(ARG_src3->isObject());
-    baseObj->defineGetter(callFrame, ident, static_cast<JSObject*>(ARG_src3));
+    baseObj->defineGetter(exec, ident, static_cast<JSObject*>(ARG_src3));
 }
 
 void Machine::cti_op_put_setter(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
 
     ASSERT(ARG_src1->isObject());
@@ -5574 +5661 @@
     Identifier& ident = *ARG_id2;
     ASSERT(ARG_src3->isObject());
-    baseObj->defineSetter(callFrame, ident, static_cast<JSObject*>(ARG_src3));
+    baseObj->defineSetter(exec, ident, static_cast<JSObject*>(ARG_src3));
 }
 
 JSValue* Machine::cti_op_new_error(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
     unsigned type = ARG_int1;
     JSValue* message = ARG_src2;
     unsigned lineNumber = ARG_int3;
 
-    return Error::create(callFrame, static_cast<ErrorType>(type), message->toString(callFrame), lineNumber, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
+    return Error::create(exec, static_cast<ErrorType>(type), message->toString(exec), lineNumber, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
 }
 
 void Machine::cti_op_debug(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
 
     int debugHookID = ARG_int1;
@@ -5596 +5685 @@
     int lastLine = ARG_int3;
 
-    ARG_globalData->machine->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
+    ARG_globalData->machine->debug(exec, r, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
 void* Machine::cti_vm_throw(CTI_ARGS)
 {
-    CallFrame* callFrame = ARG_callFrame;
-    CodeBlock* codeBlock = callFrame->codeBlock();
+    ExecState* exec = ARG_exec;
+    Register* r = ARG_r;
+    CodeBlock* codeBlock = Machine::codeBlock(r);
 
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(ARG_globalData->throwReturnAddress));
@@ -5611 +5701 @@
     ARG_globalData->exception = 0;
 
-    Instruction* handlerVPC = ARG_globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, false);
+    Instruction* handlerVPC = ARG_globalData->machine->throwException(exec, exceptionValue, codeBlock->instructions.begin() + vPCIndex, r, false);
 
     if (!handlerVPC) {
@@ -5618 +5708 @@
     }
 
-    ARG_setCallFrame(callFrame);
-    void* catchRoutine = callFrame->codeBlock()->nativeExceptionCodeForHandlerVPC(handlerVPC);
+    ARG_setR(r);
+    void* catchRoutine = Machine::codeBlock(r)->nativeExceptionCodeForHandlerVPC(handlerVPC);
     ASSERT(catchRoutine);
     ctiSetReturnAddress(&CTI_RETURN_ADDRESS, catchRoutine);

trunk/JavaScriptCore/VM/Machine.h

@@ -45 +45 @@
     class CodeBlock;
     class EvalNode;
+    class ExecState;
     class FunctionBodyNode;
     class Instruction;
@@ -95 +96 @@
         bool isOpcode(Opcode opcode);
         
-        JSValue* execute(ProgramNode*, CallFrame*, ScopeChainNode*, JSObject* thisObj, JSValue** exception);
-        JSValue* execute(FunctionBodyNode*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValue** exception);
-        JSValue* execute(EvalNode* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception);
-
-        JSValue* retrieveArguments(CallFrame*, JSFunction*) const;
-        JSValue* retrieveCaller(CallFrame*, InternalFunction*) const;
-        void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const;
-        
-        void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
+        JSValue* execute(ProgramNode*, ExecState*, ScopeChainNode*, JSObject* thisObj, JSValue** exception);
+        JSValue* execute(FunctionBodyNode*, ExecState*, JSFunction*, JSObject* thisObj, const ArgList& args, ScopeChainNode*, JSValue** exception);
+        JSValue* execute(EvalNode* evalNode, ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, JSValue** exception);
+
+        JSValue* retrieveArguments(ExecState*, JSFunction*) const;
+        JSValue* retrieveCaller(ExecState*, InternalFunction*) const;
+        void retrieveLastCaller(ExecState* exec, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const;
+        
+        static ScopeChainNode* scopeChain(const Register* r) { return r[RegisterFile::ScopeChain].scopeChain(); }
+        static CodeBlock* codeBlock(const Register* r) { return r[RegisterFile::CodeBlock].codeBlock(); }
+
+        void getArgumentsData(Register* callFrame, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
         void setTimeoutTime(unsigned timeoutTime) { m_timeoutTime = timeoutTime; }
         
@@ -236 +240 @@
         bool isJSArray(JSValue* v) { return !JSImmediate::isImmediate(v) && v->asCell()->vptr() == m_jsArrayVptr; }
         bool isJSString(JSValue* v) { return !JSImmediate::isImmediate(v) && v->asCell()->vptr() == m_jsStringVptr; }
+        
+        ALWAYS_INLINE static void initializeCallFrame(Register* callFrame, CodeBlock*, Instruction*, ScopeChainNode*, Register* r, int returnValueRegister, int argc, JSValue* function);
 
     private:
         enum ExecutionFlag { Normal, InitializeAndReturn };
 
-        NEVER_INLINE JSValue* callEval(CallFrame*, JSObject* thisObject, ScopeChainNode*, RegisterFile*, int argv, int argc, JSValue*& exceptionValue);
-        JSValue* execute(EvalNode*, CallFrame*, JSObject* thisObject, int registerOffset, ScopeChainNode*, JSValue** exception);
-
-        NEVER_INLINE void debug(CallFrame*, DebugHookID, int firstLine, int lastLine);
-
-        NEVER_INLINE bool resolve(CallFrame*, Instruction*, JSValue*& exceptionValue);
-        NEVER_INLINE bool resolveSkip(CallFrame*, Instruction*, JSValue*& exceptionValue);
-        NEVER_INLINE bool resolveGlobal(CallFrame*, Instruction*, JSValue*& exceptionValue);
-        NEVER_INLINE void resolveBase(CallFrame*, Instruction* vPC);
-        NEVER_INLINE bool resolveBaseAndProperty(CallFrame*, Instruction*, JSValue*& exceptionValue);
-        NEVER_INLINE ScopeChainNode* createExceptionScope(CallFrame*, const Instruction* vPC);
-
-        NEVER_INLINE bool unwindCallFrame(CallFrame*&, JSValue*, const Instruction*&, CodeBlock*&);
-        NEVER_INLINE Instruction* throwException(CallFrame*&, JSValue*&, const Instruction*, bool);
-        NEVER_INLINE bool resolveBaseAndFunc(CallFrame*, Instruction*, JSValue*& exceptionValue);
-
-        static ALWAYS_INLINE CallFrame* slideRegisterWindowForCall(CodeBlock*, RegisterFile*, CallFrame*, size_t registerOffset, int argc);
-
-        static CallFrame* findFunctionCallFrame(CallFrame*, InternalFunction*);
-
-        JSValue* privateExecute(ExecutionFlag, RegisterFile*, CallFrame*, JSValue** exception);
-
-        void dumpCallFrame(const RegisterFile*, CallFrame*);
-        void dumpRegisters(const RegisterFile*, CallFrame*);
+        NEVER_INLINE JSValue* callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile*, Register* r, int argv, int argc, JSValue*& exceptionValue);
+        JSValue* execute(EvalNode*, ExecState*, JSObject* thisObj, int registerOffset, ScopeChainNode*, JSValue** exception);
+
+        NEVER_INLINE void debug(ExecState*, Register*, DebugHookID, int firstLine, int lastLine);
+
+        NEVER_INLINE bool resolve(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue);
+        NEVER_INLINE bool resolveSkip(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue);
+        NEVER_INLINE bool resolveGlobal(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue);
+        NEVER_INLINE void resolveBase(ExecState* exec, Instruction* vPC, Register* r);
+        NEVER_INLINE bool resolveBaseAndProperty(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue);
+        NEVER_INLINE ScopeChainNode* createExceptionScope(ExecState* exec, const Instruction* vPC, Register* r);
+
+        NEVER_INLINE bool unwindCallFrame(ExecState*&, JSValue*, const Instruction*&, CodeBlock*&, Register*&);
+        NEVER_INLINE Instruction* throwException(ExecState*, JSValue*&, const Instruction*, Register*&, bool);
+        NEVER_INLINE bool resolveBaseAndFunc(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue);
+
+        Register* callFrame(ExecState*, InternalFunction*) const;
+
+        JSValue* privateExecute(ExecutionFlag, RegisterFile*, Register*, JSValue** exception);
+
+        void dumpCallFrame(const RegisterFile*, const Register*);
+        void dumpRegisters(const RegisterFile*, const Register*);
 
         JSValue* checkTimeout(JSGlobalObject*);
         void resetTimeoutCheck();
 
-        void tryCacheGetByID(CallFrame*, CodeBlock*, Instruction*, JSValue* baseValue, const Identifier& propertyName, const PropertySlot&);
+        void tryCacheGetByID(ExecState*, CodeBlock*, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot&);
         void uncacheGetByID(CodeBlock*, Instruction* vPC);
-        void tryCachePutByID(CallFrame*, CodeBlock*, Instruction*, JSValue* baseValue, const PutPropertySlot&);
+        void tryCachePutByID(ExecState* exec, CodeBlock*, Instruction* vPC, JSValue* baseValue, const PutPropertySlot&);
         void uncachePutByID(CodeBlock*, Instruction* vPC);
 
 #if ENABLE(CTI)
-        void tryCTICacheGetByID(CallFrame*, CodeBlock*, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot&);
-        void tryCTICachePutByID(CallFrame*, CodeBlock*, void* returnAddress, JSValue* baseValue, const PutPropertySlot&);
-
-        void* getCTIArrayLengthTrampoline(CallFrame*, CodeBlock*);
-        void* getCTIStringLengthTrampoline(CallFrame*, CodeBlock*);
+        void tryCTICacheGetByID(ExecState*, CodeBlock*, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot&);
+        void tryCTICachePutByID(ExecState*, CodeBlock*, void* returnAddress, JSValue* baseValue, const PutPropertySlot&);
+
+        void* getCTIArrayLengthTrampoline(ExecState*, CodeBlock*);
+        void* getCTIStringLengthTrampoline(ExecState*, CodeBlock*);
 
         void* m_ctiArrayLengthTrampoline;
@@ -306 +310 @@
     };
 
+    ALWAYS_INLINE void Machine::initializeCallFrame(Register* callFrame, CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain, Register* r, int returnValueRegister, int argc, JSValue* function)
+    {
+        ASSERT(r); // use makeHostCallFramePointer(0) to create a host call frame sentinel.
+        callFrame[RegisterFile::CodeBlock] = codeBlock;
+        callFrame[RegisterFile::ScopeChain] = scopeChain;
+        callFrame[RegisterFile::CallerRegisters] = r;
+        callFrame[RegisterFile::ReturnPC] = vPC;
+        callFrame[RegisterFile::ReturnValueRegister] = returnValueRegister;
+        callFrame[RegisterFile::ArgumentCount] = argc; // original argument count (for the sake of the "arguments" object)
+        callFrame[RegisterFile::Callee] = function;
+        callFrame[RegisterFile::OptionalCalleeArguments] = nullJSValue;
+    }
+
+    const intptr_t HostCallFrameMask = 1;
+
+    inline Register* makeHostCallFramePointer(Register* callFrame)
+    {
+        return reinterpret_cast<Register*>(reinterpret_cast<intptr_t>(callFrame) | HostCallFrameMask);
+    }
+
+    inline bool isHostCallFrame(Register* callFrame)
+    {
+        return reinterpret_cast<intptr_t>(callFrame) & HostCallFrameMask;
+    }
+
+    inline Register* stripHostCallFrameBit(Register* callFrame)
+    {
+        return reinterpret_cast<Register*>(reinterpret_cast<intptr_t>(callFrame) & ~HostCallFrameMask);
+    }
+
 } // namespace JSC
 

trunk/JavaScriptCore/VM/Register.h

@@ -35 +35 @@
 namespace JSC {
 
-    class Arguments;
     class CodeBlock;
     class ExecState;
-    class JSActivation;
-    class JSFunction;
     class JSPropertyNameIterator;
     class JSValue;
     class ScopeChainNode;
-
     struct Instruction;
-
-    typedef ExecState CallFrame;
-
+    
     static JSValue* const nullJSValue = 0;
 
@@ -55 +49 @@
         Register(JSValue*);
 
-        JSValue* jsValue(CallFrame*) const;
+        JSValue* jsValue(ExecState*) const;
         JSValue* getJSValue() const;
 
@@ -62 +56 @@
         
     private:
-        friend class ExecState;
         friend class Machine;
 
-        // Only CallFrame and Machine should use these functions.
-
+        // Only the Machine should use these functions.
+
+        Register(CodeBlock*);
+        Register(ScopeChainNode*);
         Register(intptr_t);
-
-        Register(JSActivation*);
-        Register(Arguments*);
-        Register(CallFrame*);
-        Register(CodeBlock*);
-        Register(JSFunction*);
+        Register(Register*);
+        Register(Instruction*);
         Register(JSPropertyNameIterator*);
-        Register(ScopeChainNode*);
-        Register(Instruction*);
-
+        explicit Register(void*);
+
+        CodeBlock* codeBlock() const;
+        ScopeChainNode* scopeChain() const;
         intptr_t i() const;
+        Register* r() const;
+        Instruction* vPC() const;
+        JSPropertyNameIterator* jsPropertyNameIterator() const;
         void* v() const;
 
-        JSActivation* activation() const;
-        Arguments* arguments() const;
-        CallFrame* callFrame() const;
-        CodeBlock* codeBlock() const;
-        JSFunction* function() const;
-        JSPropertyNameIterator* propertyNameIterator() const;
-        ScopeChainNode* scopeChain() const;
-        Instruction* vPC() const;
-
         union {
+        private:
+            friend class Register;
+
+            CodeBlock* codeBlock;
+            Instruction* vPC;
+            JSValue* jsValue;
+            ScopeChainNode* scopeChain;
+            JSPropertyNameIterator* jsPropertyNameIterator;
+            Register* r;
+            void* v;
             intptr_t i;
-            void* v;
-            JSValue* value;
-
-            JSActivation* activation;
-            Arguments* arguments;
-            CallFrame* callFrame;
-            CodeBlock* codeBlock;
-            JSFunction* function;
-            JSPropertyNameIterator* propertyNameIterator;
-            ScopeChainNode* scopeChain;
-            Instruction* vPC;
         } u;
 
 #ifndef NDEBUG
         enum {
-            EmptyType,
-
-            IntType,
-            ValueType,
-
-            ActivationType,
-            ArgumentsType,
-            CallFrameType,
-            CodeBlockType,
-            FunctionType,
-            InstructionType,
-            PropertyNameIteratorType,
-            RegisterType,
-            ScopeChainNodeType
+            CodeBlockType = 0, 
+            InstructionType, 
+            JSValueType, 
+            ScopeChainNodeType, 
+            JSPropertyNameIteratorType, 
+            RegisterType, 
+            IntType
         } m_type;
 #endif
+
+// FIXME: The commented out ASSERTs below are valid; NDEBUG CTI should set these when up to date.
+//        static inline ptrdiff_t offsetOf_type()
+//        {
+//            return OBJECT_OFFSET(Register, m_type);
+//        }
     };
 
-#ifndef NDEBUG
-    #define SET_TYPE(type) m_type = (type)
-    // FIXME: The CTI code to put value into registers doesn't set m_type.
-    // Once it does, we can turn this assertion back on.
-    #define ASSERT_TYPE(type)
-#else
-    #define SET_TYPE(type)
-    #define ASSERT_TYPE(type)
-#endif
-
     ALWAYS_INLINE Register::Register()
     {
 #ifndef NDEBUG
-        SET_TYPE(EmptyType);
         *this = nullJSValue;
 #endif
@@ -145 +118 @@
     ALWAYS_INLINE Register::Register(JSValue* v)
     {
-        SET_TYPE(ValueType);
-        u.value = v;
+#ifndef NDEBUG
+        m_type = JSValueType;
+#endif
+        u.jsValue = v;
     }
     
     // This function is scaffolding for legacy clients. It will eventually go away.
-    ALWAYS_INLINE JSValue* Register::jsValue(CallFrame*) const
+    ALWAYS_INLINE JSValue* Register::jsValue(ExecState*) const
     {
         // Once registers hold doubles, this function will allocate a JSValue*
         // if the register doesn't hold one already. 
-        ASSERT_TYPE(ValueType);
-        return u.value;
+//        ASSERT(m_type == JSValueType);
+        return u.jsValue;
     }
     
     ALWAYS_INLINE JSValue* Register::getJSValue() const
     {
-        ASSERT_TYPE(JSValueType);
-        return u.value;
+//        ASSERT(m_type == JSValueType);
+        return u.jsValue;
     }
     
@@ -176 +151 @@
     // Machine functions
 
-    ALWAYS_INLINE Register::Register(Arguments* arguments)
-    {
-        SET_TYPE(ArgumentsType);
-        u.arguments = arguments;
-    }
-
-    ALWAYS_INLINE Register::Register(JSActivation* activation)
-    {
-        SET_TYPE(ActivationType);
-        u.activation = activation;
-    }
-
-    ALWAYS_INLINE Register::Register(CallFrame* callFrame)
-    {
-        SET_TYPE(CallFrameType);
-        u.callFrame = callFrame;
-    }
-
     ALWAYS_INLINE Register::Register(CodeBlock* codeBlock)
     {
-        SET_TYPE(CodeBlockType);
+#ifndef NDEBUG
+        m_type = CodeBlockType;
+#endif
         u.codeBlock = codeBlock;
     }
 
-    ALWAYS_INLINE Register::Register(JSFunction* function)
-    {
-        SET_TYPE(FunctionType);
-        u.function = function;
-    }
-
     ALWAYS_INLINE Register::Register(Instruction* vPC)
     {
-        SET_TYPE(InstructionType);
+#ifndef NDEBUG
+        m_type = InstructionType;
+#endif
         u.vPC = vPC;
     }
@@ -214 +169 @@
     ALWAYS_INLINE Register::Register(ScopeChainNode* scopeChain)
     {
-        SET_TYPE(ScopeChainNodeType);
+#ifndef NDEBUG
+        m_type = ScopeChainNodeType;
+#endif
         u.scopeChain = scopeChain;
     }
 
-    ALWAYS_INLINE Register::Register(JSPropertyNameIterator* propertyNameIterator)
-    {
-        SET_TYPE(PropertyNameIteratorType);
-        u.propertyNameIterator = propertyNameIterator;
+    ALWAYS_INLINE Register::Register(JSPropertyNameIterator* jsPropertyNameIterator)
+    {
+#ifndef NDEBUG
+        m_type = JSPropertyNameIteratorType;
+#endif
+        u.jsPropertyNameIterator = jsPropertyNameIterator;
+    }
+
+    ALWAYS_INLINE Register::Register(Register* r)
+    {
+#ifndef NDEBUG
+        m_type = RegisterType;
+#endif
+        u.r = r;
     }
 
     ALWAYS_INLINE Register::Register(intptr_t i)
     {
-        SET_TYPE(IntType);
+#ifndef NDEBUG
+        m_type = IntType;
+#endif
         u.i = i;
     }
 
+    ALWAYS_INLINE Register::Register(void* v)
+    {
+        u.v = v;
+    }
+
+    ALWAYS_INLINE CodeBlock* Register::codeBlock() const
+    {
+//        ASSERT(m_type == CodeBlockType);
+        return u.codeBlock;
+    }
+    
+    ALWAYS_INLINE ScopeChainNode* Register::scopeChain() const
+    {
+//        ASSERT(m_type == ScopeChainNodeType);
+        return u.scopeChain;
+    }
+    
     ALWAYS_INLINE intptr_t Register::i() const
     {
-        ASSERT_TYPE(IntType);
+//        ASSERT(m_type == IntType);
         return u.i;
     }
     
+    ALWAYS_INLINE Register* Register::r() const
+    {
+//        ASSERT(m_type == RegisterType);
+        return u.r;
+    }
+    
+    ALWAYS_INLINE Instruction* Register::vPC() const
+    {
+//        ASSERT(m_type == InstructionType);
+        return u.vPC;
+    }
+    
+    ALWAYS_INLINE JSPropertyNameIterator* Register::jsPropertyNameIterator() const
+    {
+//        ASSERT(m_type == JSPropertyNameIteratorType);
+        return u.jsPropertyNameIterator;
+    }
+    
     ALWAYS_INLINE void* Register::v() const
     {
@@ -241 +245 @@
     }
 
-    ALWAYS_INLINE JSActivation* Register::activation() const
-    {
-        ASSERT_TYPE(ActivationType);
-        return u.activation;
-    }
-    
-    ALWAYS_INLINE Arguments* Register::arguments() const
-    {
-        ASSERT_TYPE(ArgumentsType);
-        return u.arguments;
-    }
-    
-    ALWAYS_INLINE CallFrame* Register::callFrame() const
-    {
-        ASSERT_TYPE(CallFrameType);
-        return u.callFrame;
-    }
-    
-    ALWAYS_INLINE CodeBlock* Register::codeBlock() const
-    {
-        ASSERT_TYPE(CodeBlockType);
-        return u.codeBlock;
-    }
-    
-    ALWAYS_INLINE JSFunction* Register::function() const
-    {
-        ASSERT_TYPE(FunctionType);
-        return u.function;
-    }
-    
-    ALWAYS_INLINE JSPropertyNameIterator* Register::propertyNameIterator() const
-    {
-        ASSERT_TYPE(PropertyNameIteratorType);
-        return u.propertyNameIterator;
-    }
-    
-    ALWAYS_INLINE ScopeChainNode* Register::scopeChain() const
-    {
-        ASSERT_TYPE(ScopeChainNodeType);
-        return u.scopeChain;
-    }
-    
-    ALWAYS_INLINE Instruction* Register::vPC() const
-    {
-        ASSERT_TYPE(InstructionType);
-        return u.vPC;
-    }
-
-    #undef SET_TYPE
-    #undef ASSERT_TYPE
-
 } // namespace JSC
 

trunk/JavaScriptCore/VM/RegisterFile.h

@@ -95 +95 @@
             CodeBlock = -8,
             ScopeChain = -7,
-            CallerFrame = -6,
+            CallerRegisters = -6,
             ReturnPC = -5,
             ReturnValueRegister = -4,

trunk/JavaScriptCore/kjs/Arguments.h

@@ -52 +52 @@
     class Arguments : public JSObject {
     public:
-        Arguments(CallFrame*);
+        Arguments(ExecState*, Register* callFrame);
         virtual ~Arguments();
 
@@ -75 +75 @@
         virtual const ClassInfo* classInfo() const { return &info; }
 
-        void init(CallFrame*);
+        void init(ExecState*, Register* callFrame);
 
         OwnPtr<ArgumentsData> d;
     };
 
-    inline Arguments::Arguments(CallFrame* callFrame)
-        : JSObject(callFrame->lexicalGlobalObject()->argumentsStructure())
+    inline Arguments::Arguments(ExecState* exec, Register* callFrame)
+        : JSObject(exec->lexicalGlobalObject()->argumentsStructure())
         , d(new ArgumentsData)
     {
@@ -88 +88 @@
         Register* argv;
         int numArguments;
-        callFrame->machine()->getArgumentsData(callFrame, callee, firstParameterIndex, argv, numArguments);
+        exec->machine()->getArgumentsData(callFrame, callee, firstParameterIndex, argv, numArguments);
 
         d->numParameters = callee->m_body->parameterCount();
@@ -94 +94 @@
         d->numArguments = numArguments;
 
-        d->registers = callFrame->registers();
+        d->registers = callFrame;
 
         Register* extraArguments;

trunk/JavaScriptCore/kjs/DebuggerCallFrame.cpp

@@ -39 +39 @@
 const UString* DebuggerCallFrame::functionName() const
 {
-    if (!m_callFrame->codeBlock())
+    if (!m_codeBlock)
         return 0;
 
-    JSFunction* function = static_cast<JSFunction*>(m_callFrame->callee());
+    JSFunction* function = static_cast<JSFunction*>(m_registers[RegisterFile::Callee].getJSValue());
     if (!function)
         return 0;
-    return &function->name(&m_callFrame->globalData());
+    return &function->name(m_scopeChain->globalData);
 }
 
 DebuggerCallFrame::Type DebuggerCallFrame::type() const
 {
-    if (m_callFrame->callee())
+    if (m_registers[RegisterFile::Callee].getJSValue())
         return FunctionType;
 
@@ -58 +58 @@
 JSObject* DebuggerCallFrame::thisObject() const
 {
-    if (!m_callFrame->codeBlock())
+    if (!m_codeBlock)
         return 0;
 
-    // FIXME: Why is it safe to cast this to JSObject?
-    return static_cast<JSObject*>(m_callFrame->thisValue());
+    return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].getJSValue());
 }
 
 JSValue* DebuggerCallFrame::evaluate(const UString& script, JSValue*& exception) const
 {
-    if (!m_callFrame->codeBlock())
+    if (!m_codeBlock)
         return 0;
 
@@ -73 +72 @@
     UString errMsg;
     SourceCode source = makeSource(script);
-    RefPtr<EvalNode> evalNode = m_callFrame->scopeChain()->globalData->parser->parse<EvalNode>(m_callFrame, source, &errLine, &errMsg);
+    RefPtr<EvalNode> evalNode = m_scopeChain->globalData->parser->parse<EvalNode>(CallFrame::create(m_registers), source, &errLine, &errMsg);
     if (!evalNode)
-        return Error::create(m_callFrame, SyntaxError, errMsg, errLine, source.provider()->asID(), source.provider()->url());
+        return Error::create(CallFrame::create(m_registers), SyntaxError, errMsg, errLine, source.provider()->asID(), source.provider()->url());
 
-    return m_callFrame->scopeChain()->globalData->machine->execute(evalNode.get(), m_callFrame, thisObject(), m_callFrame->scopeChain(), &exception);
+    return m_scopeChain->globalData->machine->execute(evalNode.get(), CallFrame::create(m_registers), thisObject(), m_scopeChain, &exception);
 }
 

trunk/JavaScriptCore/kjs/DebuggerCallFrame.h

@@ -30 +30 @@
 #define DebuggerCallFrame_h
 
-#include "ExecState.h"
-
 namespace JSC {
+    
+    class CodeBlock;
+    class ExecState;
+    class JSGlobalObject;
+    class JSObject;
+    class JSValue;
+    class Machine;
+    class UString;
+    class Register;
+    class ScopeChainNode;
     
     class DebuggerCallFrame {
     public:
-        enum Type { ProgramType, FunctionType };
+        enum Type {
+            ProgramType,
+            FunctionType
+        };
 
-        DebuggerCallFrame(CallFrame* callFrame, JSValue* exception)
-            : m_callFrame(callFrame)
+        DebuggerCallFrame(JSGlobalObject* dynamicGlobalObject, const CodeBlock* codeBlock, ScopeChainNode* scopeChain, Register* r, JSValue* exception)
+            : m_dynamicGlobalObject(dynamicGlobalObject)
+            , m_codeBlock(codeBlock)
+            , m_scopeChain(scopeChain)
+            , m_registers(r)
             , m_exception(exception)
         {
         }
 
-        JSGlobalObject* dynamicGlobalObject() const { return m_callFrame->dynamicGlobalObject(); }
-        const ScopeChainNode* scopeChain() const { return m_callFrame->scopeChain(); }
+        JSGlobalObject* dynamicGlobalObject() const { return m_dynamicGlobalObject; }
+        const ScopeChainNode* scopeChain() const { return m_scopeChain; }
         const UString* functionName() const;
         Type type() const;
@@ -53 +67 @@
 
     private:
-        CallFrame* m_callFrame;
+        JSGlobalObject* m_dynamicGlobalObject;
+        const CodeBlock* m_codeBlock;
+        ScopeChainNode* m_scopeChain;
+        Register* m_registers;
         JSValue* m_exception;
     };

trunk/JavaScriptCore/kjs/ExecState.cpp

@@ -1 @@
-/*
- * Copyright (C) 2008 Apple Inc. All Rights Reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#include "config.h"
-#include "ExecState.h"
-
-#include "CodeBlock.h"
-
-namespace JSC {
-
-JSValue* CallFrame::thisValue()
-{
-    return this[codeBlock()->thisRegister].jsValue(this);
-}
-
-}
+/* delete me */

trunk/JavaScriptCore/kjs/ExecState.h

@@ -24 +24 @@
 #define ExecState_h
 
-// FIXME: Rename this file to CallFrame.h.
-
 #include "JSGlobalData.h"
 #include "Machine.h"
@@ -32 +30 @@
 namespace JSC  {
 
-    class Arguments;
-    class JSActivation;
+    class ExecState;
+    class JSValue;
+    class Register;
+
+    typedef ExecState CallFrame;
 
     // Represents the current state of script execution.
     // Passed as the first argument to most functions.
-    class ExecState : private Register {
+    class ExecState : private Register, Noncopyable {
     public:
-        JSFunction* callee() const { return this[RegisterFile::Callee].function(); }
-        CodeBlock* codeBlock() const { return this[RegisterFile::CodeBlock].codeBlock(); }
-        ScopeChainNode* scopeChain() const { return this[RegisterFile::ScopeChain].scopeChain(); }
-
-        JSValue* thisValue();
+        static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
+        Register* registers() { return this; }
 
         // Global object in which execution began.
@@ -50 +48 @@
         // Global object in which the currently executing code was defined.
         // Differs from dynamicGlobalObject() during function calls across web browser frames.
-        JSGlobalObject* lexicalGlobalObject() const
+        JSGlobalObject* lexicalGlobalObject()
         {
-            return scopeChain()->globalObject();
+            return Machine::scopeChain(this)->globalObject();
         }
 
         // Differs from lexicalGlobalObject because this will have DOM window shell rather than
-        // the actual DOM window, which can't be "this" for security reasons.
-        JSObject* globalThisValue() const
+        // the actual DOM window.
+        JSObject* globalThisValue()
         {
-            return scopeChain()->globalThisObject();
+            return Machine::scopeChain(this)->globalThisObject();
         }
 
-        // FIXME: Elsewhere, we use JSGlobalData* rather than JSGlobalData&.
-        // We should make this more uniform and either use a reference everywhere
-        // or a pointer everywhere.
-        JSGlobalData& globalData() const
+        JSGlobalData& globalData()
         {
-            return *scopeChain()->globalData;
+            return *Machine::scopeChain(this)->globalData;
         }
 
         // Convenience functions for access to global data.
-        // It takes a few memory references to get from a call frame to the global data
-        // pointer, so these are inefficient, and should be used sparingly in new code.
-        // But they're used in many places in legacy code, so they're not going away any time soon.
 
         void setException(JSValue* exception) { globalData().exception = exception; }
         void clearException() { globalData().exception = 0; }
-        JSValue* exception() const { return globalData().exception; }
+        JSValue* exception() { return globalData().exception; }
         JSValue** exceptionSlot() { return &globalData().exception; }
-        bool hadException() const { return !!globalData().exception; }
+        bool hadException() { return !!globalData().exception; }
 
-        const CommonIdentifiers& propertyNames() const { return *globalData().propertyNames; }
-        const ArgList& emptyList() const { return *globalData().emptyList; }
+        IdentifierTable* identifierTable() { return globalData().identifierTable; }
+        const CommonIdentifiers& propertyNames() { return *globalData().propertyNames; }
+        const ArgList& emptyList() { return *globalData().emptyList; }
+        Lexer* lexer() { return globalData().lexer; }
+        Parser* parser() { return globalData().parser; }
         Machine* machine() { return globalData().machine; }
         Heap* heap() { return &globalData().heap; }
@@ -95 +90 @@
 
     private:
-        friend class Arguments;
-        friend class JSActivation;
-        friend class JSGlobalObject;
-        friend class Machine;
-
-        static CallFrame* create(Register* callFrameBase) { return static_cast<CallFrame*>(callFrameBase); }
-        Register* registers() { return this; }
-
-        CallFrame& operator=(const Register& r) { *static_cast<Register*>(this) = r; return *this; }
-
-        int argumentCount() const { return this[RegisterFile::ArgumentCount].i(); }
-        CallFrame* callerFrame() const { return this[RegisterFile::CallerFrame].callFrame(); }
-        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; }
-
-        ALWAYS_INLINE void init(CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain,
-            CallFrame* callerFrame, int returnValueRegister, int argc, JSFunction* function)
-        {
-            ASSERT(callerFrame); // Use noCaller() rather than 0 for the outer host call frame caller.
-
-            setCodeBlock(codeBlock);
-            setScopeChain(scopeChain);
-            setCallerFrame(callerFrame);
-            this[RegisterFile::ReturnPC] = vPC;
-            this[RegisterFile::ReturnValueRegister] = returnValueRegister;
-            setArgumentCount(argc); // original argument count (for the sake of the "arguments" object)
-            setCallee(function);
-            setCalleeArguments(0);
-        }
-
-        static const intptr_t HostCallFrameFlag = 1;
-
-        static CallFrame* noCaller() { return reinterpret_cast<CallFrame*>(HostCallFrameFlag); }
-        bool hasHostCallFrameFlag() const { return reinterpret_cast<intptr_t>(this) & HostCallFrameFlag; }
-        CallFrame* addHostCallFrameFlag() const { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) | HostCallFrameFlag); }
-        CallFrame* removeHostCallFrameFlag() { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) & ~HostCallFrameFlag); }
-
         ExecState();
         ~ExecState();

trunk/JavaScriptCore/kjs/FunctionConstructor.cpp

@@ -88 +88 @@
     UString errMsg;
     SourceCode source = makeSource(body, sourceURL, lineNumber);
-    RefPtr<FunctionBodyNode> functionBody = exec->globalData().parser->parse<FunctionBodyNode>(exec, source, &errLine, &errMsg);
+    RefPtr<FunctionBodyNode> functionBody = exec->parser()->parse<FunctionBodyNode>(exec, source, &errLine, &errMsg);
 
     // No program node == syntax error - throw a syntax error

trunk/JavaScriptCore/kjs/JSActivation.cpp

@@ -40 +40 @@
 const ClassInfo JSActivation::info = { "JSActivation", 0, 0, 0 };
 
-JSActivation::JSActivation(CallFrame* callFrame, PassRefPtr<FunctionBodyNode> functionBody)
-    : Base(callFrame->globalData().activationStructureID, new JSActivationData(functionBody, callFrame))
+JSActivation::JSActivation(ExecState* exec, PassRefPtr<FunctionBodyNode> functionBody, Register* registers)
+    : Base(exec->globalData().activationStructureID, new JSActivationData(functionBody, registers))
 {
 }
@@ -154 +154 @@
 JSValue* JSActivation::argumentsGetter(ExecState* exec, const Identifier&, const PropertySlot& slot)
 {
-    JSActivation* activation = static_cast<JSActivation*>(slot.slotBase());
+    JSActivation* thisObj = static_cast<JSActivation*>(slot.slotBase());
 
-    if (activation->d()->functionBody->usesArguments()) {
+    if (thisObj->d()->functionBody->usesArguments()) {
         PropertySlot slot;
-        activation->symbolTableGet(exec->propertyNames().arguments, slot);
+        thisObj->symbolTableGet(exec->propertyNames().arguments, slot);
         return slot.getValue(exec, exec->propertyNames().arguments);
     }
 
-    CallFrame* callFrame = CallFrame::create(activation->d()->registers);
-    Arguments* arguments = callFrame->optionalCalleeArguments();
+    Arguments* arguments = static_cast<Arguments*>(thisObj->d()->registers[RegisterFile::OptionalCalleeArguments].getJSValue());
     if (!arguments) {
-        arguments = new (exec) Arguments(exec);
+        arguments = new (exec) Arguments(exec, &thisObj->registerAt(0));
         arguments->copyRegisters();
-        callFrame->setCalleeArguments(arguments);
+        thisObj->d()->registers[RegisterFile::OptionalCalleeArguments] = arguments;
     }
     ASSERT(arguments->isObject(&Arguments::info));

trunk/JavaScriptCore/kjs/JSActivation.h

@@ -44 +44 @@
         typedef JSVariableObject Base;
     public:
-        JSActivation(CallFrame*, PassRefPtr<FunctionBodyNode>);
+        JSActivation(ExecState*, PassRefPtr<FunctionBodyNode>, Register*);
         virtual ~JSActivation();
 

trunk/JavaScriptCore/kjs/JSGlobalObject.cpp

@@ -130 +130 @@
     d()->globalScopeChain = ScopeChain(this, d()->globalData.get(), thisValue);
 
-    JSGlobalObject::globalExec()->init(0, 0, d()->globalScopeChain.node(), CallFrame::noCaller(), 0, 0, 0);
+    Machine::initializeCallFrame(d()->globalCallFrame + RegisterFile::CallFrameHeaderSize, 0, 0, d()->globalScopeChain.node(), makeHostCallFramePointer(0), 0, 0, 0);
 
     if (JSGlobalObject*& headObject = head()) {

trunk/JavaScriptCore/kjs/JSGlobalObjectFunctions.cpp

@@ -287 +287 @@
 
     SourceCode source = makeSource(s);
-    RefPtr<EvalNode> evalNode = exec->globalData().parser->parse<EvalNode>(exec, source, &errLine, &errMsg);
+    RefPtr<EvalNode> evalNode = exec->parser()->parse<EvalNode>(exec, source, &errLine, &errMsg);
 
     if (!evalNode)

trunk/JavaScriptCore/kjs/JSVariableObject.h

@@ -62 +62 @@
         // size of a JSCell).
         struct JSVariableObjectData {
-            JSVariableObjectData(SymbolTable* symbolTable, Register* registers)
-                : symbolTable(symbolTable)
-                , registers(registers)
+            JSVariableObjectData(SymbolTable* symbolTable_, Register* registers_)
+                : symbolTable(symbolTable_)
+                , registers(registers_)
             {
-                ASSERT(symbolTable);
+                ASSERT(symbolTable_);
             }
 

trunk/JavaScriptCore/kjs/Parser.cpp

@@ -48 +48 @@
     *errMsg = 0;
 
-    Lexer& lexer = *exec->globalData().lexer;
+    Lexer& lexer = *exec->lexer();
     lexer.setCode(*m_source);
 

trunk/JavaScriptCore/kjs/RegExpConstructor.cpp

@@ -332 +332 @@
     UString flags = arg1->isUndefined() ? UString("") : arg1->toString(exec);
 
-    RefPtr<RegExp> regExp = RegExp::create(&exec->globalData(), pattern, flags);
+    RefPtr<RegExp> regExp = RegExp::create(exec, pattern, flags);
     if (!regExp->isValid())
         return throwError(exec, SyntaxError, UString("Invalid regular expression: ").append(regExp->errorMessage()));

trunk/JavaScriptCore/kjs/RegExpPrototype.cpp

@@ -86 +86 @@
         UString pattern = args.isEmpty() ? UString("") : arg0->toString(exec);
         UString flags = arg1->isUndefined() ? UString("") : arg1->toString(exec);
-        regExp = RegExp::create(&exec->globalData(), pattern, flags);
+        regExp = RegExp::create(exec, pattern, flags);
     }
 

trunk/JavaScriptCore/kjs/Shell.cpp

@@ -306 +306 @@
     int errLine = 0;
     UString errMsg;
-    RefPtr<ProgramNode> programNode = exec->globalData().parser->parse<ProgramNode>(exec, makeSource(script.data(), fileName), &errLine, &errMsg);
+    RefPtr<ProgramNode> programNode = exec->parser()->parse<ProgramNode>(exec, makeSource(script.data(), fileName), &errLine, &errMsg);
     if (!programNode) {
         fprintf(stderr, "%s:%d: %s.\n", fileName.UTF8String().c_str(), errLine, errMsg.UTF8String().c_str());

trunk/JavaScriptCore/kjs/StringPrototype.cpp

@@ -413 +413 @@
          *  replaced with the result of the expression new RegExp(regexp).
          */
-        reg = RegExp::create(&exec->globalData(), a0->toString(exec));
+        reg = RegExp::create(exec, a0->toString(exec));
     }
     RegExpConstructor* regExpObj = exec->lexicalGlobalObject()->regExpConstructor();
@@ -463 +463 @@
          *  replaced with the result of the expression new RegExp(regexp).
          */
-        reg = RegExp::create(&exec->globalData(), a0->toString(exec));
+        reg = RegExp::create(exec, a0->toString(exec));
     }
     RegExpConstructor* regExpObj = exec->lexicalGlobalObject()->regExpConstructor();

trunk/JavaScriptCore/kjs/identifier.cpp

@@ -241 +241 @@
 void Identifier::checkSameIdentifierTable(ExecState* exec, UString::Rep* rep)
 {
-    ASSERT(rep->identifierTable() == exec->globalData().identifierTable);
+    ASSERT(rep->identifierTable() == exec->identifierTable());
 }
 

trunk/JavaScriptCore/kjs/interpreter.cpp

@@ -47 +47 @@
     UString errMsg;
 
-    RefPtr<ProgramNode> progNode = exec->globalData().parser->parse<ProgramNode>(exec, source, &errLine, &errMsg);
+    RefPtr<ProgramNode> progNode = exec->parser()->parse<ProgramNode>(exec, source, &errLine, &errMsg);
     if (!progNode)
         return Completion(Throw, Error::create(exec, SyntaxError, errMsg, errLine, source.provider()->asID(), source.provider()->url()));
@@ -59 +59 @@
     int errLine;
     UString errMsg;
-    RefPtr<ProgramNode> programNode = exec->globalData().parser->parse<ProgramNode>(exec, source, &errLine, &errMsg);
+    RefPtr<ProgramNode> programNode = exec->parser()->parse<ProgramNode>(exec, source, &errLine, &errMsg);
 
     if (!programNode)

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -160 +160 @@
 {
     generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
-    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalData(), msg));
+    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalExec(), msg));
     generator.emitThrow(exception);
     return exception;
@@ -170 +170 @@
     substitute(message, label.ustring());
     generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
-    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalData(), message));
+    RegisterID* exception = generator.emitNewError(generator.newTemporary(), e, jsString(generator.globalExec(), message));
     generator.emitThrow(exception);
     return exception;
@@ -239 +239 @@
 RegisterID* RegExpNode::emitCode(CodeGenerator& generator, RegisterID* dst)
 {
-    RefPtr<RegExp> regExp = RegExp::create(generator.globalData(), m_pattern, m_flags);
+    RefPtr<RegExp> regExp = RegExp::create(generator.globalExec(), m_pattern, m_flags);
     if (!regExp->isValid())
         return emitThrowError(generator, SyntaxError, ("Invalid regular expression: " + UString(regExp->errorMessage())).UTF8String().c_str());
@@ -301 +301 @@
 
     if (m_elision) {
-        RegisterID* value = generator.emitLoad(0, jsNumber(generator.globalData(), m_elision + length));
+        RegisterID* value = generator.emitLoad(0, jsNumber(generator.globalExec(), m_elision + length));
         generator.emitPutById(array.get(), generator.propertyNames().length, value);
     }
@@ -776 +776 @@
 
     generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);
-    RegisterID* src2Prototype = generator.emitGetById(generator.newTemporary(), src2.get(), generator.globalData()->propertyNames->prototype);
+    RegisterID* src2Prototype = generator.emitGetById(generator.newTemporary(), src2.get(), generator.globalExec()->propertyNames().prototype);
 
     generator.emitExpressionInfo(m_divot, m_startOffset, m_endOffset);

trunk/JavaScriptCore/kjs/nodes.h

@@ -117 +117 @@
     };
 
-    namespace DeclarationStacks {
+    struct DeclarationStacks {
         typedef Vector<Node*, 16> NodeStack;
-        enum VarAttrs { IsConstant = 1, HasInitializer = 2 };
+        enum { IsConstant = 1, HasInitializer = 2 } VarAttrs;
         typedef Vector<std::pair<Identifier, unsigned>, 16> VarStack;
         typedef Vector<RefPtr<FuncDeclNode>, 16> FunctionStack;
-    }
+
+        DeclarationStacks(ExecState* e, NodeStack& n, VarStack& v, FunctionStack& f)
+            : exec(e)
+            , nodeStack(n)
+            , varStack(v)
+            , functionStack(f)
+        {
+        }
+
+        ExecState* exec;
+        NodeStack& nodeStack;
+        VarStack& varStack;
+        FunctionStack& functionStack;
+    };
 
     struct SwitchInfo {

trunk/JavaScriptCore/kjs/regexp.cpp

@@ -33 +33 @@
 namespace JSC {
 
-inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern)
+
+
+inline RegExp::RegExp(ExecState* exec, const UString& pattern)
     : m_pattern(pattern)
     , m_flagBits(0)
@@ -41 +43 @@
 {
 #if ENABLE(WREC)
-    m_wrecFunction = reinterpret_cast<WRECFunction>(CTI::compileRegExp(globalData->machine, pattern, &m_numSubpatterns, &m_constructionError));
-    if (m_wrecFunction)
-        return;
-    // Fall through to non-WREC case.
+    if (!(m_wrecFunction = (WRECFunction)CTI::compileRegExp(exec, pattern, &m_numSubpatterns, &m_constructionError)))
 #else
-    UNUSED_PARAM(globalData);
+    UNUSED_PARAM(exec);
 #endif
-    m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
-        JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, &m_numSubpatterns, &m_constructionError);
+    {
+        m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
+            JSRegExpDoNotIgnoreCase, JSRegExpSingleLine, &m_numSubpatterns, &m_constructionError);
+    }
 }
 
-PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& pattern)
+PassRefPtr<RegExp> RegExp::create(ExecState* exec, const UString& pattern)
 {
-    return adoptRef(new RegExp(globalData, pattern));
+    return adoptRef(new RegExp(exec, pattern));
 }
 
-inline RegExp::RegExp(JSGlobalData* globalData, const UString& pattern, const UString& flags)
+inline RegExp::RegExp(ExecState* exec, const UString& pattern, const UString& flags)
     : m_pattern(pattern)
     , m_flags(flags)
@@ -84 +85 @@
 
 #if ENABLE(WREC)
-    m_wrecFunction = reinterpret_cast<WRECFunction>(CTI::compileRegExp(globalData->machine, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline)));
-    if (m_wrecFunction)
-        return;
-    // Fall through to non-WREC case.
+    if (!(m_wrecFunction = (WRECFunction)CTI::compileRegExp(exec, pattern, &m_numSubpatterns, &m_constructionError, (m_flagBits & IgnoreCase), (m_flagBits & Multiline))))
 #else
-    UNUSED_PARAM(globalData);
+    UNUSED_PARAM(exec);
 #endif
-    m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
-        ignoreCaseOption, multilineOption, &m_numSubpatterns, &m_constructionError);
+    {
+        m_regExp = jsRegExpCompile(reinterpret_cast<const UChar*>(pattern.data()), pattern.size(),
+            ignoreCaseOption, multilineOption, &m_numSubpatterns, &m_constructionError);
+    }
 }
 
-PassRefPtr<RegExp> RegExp::create(JSGlobalData* globalData, const UString& pattern, const UString& flags)
+PassRefPtr<RegExp> RegExp::create(ExecState* exec, const UString& pattern, const UString& flags)
 {
-    return adoptRef(new RegExp(globalData, pattern, flags));
+    return adoptRef(new RegExp(exec, pattern, flags));
 }
 

trunk/JavaScriptCore/kjs/regexp.h

@@ -23 +23 @@
 
 #include "ustring.h"
+#include "ExecState.h"
 #include <wtf/Forward.h>
 #include <wtf/RefCounted.h>
@@ -31 +32 @@
 namespace JSC {
 
-    class JSGlobalData;
-
     class RegExp : public RefCounted<RegExp> {
     public:
-        static PassRefPtr<RegExp> create(JSGlobalData*, const UString& pattern);
-        static PassRefPtr<RegExp> create(JSGlobalData*, const UString& pattern, const UString& flags);
+        static PassRefPtr<RegExp> create(ExecState*, const UString& pattern);
+        static PassRefPtr<RegExp> create(ExecState*, const UString& pattern, const UString& flags);
         ~RegExp();
 
@@ -53 +52 @@
 
     private:
-        RegExp(JSGlobalData*, const UString& pattern);
-        RegExp(JSGlobalData*, const UString& pattern, const UString& flags);
+        RegExp(ExecState*, const UString& pattern);
+        RegExp(ExecState*, const UString& pattern, const UString& flags);
 
         void compile();

trunk/JavaScriptCore/profiler/HeavyProfile.h

@@ -33 +33 @@
 namespace JSC {
 
+    class ExecState;
     class UString;
 

trunk/JavaScriptCore/profiler/Profile.h

@@ -33 +33 @@
 
 namespace JSC {
+
+    class ExecState;
 
     class Profile : public RefCounted<Profile> {

trunk/JavaScriptCore/wrec/WREC.cpp

@@ -30 +30 @@
 
 #include "CharacterClassConstructor.h"
+#include "ExecState.h"
 #include "Machine.h"
 #include "pcre_internal.h"

trunk/JavaScriptCore/wrec/WREC.h

@@ -44 +44 @@
     typedef int (*WRECFunction)(const UChar* input, unsigned start, unsigned length, int* output) WREC_CALL;
 
+    class ExecState;
     class GenerateAtomFunctor;
     struct CharacterClassRange;

trunk/WebKit/mac/ChangeLog

@@ +1 @@
+2008-10-08  Timothy Hatcher  <timothy@apple.com>
+
+        Roll out r37427 because it causes an infinite recursion loading about:blank.
+
+        https://bugs.webkit.org/show_bug.cgi?id=21476
+
 2008-10-08  Darin Adler  <darin@apple.com>
 

trunk/WebKit/mac/WebView/WebScriptDebugger.mm

@@ -81 +81 @@
 {
     attach(globalObject);
-    DebuggerCallFrame globalCallFrame(globalObject->globalExec(), 0);
+    DebuggerCallFrame globalCallFrame(globalObject, 0, globalObject->globalScopeChain().node(), 0, 0);
     callEvent(globalCallFrame, 0, -1);
 }