Changeset 37428 in webkit for trunk/JavaScriptCore/VM/Machine.cpp

Timestamp:

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

Author:

[email protected]

Message:

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

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

File:

• trunk/JavaScriptCore/VM/Machine.cpp (modified) (315 diffs)

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);