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

Timestamp:

Oct 8, 2008, 5:40:43 PM (17 years ago)

Author:

Darin Adler

Message:

JavaScriptCore:

2008-10-08 Darin Adler <Darin Adler>

Reviewed by Cameron Zwarich.

• ​https://bugs.webkit.org/show_bug.cgi?id=21403 Bug 21403: use new CallFrame class rather than Register* for call frame manipulation

Add CallFrame as a synonym for ExecState. Arguably, some day we should switch every
client over to the new name.

Use CallFrame* consistently rather than Register* or ExecState* in low-level code such
as Machine.cpp and CTI.cpp. Similarly, use callFrame rather than r as its name and use
accessor functions to get at things in the frame.

Eliminate other uses of ExecState* that aren't needed, replacing in some cases with
JSGlobalData* and in other cases eliminating them entirely.

• API/JSObjectRef.cpp: (JSObjectMakeFunctionWithCallback): (JSObjectMakeFunction): (JSObjectHasProperty): (JSObjectGetProperty): (JSObjectSetProperty): (JSObjectDeleteProperty):
• API/OpaqueJSString.cpp:
• API/OpaqueJSString.h:
• VM/CTI.cpp: (JSC::CTI::getConstant): (JSC::CTI::emitGetArg): (JSC::CTI::emitGetPutArg): (JSC::CTI::getConstantImmediateNumericArg): (JSC::CTI::printOpcodeOperandTypes): (JSC::CTI::CTI): (JSC::CTI::compileOpCall): (JSC::CTI::compileBinaryArithOp): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompile): (JSC::CTI::privateCompileGetByIdProto): (JSC::CTI::privateCompileGetByIdChain): (JSC::CTI::compileRegExp):
• VM/CTI.h:
• VM/CodeBlock.h:
• VM/CodeGenerator.cpp: (JSC::CodeGenerator::emitEqualityOp): (JSC::CodeGenerator::emitLoad): (JSC::CodeGenerator::emitUnexpectedLoad): (JSC::CodeGenerator::emitConstruct):
• VM/CodeGenerator.h:
• VM/Machine.cpp: (JSC::jsLess): (JSC::jsLessEq): (JSC::jsAddSlowCase): (JSC::jsAdd): (JSC::jsTypeStringForValue): (JSC::Machine::resolve): (JSC::Machine::resolveSkip): (JSC::Machine::resolveGlobal): (JSC::inlineResolveBase): (JSC::Machine::resolveBase): (JSC::Machine::resolveBaseAndProperty): (JSC::Machine::resolveBaseAndFunc): (JSC::Machine::slideRegisterWindowForCall): (JSC::isNotObject): (JSC::Machine::callEval): (JSC::Machine::dumpCallFrame): (JSC::Machine::dumpRegisters): (JSC::Machine::unwindCallFrame): (JSC::Machine::throwException): (JSC::DynamicGlobalObjectScope::DynamicGlobalObjectScope): (JSC::DynamicGlobalObjectScope::~DynamicGlobalObjectScope): (JSC::Machine::execute): (JSC::Machine::debug): (JSC::Machine::createExceptionScope): (JSC::cachePrototypeChain): (JSC::Machine::tryCachePutByID): (JSC::Machine::tryCacheGetByID): (JSC::Machine::privateExecute): (JSC::Machine::retrieveArguments): (JSC::Machine::retrieveCaller): (JSC::Machine::retrieveLastCaller): (JSC::Machine::findFunctionCallFrame): (JSC::Machine::getArgumentsData): (JSC::Machine::tryCTICachePutByID): (JSC::Machine::getCTIArrayLengthTrampoline): (JSC::Machine::getCTIStringLengthTrampoline): (JSC::Machine::tryCTICacheGetByID): (JSC::Machine::cti_op_convert_this): (JSC::Machine::cti_op_end): (JSC::Machine::cti_op_add): (JSC::Machine::cti_op_pre_inc): (JSC::Machine::cti_timeout_check): (JSC::Machine::cti_op_loop_if_less): (JSC::Machine::cti_op_loop_if_lesseq): (JSC::Machine::cti_op_new_object): (JSC::Machine::cti_op_put_by_id): (JSC::Machine::cti_op_put_by_id_second): (JSC::Machine::cti_op_put_by_id_generic): (JSC::Machine::cti_op_put_by_id_fail): (JSC::Machine::cti_op_get_by_id): (JSC::Machine::cti_op_get_by_id_second): (JSC::Machine::cti_op_get_by_id_generic): (JSC::Machine::cti_op_get_by_id_fail): (JSC::Machine::cti_op_instanceof): (JSC::Machine::cti_op_del_by_id): (JSC::Machine::cti_op_mul): (JSC::Machine::cti_op_new_func): (JSC::Machine::cti_op_call_JSFunction): (JSC::Machine::cti_vm_compile): (JSC::Machine::cti_op_push_activation): (JSC::Machine::cti_op_call_NotJSFunction): (JSC::Machine::cti_op_create_arguments): (JSC::Machine::cti_op_tear_off_activation): (JSC::Machine::cti_op_tear_off_arguments): (JSC::Machine::cti_op_ret_profiler): (JSC::Machine::cti_op_ret_scopeChain): (JSC::Machine::cti_op_new_array): (JSC::Machine::cti_op_resolve): (JSC::Machine::cti_op_construct_JSConstruct): (JSC::Machine::cti_op_construct_NotJSConstruct): (JSC::Machine::cti_op_get_by_val): (JSC::Machine::cti_op_resolve_func): (JSC::Machine::cti_op_sub): (JSC::Machine::cti_op_put_by_val): (JSC::Machine::cti_op_put_by_val_array): (JSC::Machine::cti_op_lesseq): (JSC::Machine::cti_op_loop_if_true): (JSC::Machine::cti_op_negate): (JSC::Machine::cti_op_resolve_base): (JSC::Machine::cti_op_resolve_skip): (JSC::Machine::cti_op_resolve_global): (JSC::Machine::cti_op_div): (JSC::Machine::cti_op_pre_dec): (JSC::Machine::cti_op_jless): (JSC::Machine::cti_op_not): (JSC::Machine::cti_op_jtrue): (JSC::Machine::cti_op_post_inc): (JSC::Machine::cti_op_eq): (JSC::Machine::cti_op_lshift): (JSC::Machine::cti_op_bitand): (JSC::Machine::cti_op_rshift): (JSC::Machine::cti_op_bitnot): (JSC::Machine::cti_op_resolve_with_base): (JSC::Machine::cti_op_new_func_exp): (JSC::Machine::cti_op_mod): (JSC::Machine::cti_op_less): (JSC::Machine::cti_op_neq): (JSC::Machine::cti_op_post_dec): (JSC::Machine::cti_op_urshift): (JSC::Machine::cti_op_bitxor): (JSC::Machine::cti_op_new_regexp): (JSC::Machine::cti_op_bitor): (JSC::Machine::cti_op_call_eval): (JSC::Machine::cti_op_throw): (JSC::Machine::cti_op_get_pnames): (JSC::Machine::cti_op_next_pname): (JSC::Machine::cti_op_push_scope): (JSC::Machine::cti_op_pop_scope): (JSC::Machine::cti_op_typeof): (JSC::Machine::cti_op_to_jsnumber): (JSC::Machine::cti_op_in): (JSC::Machine::cti_op_push_new_scope): (JSC::Machine::cti_op_jmp_scopes): (JSC::Machine::cti_op_put_by_index): (JSC::Machine::cti_op_switch_imm): (JSC::Machine::cti_op_switch_char): (JSC::Machine::cti_op_switch_string): (JSC::Machine::cti_op_del_by_val): (JSC::Machine::cti_op_put_getter): (JSC::Machine::cti_op_put_setter): (JSC::Machine::cti_op_new_error): (JSC::Machine::cti_op_debug): (JSC::Machine::cti_vm_throw):
• VM/Machine.h:
• VM/Register.h:
• VM/RegisterFile.h:
• kjs/Arguments.h:
• kjs/DebuggerCallFrame.cpp: (JSC::DebuggerCallFrame::functionName): (JSC::DebuggerCallFrame::type): (JSC::DebuggerCallFrame::thisObject): (JSC::DebuggerCallFrame::evaluate):
• kjs/DebuggerCallFrame.h:
• kjs/ExecState.cpp: (JSC::CallFrame::thisValue):
• kjs/ExecState.h:
• kjs/FunctionConstructor.cpp: (JSC::constructFunction):
• kjs/JSActivation.cpp: (JSC::JSActivation::JSActivation): (JSC::JSActivation::argumentsGetter):
• kjs/JSActivation.h:
• kjs/JSGlobalObject.cpp: (JSC::JSGlobalObject::init):
• kjs/JSGlobalObjectFunctions.cpp: (JSC::globalFuncEval):
• kjs/JSVariableObject.h:
• kjs/Parser.cpp: (JSC::Parser::parse):
• kjs/RegExpConstructor.cpp: (JSC::constructRegExp):
• kjs/RegExpPrototype.cpp: (JSC::regExpProtoFuncCompile):
• kjs/Shell.cpp: (prettyPrintScript):
• kjs/StringPrototype.cpp: (JSC::stringProtoFuncMatch): (JSC::stringProtoFuncSearch):
• kjs/identifier.cpp: (JSC::Identifier::checkSameIdentifierTable):
• kjs/interpreter.cpp: (JSC::Interpreter::checkSyntax): (JSC::Interpreter::evaluate):
• kjs/nodes.cpp: (JSC::ThrowableExpressionData::emitThrowError): (JSC::RegExpNode::emitCode): (JSC::ArrayNode::emitCode): (JSC::InstanceOfNode::emitCode):
• kjs/nodes.h:
• kjs/regexp.cpp: (JSC::RegExp::RegExp): (JSC::RegExp::create):
• kjs/regexp.h:
• profiler/HeavyProfile.h:
• profiler/Profile.h:
• wrec/WREC.cpp:
• wrec/WREC.h:

WebKit/mac:

2008-10-08 Darin Adler <Darin Adler>

Reviewed by Cameron Zwarich.

• ​https://bugs.webkit.org/show_bug.cgi?id=21403 Bug 21403: use new CallFrame class rather than Register* for call frame manipulation

• WebView/WebScriptDebugger.mm: (WebScriptDebugger::WebScriptDebugger): Update since DebuggerCallFrame is simpler now.

File:

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

trunk/JavaScriptCore/VM/Machine.cpp

@@ -163 +163 @@
 }
 
-static inline bool jsLess(ExecState* exec, JSValue* v1, JSValue* v2)
+static inline bool jsLess(CallFrame* callFrame, JSValue* v1, JSValue* v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
@@ -173 +173 @@
         return n1 < n2;
 
-    Machine* machine = exec->machine();
+    Machine* machine = callFrame->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(exec, n1, p1);
-    bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
+    bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
+    bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
 
     if (wasNotString1 | wasNotString2)
@@ -188 +188 @@
 }
 
-static inline bool jsLessEq(ExecState* exec, JSValue* v1, JSValue* v2)
+static inline bool jsLessEq(CallFrame* callFrame, JSValue* v1, JSValue* v2)
 {
     if (JSImmediate::areBothImmediateNumbers(v1, v2))
@@ -198 +198 @@
         return n1 <= n2;
 
-    Machine* machine = exec->machine();
+    Machine* machine = callFrame->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(exec, n1, p1);
-    bool wasNotString2 = v2->getPrimitiveNumber(exec, n2, p2);
+    bool wasNotString1 = v1->getPrimitiveNumber(callFrame, n1, p1);
+    bool wasNotString2 = v2->getPrimitiveNumber(callFrame, n2, p2);
 
     if (wasNotString1 | wasNotString2)
@@ -213 +213 @@
 }
 
-static NEVER_INLINE JSValue* jsAddSlowCase(ExecState* exec, JSValue* v1, JSValue* v2)
+static NEVER_INLINE JSValue* jsAddSlowCase(CallFrame* callFrame, JSValue* v1, JSValue* v2)
 {
     // exception for the Date exception in defaultValue()
-    JSValue* p1 = v1->toPrimitive(exec);
-    JSValue* p2 = v2->toPrimitive(exec);
+    JSValue* p1 = v1->toPrimitive(callFrame);
+    JSValue* p2 = v2->toPrimitive(callFrame);
 
     if (p1->isString() || p2->isString()) {
-        RefPtr<UString::Rep> value = concatenate(p1->toString(exec).rep(), p2->toString(exec).rep());
+        RefPtr<UString::Rep> value = concatenate(p1->toString(callFrame).rep(), p2->toString(callFrame).rep());
         if (!value)
-            return throwOutOfMemoryError(exec);
-        return jsString(exec, value.release());
-    }
-
-    return jsNumber(exec, p1->toNumber(exec) + p2->toNumber(exec));
+            return throwOutOfMemoryError(callFrame);
+        return jsString(callFrame, value.release());
+    }
+
+    return jsNumber(callFrame, p1->toNumber(callFrame) + p2->toNumber(callFrame));
 }
 
@@ -238 +238 @@
 //    4000    Add case: 3 5
 
-static ALWAYS_INLINE JSValue* jsAdd(ExecState* exec, JSValue* v1, JSValue* v2)
+static ALWAYS_INLINE JSValue* jsAdd(CallFrame* callFrame, JSValue* v1, JSValue* v2)
 {
     double left;
@@ -245 +245 @@
     bool rightIsNumber = fastIsNumber(v2, right);
     if (rightIsNumber && fastIsNumber(v1, left))
-        return jsNumber(exec, left + right);
+        return jsNumber(callFrame, 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(exec);
-        return jsString(exec, value.release());
+            return throwOutOfMemoryError(callFrame);
+        return jsString(callFrame, value.release());
     }
 
@@ -261 +261 @@
 
         if (!value)
-            return throwOutOfMemoryError(exec);
-        return jsString(exec, value.release());
+            return throwOutOfMemoryError(callFrame);
+        return jsString(callFrame, value.release());
     }
 
     // All other cases are pretty uncommon
-    return jsAddSlowCase(exec, v1, v2);
-}
-
-static JSValue* jsTypeStringForValue(ExecState* exec, JSValue* v)
+    return jsAddSlowCase(callFrame, v1, v2);
+}
+
+static JSValue* jsTypeStringForValue(CallFrame* callFrame, JSValue* v)
 {
     if (v->isUndefined())
-        return jsNontrivialString(exec, "undefined");
+        return jsNontrivialString(callFrame, "undefined");
     if (v->isBoolean())
-        return jsNontrivialString(exec, "boolean");
+        return jsNontrivialString(callFrame, "boolean");
     if (v->isNumber())
-        return jsNontrivialString(exec, "number");
+        return jsNontrivialString(callFrame, "number");
     if (v->isString())
-        return jsNontrivialString(exec, "string");
+        return jsNontrivialString(callFrame, "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(exec, "undefined");
+            return jsNontrivialString(callFrame, "undefined");
         CallData callData;
         if (static_cast<JSObject*>(v)->getCallData(callData) != CallTypeNone)
-            return jsNontrivialString(exec, "function");
-    }
-    return jsNontrivialString(exec, "object");
+            return jsNontrivialString(callFrame, "function");
+    }
+    return jsNontrivialString(callFrame, "object");
 }
 
@@ -319 +319 @@
 }
 
-NEVER_INLINE bool Machine::resolve(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolve(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
 
-    ScopeChainNode* scopeChain = this->scopeChain(r);
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& ident = codeBlock->identifiers[property];
     do {
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
-            exceptionValue = exec->exception();
+        if (o->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
+            exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            r[dst] = result;
+            callFrame[dst] = result;
             return true;
         }
     } while (++iter != end);
-    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveSkip(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
-{
-    CodeBlock* codeBlock = this->codeBlock(r);
+NEVER_INLINE bool Machine::resolveSkip(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
+{
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     int dst = (vPC + 1)->u.operand;
@@ -355 +355 @@
     int skip = (vPC + 3)->u.operand + codeBlock->needsFullScopeChain;
 
-    ScopeChainNode* scopeChain = this->scopeChain(r);
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -367 +367 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
-            exceptionValue = exec->exception();
+        if (o->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
+            exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            r[dst] = result;
+            callFrame[dst] = result;
             return true;
         }
     } while (++iter != end);
-    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveGlobal(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolveGlobal(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int dst = (vPC + 1)->u.operand;
@@ -390 +390 @@
 
     if (structureID == globalObject->structureID()) {
-        r[dst] = globalObject->getDirectOffset(offset);
+        callFrame[dst] = globalObject->getDirectOffset(offset);
         return true;
     }
 
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& ident = codeBlock->identifiers[property];
     PropertySlot slot(globalObject);
-    if (globalObject->getPropertySlot(exec, ident, slot)) {
-        JSValue* result = slot.getValue(exec, ident);
+    if (globalObject->getPropertySlot(callFrame, ident, slot)) {
+        JSValue* result = slot.getValue(callFrame, ident);
         if (slot.isCacheable()) {
             if (vPC[4].u.structureID)
@@ -405 +405 @@
             vPC[4] = globalObject->structureID();
             vPC[5] = slot.cachedOffset();
-            r[dst] = result;
+            callFrame[dst] = result;
             return true;
         }
 
-        exceptionValue = exec->exception();
+        exceptionValue = callFrame->globalData().exception;
         if (exceptionValue)
             return false;
-        r[dst] = result;
+        callFrame[dst] = result;
         return true;
     }
 
-    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
     return false;
 }
 
-ALWAYS_INLINE static JSValue* inlineResolveBase(ExecState* exec, Identifier& property, ScopeChainNode* scopeChain)
+ALWAYS_INLINE static JSValue* inlineResolveBase(CallFrame* callFrame, Identifier& property, ScopeChainNode* scopeChain)
 {
     ScopeChainIterator iter = scopeChain->begin();
@@ -432 +432 @@
     while (true) {
         base = *iter;
-        if (next == end || base->getPropertySlot(exec, property, slot))
+        if (next == end || base->getPropertySlot(callFrame, property, slot))
             return base;
 
@@ -443 +443 @@
 }
 
-NEVER_INLINE void Machine::resolveBase(ExecState* exec, Instruction* vPC, Register* r)
+NEVER_INLINE void Machine::resolveBase(CallFrame* callFrame, Instruction* vPC)
 {
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
-    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)
+    callFrame[dst] = inlineResolveBase(callFrame, callFrame->codeBlock()->identifiers[property], callFrame->scopeChain());
+}
+
+NEVER_INLINE bool Machine::resolveBaseAndProperty(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
@@ -458 +456 @@
     int property = (vPC + 3)->u.operand;
 
-    ScopeChainNode* scopeChain = this->scopeChain(r);
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -466 +464 @@
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& ident = codeBlock->identifiers[property];
     JSObject* base;
@@ -472 +470 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
-            exceptionValue = exec->exception();
+        if (base->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
+            exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
-            r[propDst] = result;
-            r[baseDst] = base;
+            callFrame[propDst] = result;
+            callFrame[baseDst] = base;
             return true;
         }
@@ -484 +482 @@
     } while (iter != end);
 
-    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
     return false;
 }
 
-NEVER_INLINE bool Machine::resolveBaseAndFunc(ExecState* exec, Instruction* vPC, Register* r, JSValue*& exceptionValue)
+NEVER_INLINE bool Machine::resolveBaseAndFunc(CallFrame* callFrame, Instruction* vPC, JSValue*& exceptionValue)
 {
     int baseDst = (vPC + 1)->u.operand;
@@ -494 +492 @@
     int property = (vPC + 3)->u.operand;
 
-    ScopeChainNode* scopeChain = this->scopeChain(r);
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
     ScopeChainIterator iter = scopeChain->begin();
     ScopeChainIterator end = scopeChain->end();
@@ -502 +500 @@
     ASSERT(iter != end);
 
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& ident = codeBlock->identifiers[property];
     JSObject* base;
@@ -508 +506 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(exec, ident, slot)) {            
+        if (base->getPropertySlot(callFrame, 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
@@ -516 +514 @@
             // 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(exec);
-            JSValue* result = slot.getValue(exec, ident);
-            exceptionValue = exec->exception();
+            JSObject* thisObj = base->toThisObject(callFrame);
+            JSValue* result = slot.getValue(callFrame, ident);
+            exceptionValue = callFrame->globalData().exception;
             if (exceptionValue)
                 return false;
 
-            r[baseDst] = thisObj;
-            r[funcDst] = result;
+            callFrame[baseDst] = thisObj;
+            callFrame[funcDst] = result;
             return true;
         }
@@ -529 +527 @@
     } while (iter != end);
 
-    exceptionValue = createUndefinedVariableError(exec, ident, vPC, codeBlock);
+    exceptionValue = createUndefinedVariableError(callFrame, ident, vPC, codeBlock);
     return false;
 }
 
-ALWAYS_INLINE Register* slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, Register* r, size_t registerOffset, int argc)
-{
+ALWAYS_INLINE CallFrame* Machine::slideRegisterWindowForCall(CodeBlock* newCodeBlock, RegisterFile* registerFile, CallFrame* callFrame, size_t registerOffset, int argc)
+{
+    Register* r = callFrame->registers();
     Register* newEnd = r + registerOffset + newCodeBlock->numCalleeRegisters;
 
@@ -566 +565 @@
     }
 
-    return r;
-}
-
-static NEVER_INLINE bool isNotObject(ExecState* exec, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
+    return CallFrame::create(r);
+}
+
+static NEVER_INLINE bool isNotObject(CallFrame* callFrame, bool forInstanceOf, CodeBlock* codeBlock, const Instruction* vPC, JSValue* value, JSValue*& exceptionData)
 {
     if (value->isObject())
         return false;
-    exceptionData = createInvalidParamError(exec, forInstanceOf ? "instanceof" : "in" , value, vPC, codeBlock);
+    exceptionData = createInvalidParamError(callFrame, forInstanceOf ? "instanceof" : "in" , value, vPC, codeBlock);
     return true;
 }
 
-NEVER_INLINE JSValue* Machine::callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, Register* r, int argv, int argc, JSValue*& exceptionValue)
+NEVER_INLINE JSValue* Machine::callEval(CallFrame* callFrame, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, int argv, int argc, JSValue*& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
 
-    JSValue* program = r[argv + 1].jsValue(exec);
+    JSValue* program = callFrame[argv + 1].jsValue(callFrame);
 
     if (!program->isString())
@@ -589 +588 @@
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(exec, scopeChain->globalObject()->evalFunction());
+        (*profiler)->willExecute(callFrame, scopeChain->globalObject()->evalFunction());
 
     UString programSource = static_cast<JSString*>(program)->value();
 
-    CodeBlock* codeBlock = this->codeBlock(r);
-    RefPtr<EvalNode> evalNode = codeBlock->evalCodeCache.get(exec, programSource, scopeChain, exceptionValue);
+    CodeBlock* codeBlock = callFrame->codeBlock();
+    RefPtr<EvalNode> evalNode = codeBlock->evalCodeCache.get(callFrame, programSource, scopeChain, exceptionValue);
 
     JSValue* result = 0;
     if (evalNode)
-        result = exec->globalData().machine->execute(evalNode.get(), exec, thisObj, r - registerFile->start() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
+        result = callFrame->globalData().machine->execute(evalNode.get(), callFrame, thisObj, callFrame->registers() - registerFile->start() + argv + 1 + RegisterFile::CallFrameHeaderSize, scopeChain, &exceptionValue);
 
     if (*profiler)
-        (*profiler)->didExecute(exec, scopeChain->globalObject()->evalFunction());
+        (*profiler)->didExecute(callFrame, scopeChain->globalObject()->evalFunction());
 
     return result;
@@ -653 +652 @@
 #ifndef NDEBUG
 
-void Machine::dumpCallFrame(const RegisterFile* registerFile, const Register* r)
-{
-    JSGlobalObject* globalObject = scopeChain(r)->globalObject();
-
-    CodeBlock* codeBlock = this->codeBlock(r);
+void Machine::dumpCallFrame(const RegisterFile* registerFile, CallFrame* callFrame)
+{
+    JSGlobalObject* globalObject = callFrame->scopeChain()->globalObject();
+
+    CodeBlock* codeBlock = callFrame->codeBlock();
     codeBlock->dump(globalObject->globalExec());
 
-    dumpRegisters(registerFile, r);
-}
-
-void Machine::dumpRegisters(const RegisterFile* registerFile, const Register* r)
+    dumpRegisters(registerFile, callFrame);
+}
+
+void Machine::dumpRegisters(const RegisterFile* registerFile, CallFrame* callFrame)
 {
     printf("Register frame: \n\n");
@@ -670 +669 @@
     printf("----------------------------------------------------\n");
 
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     const Register* it;
     const Register* end;
@@ -684 +683 @@
     }
     
-    it = r - RegisterFile::CallFrameHeaderSize - codeBlock->numParameters;
+    it = callFrame->registers() - RegisterFile::CallFrameHeaderSize - codeBlock->numParameters;
     printf("[this]                     | %10p | %10p \n", it, (*it).v()); ++it;
     end = it + max(codeBlock->numParameters - 1, 0); // - 1 to skip "this"
@@ -740 +739 @@
 #endif
 
-//#if !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
-
 bool Machine::isOpcode(Opcode opcode)
 {
@@ -753 +750 @@
 }
 
-//#endif
-
-NEVER_INLINE bool Machine::unwindCallFrame(ExecState*& exec, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock, Register*& r)
+NEVER_INLINE bool Machine::unwindCallFrame(CallFrame*& callFrame, JSValue* exceptionValue, const Instruction*& vPC, CodeBlock*& codeBlock)
 {
     CodeBlock* oldCodeBlock = codeBlock;
-    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))
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
+
+    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
+        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
+        if (callFrame->callee())
             debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->lastLine());
         else
@@ -769 +764 @@
 
     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {
-        if (r[RegisterFile::Callee].jsValue(exec))
-            profiler->didExecute(exec, static_cast<JSObject*>(r[RegisterFile::Callee].jsValue(exec)));
+        if (callFrame->callee())
+            profiler->didExecute(callFrame, callFrame->callee());
         else
-            profiler->didExecute(exec, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
+            profiler->didExecute(callFrame, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
     }
 
@@ -779 +774 @@
         while (!scopeChain->object->isObject(&JSActivation::info))
             scopeChain = scopeChain->pop();
-        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));
+        static_cast<JSActivation*>(scopeChain->object)->copyRegisters(callFrame->optionalCalleeArguments());
+    } else if (Arguments* arguments = callFrame->optionalCalleeArguments()) {
         if (!arguments->isTornOff())
             arguments->copyRegisters();
@@ -795 +783 @@
         scopeChain->deref();
 
-    void* returnPC = r[RegisterFile::ReturnPC].v();
-    r = r[RegisterFile::CallerRegisters].r();
-    exec = CallFrame::create(r);
-    if (isHostCallFrame(r))
+    void* returnPC = callFrame->returnPC();
+    callFrame = callFrame->callerFrame();
+    if (callFrame->hasHostCallFrameFlag())
         return false;
 
-    codeBlock = this->codeBlock(r);
+    codeBlock = callFrame->codeBlock();
     vPC = vPCForPC(codeBlock, returnPC);
     return true;
 }
 
-NEVER_INLINE Instruction* Machine::throwException(ExecState* exec, JSValue*& exceptionValue, const Instruction* vPC, Register*& r, bool explicitThrow)
+NEVER_INLINE Instruction* Machine::throwException(CallFrame*& callFrame, JSValue*& exceptionValue, const Instruction* vPC, bool explicitThrow)
 {
     // Set up the exception object
     
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     if (exceptionValue->isObject()) {
         JSObject* exception = static_cast<JSObject*>(exceptionValue);
         if (exception->isNotAnObjectErrorStub()) {
-            exception = createNotAnObjectError(exec, static_cast<JSNotAnObjectErrorStub*>(exception), vPC, codeBlock);
+            exception = createNotAnObjectError(callFrame, static_cast<JSNotAnObjectErrorStub*>(exception), vPC, codeBlock);
             exceptionValue = exception;
         } else {
-            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 (!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 (explicitThrow) {
                     int startOffset = 0;
@@ -828 +815 @@
                     int divotPoint = 0;
                     int line = codeBlock->expressionRangeForVPC(vPC, divotPoint, startOffset, endOffset);
-                    exception->putWithAttributes(exec, Identifier(exec, "line"), jsNumber(exec, line), ReadOnly | DontDelete);
+                    exception->putWithAttributes(callFrame, Identifier(callFrame, "line"), jsNumber(callFrame, 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(exec, Identifier(exec, expressionBeginOffsetPropertyName), jsNumber(exec, divotPoint - startOffset), ReadOnly | DontDelete);
-                    exception->putWithAttributes(exec, Identifier(exec, expressionEndOffsetPropertyName), jsNumber(exec, divotPoint + endOffset), ReadOnly | DontDelete);
+                    exception->putWithAttributes(callFrame, Identifier(callFrame, expressionBeginOffsetPropertyName), jsNumber(callFrame, divotPoint - startOffset), ReadOnly | DontDelete);
+                    exception->putWithAttributes(callFrame, Identifier(callFrame, expressionEndOffsetPropertyName), jsNumber(callFrame, divotPoint + endOffset), ReadOnly | DontDelete);
                 } else
-                    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);
+                    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);
             }
             
             if (exception->isWatchdogException()) {
-                while (unwindCallFrame(exec, exceptionValue, vPC, codeBlock, r)) {
+                while (unwindCallFrame(callFrame, exceptionValue, vPC, codeBlock)) {
                     // Don't need handler checks or anything, we just want to unroll all the JS callframes possible.
                 }
@@ -849 +836 @@
     }
 
-    if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
-        ScopeChainNode* scopeChain = this->scopeChain(r);
-        DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
+    if (Debugger* debugger = callFrame->dynamicGlobalObject()->debugger()) {
+        DebuggerCallFrame debuggerCallFrame(callFrame, exceptionValue);
         debugger->exception(debuggerCallFrame, codeBlock->ownerNode->sourceID(), codeBlock->lineNumberForVPC(vPC));
     }
@@ -861 +847 @@
 
     while (!codeBlock->getHandlerForVPC(vPC, handlerVPC, scopeDepth)) {
-        if (!unwindCallFrame(exec, exceptionValue, vPC, codeBlock, r))
+        if (!unwindCallFrame(callFrame, exceptionValue, vPC, codeBlock))
             return 0;
     }
@@ -867 +853 @@
     // Now unwind the scope chain within the exception handler's call frame.
 
-    ScopeChain sc(this->scopeChain(r));
+    ScopeChain sc(callFrame->scopeChain());
     int scopeDelta = depth(codeBlock, sc) - scopeDepth;
     ASSERT(scopeDelta >= 0);
     while (scopeDelta--)
         sc.pop();
-    r[RegisterFile::ScopeChain] = sc.node();
+    callFrame->setScopeChain(sc.node());
 
     return handlerVPC;
 }
 
-class DynamicGlobalObjectScope {
+class DynamicGlobalObjectScope : Noncopyable {
 public:
-    DynamicGlobalObjectScope(ExecState* exec, JSGlobalObject* dynamicGlobalObject) 
-        : m_exec(exec)
-        , m_savedGlobalObject(exec->globalData().dynamicGlobalObject)
+    DynamicGlobalObjectScope(CallFrame* callFrame, JSGlobalObject* dynamicGlobalObject) 
+        : m_dynamicGlobalObjectSlot(callFrame->globalData().dynamicGlobalObject)
+        , m_savedDynamicGlobalObject(m_dynamicGlobalObjectSlot)
     {
-        exec->globalData().dynamicGlobalObject = dynamicGlobalObject;
+        m_dynamicGlobalObjectSlot = dynamicGlobalObject;
     }
 
     ~DynamicGlobalObjectScope()
     {
-        m_exec->globalData().dynamicGlobalObject = m_savedGlobalObject;
+        m_dynamicGlobalObjectSlot = m_savedDynamicGlobalObject;
     }
 
 private:
-    ExecState* m_exec;
-    JSGlobalObject* m_savedGlobalObject;
+    JSGlobalObject*& m_dynamicGlobalObjectSlot;
+    JSGlobalObject* m_savedDynamicGlobalObject;
 };
 
-JSValue* Machine::execute(ProgramNode* programNode, ExecState* exec, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
-{
-    ASSERT(!exec->hadException());
+JSValue* Machine::execute(ProgramNode* programNode, CallFrame* callFrame, ScopeChainNode* scopeChain, JSObject* thisObj, JSValue** exception)
+{
+    ASSERT(!scopeChain->globalData->exception);
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
@@ -910 +896 @@
     Register* newEnd = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize + codeBlock->numCalleeRegisters;
     if (!m_registerFile.grow(newEnd)) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(exec, scopeChain->globalObject());
+    DynamicGlobalObjectScope globalObjectScope(callFrame, scopeChain->globalObject());
 
     JSGlobalObject* lastGlobalObject = m_registerFile.globalObject();
-    JSGlobalObject* globalObject = exec->dynamicGlobalObject();
+    JSGlobalObject* globalObject = callFrame->dynamicGlobalObject();
     globalObject->copyGlobalsTo(m_registerFile);
 
-    Register* r = oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize;
-    r[codeBlock->thisRegister] = thisObj;
-    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(0), 0, 0, 0);
+    CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->numParameters + RegisterFile::CallFrameHeaderSize);
+    newCallFrame[codeBlock->thisRegister] = thisObj;
+    newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain)
-        scopeChain = scopeChain->copy();
+        scopeChain->ref();
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(exec, programNode->sourceURL(), programNode->lineNo());
+        (*profiler)->willExecute(newCallFrame, programNode->sourceURL(), programNode->lineNo());
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, exec, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
+        CTI::compile(this, newCallFrame, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
     m_reentryDepth--;
@@ -944 +930 @@
 
     if (*profiler)
-        (*profiler)->didExecute(exec, programNode->sourceURL(), programNode->lineNo());
+        (*profiler)->didExecute(callFrame, programNode->sourceURL(), programNode->lineNo());
 
     if (m_reentryDepth && lastGlobalObject && globalObject != lastGlobalObject)
@@ -954 +940 @@
 }
 
-JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, ExecState* exec, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
-{
-    ASSERT(!exec->hadException());
+JSValue* Machine::execute(FunctionBodyNode* functionBodyNode, CallFrame* callFrame, JSFunction* function, JSObject* thisObj, const ArgList& args, ScopeChainNode* scopeChain, JSValue** exception)
+{
+    ASSERT(!scopeChain->globalData->exception);
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
@@ -967 +953 @@
 
     if (!m_registerFile.grow(oldEnd + argc)) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(exec, exec->globalData().dynamicGlobalObject ? exec->globalData().dynamicGlobalObject : scopeChain->globalObject());
-
-    Register* argv = oldEnd;
+    DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject());
+
+    CallFrame* newCallFrame = CallFrame::create(oldEnd);
     size_t dst = 0;
-    argv[dst] = thisObj;
-
+    newCallFrame[0] = thisObj;
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        argv[++dst] = *it;
+        newCallFrame[++dst] = *it;
 
     CodeBlock* codeBlock = &functionBodyNode->byteCode(scopeChain);
-    Register* r = slideRegisterWindowForCall(codeBlock, &m_registerFile, argv, argc + RegisterFile::CallFrameHeaderSize, argc);
-    if (UNLIKELY(!r)) {
-        *exception = createStackOverflowError(exec);
+    newCallFrame = slideRegisterWindowForCall(codeBlock, &m_registerFile, newCallFrame, argc + RegisterFile::CallFrameHeaderSize, argc);
+    if (UNLIKELY(!newCallFrame)) {
+        *exception = createStackOverflowError(callFrame);
         m_registerFile.shrink(oldEnd);
         return jsNull();
     }
     // a 0 codeBlock indicates a built-in caller
-    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(exec->registers()), 0, argc, function);
+    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, argc, function);
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(exec, function);
+        (*profiler)->willExecute(newCallFrame, function);
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, exec, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
+        CTI::compile(this, newCallFrame, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
     m_reentryDepth--;
@@ -1011 +996 @@
 }
 
-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());
+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);
 
     if (m_reentryDepth >= MaxReentryDepth) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
 
-    DynamicGlobalObjectScope globalObjectScope(exec, exec->globalData().dynamicGlobalObject ? exec->globalData().dynamicGlobalObject : scopeChain->globalObject());
+    DynamicGlobalObjectScope globalObjectScope(callFrame, callFrame->globalData().dynamicGlobalObject ? callFrame->globalData().dynamicGlobalObject : scopeChain->globalObject());
 
     EvalCodeBlock* codeBlock = &evalNode->byteCode(scopeChain);
@@ -1046 +1031 @@
         for (Node::VarStack::const_iterator it = varStack.begin(); it != varStackEnd; ++it) {
             const Identifier& ident = (*it).first;
-            if (!variableObject->hasProperty(exec, ident)) {
+            if (!variableObject->hasProperty(callFrame, ident)) {
                 PutPropertySlot slot;
-                variableObject->put(exec, ident, jsUndefined(), slot);
+                variableObject->put(callFrame, ident, jsUndefined(), slot);
             }
         }
@@ -1056 +1041 @@
         for (Node::FunctionStack::const_iterator it = functionStack.begin(); it != functionStackEnd; ++it) {
             PutPropertySlot slot;
-            variableObject->put(exec, (*it)->m_ident, (*it)->makeFunction(exec, scopeChain), slot);
+            variableObject->put(callFrame, (*it)->m_ident, (*it)->makeFunction(callFrame, scopeChain), slot);
         }
 
@@ -1064 +1049 @@
     Register* newEnd = m_registerFile.start() + registerOffset + codeBlock->numCalleeRegisters;
     if (!m_registerFile.grow(newEnd)) {
-        *exception = createStackOverflowError(exec);
+        *exception = createStackOverflowError(callFrame);
         return jsNull();
     }
 
-    Register* r = m_registerFile.start() + registerOffset;
+    CallFrame* newCallFrame = CallFrame::create(m_registerFile.start() + registerOffset);
 
     // a 0 codeBlock indicates a built-in caller
-    r[codeBlock->thisRegister] = thisObj;
-    initializeCallFrame(r, codeBlock, 0, scopeChain, makeHostCallFramePointer(exec->registers()), 0, 0, 0);
+    newCallFrame[codeBlock->thisRegister] = thisObj;
+    newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0);
 
     if (codeBlock->needsFullScopeChain)
-        scopeChain = scopeChain->copy();
+        scopeChain->ref();
 
     Profiler** profiler = Profiler::enabledProfilerReference();
     if (*profiler)
-        (*profiler)->willExecute(exec, evalNode->sourceURL(), evalNode->lineNo());
+        (*profiler)->willExecute(newCallFrame, evalNode->sourceURL(), evalNode->lineNo());
 
     m_reentryDepth++;
 #if ENABLE(CTI)
     if (!codeBlock->ctiCode)
-        CTI::compile(this, exec, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, r, scopeChain->globalData, exception);
+        CTI::compile(this, newCallFrame, codeBlock);
+    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, r, exception);
+    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
     m_reentryDepth--;
@@ -1094 +1079 @@
 
     if (*profiler)
-        (*profiler)->didExecute(exec, evalNode->sourceURL(), evalNode->lineNo());
+        (*profiler)->didExecute(callFrame, evalNode->sourceURL(), evalNode->lineNo());
 
     m_registerFile.shrink(oldEnd);
@@ -1100 +1085 @@
 }
 
-NEVER_INLINE void Machine::debug(ExecState* exec, Register* r, DebugHookID debugHookID, int firstLine, int lastLine)
-{
-    Debugger* debugger = exec->dynamicGlobalObject()->debugger();
+NEVER_INLINE void Machine::debug(CallFrame* callFrame, DebugHookID debugHookID, int firstLine, int lastLine)
+{
+    Debugger* debugger = callFrame->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, codeBlock->ownerNode->sourceID(), firstLine);
+            debugger->callEvent(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
             return;
         case WillLeaveCallFrame:
-            debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
+            debugger->returnEvent(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
             return;
         case WillExecuteStatement:
-            debugger->atStatement(debuggerCallFrame, codeBlock->ownerNode->sourceID(), firstLine);
+            debugger->atStatement(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
             return;
         case WillExecuteProgram:
-            debugger->willExecuteProgram(debuggerCallFrame, codeBlock->ownerNode->sourceID(), firstLine);
+            debugger->willExecuteProgram(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), firstLine);
             return;
         case DidExecuteProgram:
-            debugger->didExecuteProgram(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
+            debugger->didExecuteProgram(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
             return;
         case DidReachBreakpoint:
-            debugger->didReachBreakpoint(debuggerCallFrame, codeBlock->ownerNode->sourceID(), lastLine);
+            debugger->didReachBreakpoint(DebuggerCallFrame(callFrame, 0), callFrame->codeBlock()->ownerNode->sourceID(), lastLine);
             return;
     }
@@ -1217 +1198 @@
 }
 
-NEVER_INLINE ScopeChainNode* Machine::createExceptionScope(ExecState* exec, const Instruction* vPC, Register* r)
+NEVER_INLINE ScopeChainNode* Machine::createExceptionScope(CallFrame* callFrame, const Instruction* vPC)
 {
     int dst = (++vPC)->u.operand;
-    CodeBlock* codeBlock = this->codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& property = codeBlock->identifiers[(++vPC)->u.operand];
-    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);
+    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);
     if (JSImmediate::isImmediate(prototype))
         return 0;
@@ -1239 +1220 @@
 }
 
-NEVER_INLINE void Machine::tryCachePutByID(ExecState* exec, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Machine::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
@@ -1291 +1272 @@
         StructureIDChain* chain = structureID->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(exec, structureID);
+            chain = cachePrototypeChain(callFrame, structureID);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
@@ -1316 +1297 @@
 }
 
-NEVER_INLINE void Machine::tryCacheGetByID(ExecState* exec, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Machine::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
 {
     // Recursive invocation may already have specialized this instruction.
@@ -1328 +1309 @@
     }
 
-    if (isJSArray(baseValue) && propertyName == exec->propertyNames().length) {
+    if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
         vPC[0] = getOpcode(op_get_array_length);
         return;
     }
 
-    if (isJSString(baseValue) && propertyName == exec->propertyNames().length) {
+    if (isJSString(baseValue) && propertyName == callFrame->propertyNames().length) {
         vPC[0] = getOpcode(op_get_string_length);
         return;
@@ -1375 +1356 @@
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(exec)) {
+    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
         ASSERT(slot.slotBase()->isObject());
 
@@ -1399 +1380 @@
     JSObject* o = static_cast<JSObject*>(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(exec);
+        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
 
         // If we didn't find base in baseValue's prototype chain, then baseValue
@@ -1423 +1404 @@
     StructureIDChain* chain = structureID->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(exec, structureID);
+        chain = cachePrototypeChain(callFrame, structureID);
     ASSERT(chain);
 
@@ -1441 +1422 @@
 }
 
-JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, Register* r, JSValue** exception)
+JSValue* Machine::privateExecute(ExecutionFlag flag, RegisterFile* registerFile, CallFrame* callFrame, JSValue** exception)
 {
     // One-time initialization of our address tables. We have to put this code
@@ -1466 +1447 @@
 #endif
 
-#define exec CallFrame::create(r)
-
-    JSGlobalData* globalData = &exec->globalData();
+    JSGlobalData* globalData = &callFrame->globalData();
     JSValue* exceptionValue = 0;
     Instruction* handlerVPC = 0;
 
-    Instruction* vPC = this->codeBlock(r)->instructions.begin();
+    Instruction* vPC = callFrame->codeBlock()->instructions.begin();
     Profiler** enabledProfilerReference = Profiler::enabledProfilerReference();
     unsigned tickCount = m_ticksUntilNextTimeoutCheck + 1;
@@ -1490 +1469 @@
 #define CHECK_FOR_TIMEOUT() \
     if (!--tickCount) { \
-        if ((exceptionValue = checkTimeout(exec->dynamicGlobalObject()))) \
+        if ((exceptionValue = checkTimeout(callFrame->dynamicGlobalObject()))) \
             goto vm_throw; \
         tickCount = m_ticksUntilNextTimeoutCheck; \
@@ -1496 +1475 @@
 
 #if HAVE(COMPUTED_GOTO)
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(this->codeBlock(r), vPC); goto *vPC->u.opcode
+    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto *vPC->u.opcode
 #if DUMP_OPCODE_STATS
     #define BEGIN_OPCODE(opcode) opcode: OpcodeStats::recordInstruction(opcode);
@@ -1504 +1483 @@
     NEXT_OPCODE;
 #else
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(this->codeBlock(r), vPC); goto interpreterLoopStart
+    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto interpreterLoopStart
 #if DUMP_OPCODE_STATS
     #define BEGIN_OPCODE(opcode) case opcode: OpcodeStats::recordInstruction(opcode);
@@ -1522 +1501 @@
         */
         int dst = (++vPC)->u.operand;
-        r[dst] = constructEmptyObject(exec);
+        callFrame[dst] = constructEmptyObject(callFrame);
 
         ++vPC;
@@ -1538 +1517 @@
         int firstArg = (++vPC)->u.operand;
         int argCount = (++vPC)->u.operand;
-        ArgList args(r + firstArg, argCount);
-        r[dst] = constructArray(exec, args);
+        ArgList args(callFrame->registers() + firstArg, argCount);
+        callFrame[dst] = constructArray(callFrame, args);
 
         ++vPC;
@@ -1553 +1532 @@
         int dst = (++vPC)->u.operand;
         int regExp = (++vPC)->u.operand;
-        r[dst] = new (globalData) RegExpObject(scopeChain(r)->globalObject()->regExpStructure(), codeBlock(r)->regexps[regExp]);
+        callFrame[dst] = new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexps[regExp]);
 
         ++vPC;
@@ -1565 +1544 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = r[src];
+        callFrame[dst] = callFrame[src];
 
         ++vPC;
@@ -1578 +1557 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else {
-            JSValue* result = jsBoolean(equalSlowCase(exec, src1, src2));
+            JSValue* result = jsBoolean(equalSlowCase(callFrame, src1, src2));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1598 +1577 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (src->isUndefinedOrNull()) {
-            r[dst] = jsBoolean(true);
+            callFrame[dst] = jsBoolean(true);
             ++vPC;
             NEXT_OPCODE;
         }
         
-        r[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_OPCODE;
@@ -1618 +1597 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            r[dst] = jsBoolean(src1 != src2);
+            callFrame[dst] = jsBoolean(src1 != src2);
         else {
-            JSValue* result = jsBoolean(!equalSlowCase(exec, src1, src2));
+            JSValue* result = jsBoolean(!equalSlowCase(callFrame, src1, src2));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1638 +1617 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (src->isUndefinedOrNull()) {
-            r[dst] = jsBoolean(false);
+            callFrame[dst] = jsBoolean(false);
             ++vPC;
             NEXT_OPCODE;
         }
         
-        r[dst] = jsBoolean(JSImmediate::isImmediate(src) || !static_cast<JSCell*>(src)->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !static_cast<JSCell*>(src)->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_OPCODE;
@@ -1658 +1637 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediate(src1, src2))
-            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
-            r[dst] = jsBoolean(false);
+            callFrame[dst] = jsBoolean(false);
         else
-            r[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
+            callFrame[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
 
         ++vPC;
@@ -1678 +1657 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
 
         if (JSImmediate::areBothImmediate(src1, src2))
-            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
+            callFrame[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
         else if (JSImmediate::isEitherImmediate(src1, src2) & (src1 != JSImmediate::zeroImmediate()) & (src2 != JSImmediate::zeroImmediate()))
-            r[dst] = jsBoolean(true);
+            callFrame[dst] = jsBoolean(true);
         else
-            r[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
+            callFrame[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
 
         ++vPC;
@@ -1699 +1678 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* result = jsBoolean(jsLess(exec, src1, src2));
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* result = jsBoolean(jsLess(callFrame, src1, src2));
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
 
         ++vPC;
@@ -1716 +1695 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* result = jsBoolean(jsLessEq(exec, src1, src2));
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* result = jsBoolean(jsLessEq(callFrame, src1, src2));
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
 
         ++vPC;
@@ -1732 +1711 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].jsValue(exec);
+        JSValue* v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            r[srcDst] = JSImmediate::incImmediateNumber(v);
+            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
         else {
-            JSValue* result = jsNumber(exec, v->toNumber(exec) + 1);
+            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) + 1);
             VM_CHECK_EXCEPTION();
-            r[srcDst] = result;
+            callFrame[srcDst] = result;
         }
 
@@ -1751 +1730 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].jsValue(exec);
+        JSValue* v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            r[srcDst] = JSImmediate::decImmediateNumber(v);
+            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
         else {
-            JSValue* result = jsNumber(exec, v->toNumber(exec) - 1);
+            JSValue* result = jsNumber(callFrame, v->toNumber(callFrame) - 1);
             VM_CHECK_EXCEPTION();
-            r[srcDst] = result;
+            callFrame[srcDst] = result;
         }
 
@@ -1772 +1751 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].jsValue(exec);
+        JSValue* v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            r[dst] = v;
-            r[srcDst] = JSImmediate::incImmediateNumber(v);
+            callFrame[dst] = v;
+            callFrame[srcDst] = JSImmediate::incImmediateNumber(v);
         } else {
-            JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
+            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
             VM_CHECK_EXCEPTION();
-            r[dst] = number;
-            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() + 1);
+            callFrame[dst] = number;
+            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() + 1);
         }
 
@@ -1795 +1774 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].jsValue(exec);
+        JSValue* v = callFrame[srcDst].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            r[dst] = v;
-            r[srcDst] = JSImmediate::decImmediateNumber(v);
+            callFrame[dst] = v;
+            callFrame[srcDst] = JSImmediate::decImmediateNumber(v);
         } else {
-            JSValue* number = r[srcDst].jsValue(exec)->toJSNumber(exec);
+            JSValue* number = callFrame[srcDst].jsValue(callFrame)->toJSNumber(callFrame);
             VM_CHECK_EXCEPTION();
-            r[dst] = number;
-            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() - 1);
+            callFrame[dst] = number;
+            callFrame[srcDst] = jsNumber(callFrame, number->uncheckedGetNumber() - 1);
         }
 
@@ -1818 +1797 @@
         int src = (++vPC)->u.operand;
 
-        JSValue* srcVal = r[src].jsValue(exec);
+        JSValue* srcVal = callFrame[src].jsValue(callFrame);
 
         if (LIKELY(srcVal->isNumber()))
-            r[dst] = r[src];
+            callFrame[dst] = callFrame[src];
         else {
-            JSValue* result = srcVal->toJSNumber(exec);
+            JSValue* result = srcVal->toJSNumber(callFrame);
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1838 +1817 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double v;
         if (fastIsNumber(src, v))
-            r[dst] = jsNumber(exec, -v);
+            callFrame[dst] = jsNumber(callFrame, -v);
         else {
-            JSValue* result = jsNumber(exec, -src->toNumber(exec));
+            JSValue* result = jsNumber(callFrame, -src->toNumber(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1859 +1838 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            r[dst] = JSImmediate::addImmediateNumbers(src1, src2);
+            callFrame[dst] = JSImmediate::addImmediateNumbers(src1, src2);
         else {
-            JSValue* result = jsAdd(exec, src1, src2);
+            JSValue* result = jsAdd(callFrame, src1, src2);
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
         vPC += 2;
@@ -1878 +1857 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            r[dst] = jsNumber(exec, left * right);
+            callFrame[dst] = jsNumber(callFrame, left * right);
         else {
-            JSValue* result = jsNumber(exec, src1->toNumber(exec) * src2->toNumber(exec));
+            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) * src2->toNumber(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1901 +1880 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* dividend = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* divisor = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* dividend = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* divisor = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (fastIsNumber(dividend, left) && fastIsNumber(divisor, right))
-            r[dst] = jsNumber(exec, left / right);
+            callFrame[dst] = jsNumber(callFrame, left / right);
         else {
-            JSValue* result = jsNumber(exec, dividend->toNumber(exec) / divisor->toNumber(exec));
+            JSValue* result = jsNumber(callFrame, dividend->toNumber(callFrame) / divisor->toNumber(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
         ++vPC;
@@ -1926 +1905 @@
         int divisor = (++vPC)->u.operand;
 
-        JSValue* dividendValue = r[dividend].jsValue(exec);
-        JSValue* divisorValue = r[divisor].jsValue(exec);
+        JSValue* dividendValue = callFrame[dividend].jsValue(callFrame);
+        JSValue* divisorValue = callFrame[divisor].jsValue(callFrame);
 
         if (JSImmediate::areBothImmediateNumbers(dividendValue, divisorValue) && divisorValue != JSImmediate::from(0)) {
-            r[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
+            callFrame[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
             ++vPC;
             NEXT_OPCODE;
         }
 
-        double d = dividendValue->toNumber(exec);
-        JSValue* result = jsNumber(exec, fmod(d, divisorValue->toNumber(exec)));
+        double d = dividendValue->toNumber(callFrame);
+        JSValue* result = jsNumber(callFrame, fmod(d, divisorValue->toNumber(callFrame)));
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1950 +1929 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         double left;
         double right;
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            r[dst] = JSImmediate::subImmediateNumbers(src1, src2);
+            callFrame[dst] = JSImmediate::subImmediateNumbers(src1, src2);
         else if (fastIsNumber(src1, left) && fastIsNumber(src2, right))
-            r[dst] = jsNumber(exec, left - right);
+            callFrame[dst] = jsNumber(callFrame, left - right);
         else {
-            JSValue* result = jsNumber(exec, src1->toNumber(exec) - src2->toNumber(exec));
+            JSValue* result = jsNumber(callFrame, src1->toNumber(callFrame) - src2->toNumber(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
         vPC += 2;
@@ -1974 +1953 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            r[dst] = jsNumber(exec, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
+            callFrame[dst] = jsNumber(callFrame, JSImmediate::getTruncatedInt32(val) << (JSImmediate::getTruncatedUInt32(shift) & 0x1f));
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            r[dst] = jsNumber(exec, left << (right & 0x1f));
+            callFrame[dst] = jsNumber(callFrame, left << (right & 0x1f));
         else {
-            JSValue* result = jsNumber(exec, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -1999 +1978 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         uint32_t right;
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else if (fastToInt32(val, left) && fastToUInt32(shift, right))
-            r[dst] = jsNumber(exec, left >> (right & 0x1f));
+            callFrame[dst] = jsNumber(callFrame, left >> (right & 0x1f));
         else {
-            JSValue* result = jsNumber(exec, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(callFrame, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -2024 +2003 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* val = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* shift = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* val = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* shift = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
-            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            callFrame[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else {
-            JSValue* result = jsNumber(exec, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(callFrame, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -2045 +2024 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            r[dst] = JSImmediate::andImmediateNumbers(src1, src2);
+            callFrame[dst] = JSImmediate::andImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            r[dst] = jsNumber(exec, left & right);
+            callFrame[dst] = jsNumber(callFrame, left & right);
         else {
-            JSValue* result = jsNumber(exec, src1->toInt32(exec) & src2->toInt32(exec));
+            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) & src2->toInt32(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -2070 +2049 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            r[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
+            callFrame[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            r[dst] = jsNumber(exec, left ^ right);
+            callFrame[dst] = jsNumber(callFrame, left ^ right);
         else {
-            JSValue* result = jsNumber(exec, src1->toInt32(exec) ^ src2->toInt32(exec));
+            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -2095 +2074 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t left;
         int32_t right;
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            r[dst] = JSImmediate::orImmediateNumbers(src1, src2);
+            callFrame[dst] = JSImmediate::orImmediateNumbers(src1, src2);
         else if (fastToInt32(src1, left) && fastToInt32(src2, right))
-            r[dst] = jsNumber(exec, left | right);
+            callFrame[dst] = jsNumber(callFrame, left | right);
         else {
-            JSValue* result = jsNumber(exec, src1->toInt32(exec) | src2->toInt32(exec));
+            JSValue* result = jsNumber(callFrame, src1->toInt32(callFrame) | src2->toInt32(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
 
@@ -2119 +2098 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue* src = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int32_t value;
         if (fastToInt32(src, value))
-            r[dst] = jsNumber(exec, ~value);
+            callFrame[dst] = jsNumber(callFrame, ~value);
         else {
-            JSValue* result = jsNumber(exec, ~src->toInt32(exec));
+            JSValue* result = jsNumber(callFrame, ~src->toInt32(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = result;
+            callFrame[dst] = result;
         }
         ++vPC;
@@ -2139 +2118 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsBoolean(!r[src].jsValue(exec)->toBoolean(exec));
+        JSValue* result = jsBoolean(!callFrame[src].jsValue(callFrame)->toBoolean(callFrame));
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
 
         ++vPC;
@@ -2164 +2143 @@
         int baseProto = (++vPC)->u.operand;
 
-        JSValue* baseVal = r[base].jsValue(exec);
-
-        if (isNotObject(exec, true, codeBlock(r), vPC, baseVal, exceptionValue))
+        JSValue* baseVal = callFrame[base].jsValue(callFrame);
+
+        if (isNotObject(callFrame, true, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
-        r[dst] = jsBoolean(baseObj->structureID()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(exec, r[value].jsValue(exec), r[baseProto].jsValue(exec)) : false);
+        callFrame[dst] = jsBoolean(baseObj->structureID()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false);
 
         ++vPC;
@@ -2183 +2162 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsTypeStringForValue(exec, r[src].jsValue(exec));
+        callFrame[dst] = jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame));
 
         ++vPC;
@@ -2197 +2176 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* v = r[src].jsValue(exec);
-        r[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        JSValue* v = callFrame[src].jsValue(callFrame);
+        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
 
         ++vPC;
@@ -2212 +2191 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsBoolean(r[src].jsValue(exec)->isBoolean());
+        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isBoolean());
 
         ++vPC;
@@ -2226 +2205 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsBoolean(r[src].jsValue(exec)->isNumber());
+        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isNumber());
 
         ++vPC;
@@ -2240 +2219 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsBoolean(r[src].jsValue(exec)->isString());
+        callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)->isString());
 
         ++vPC;
@@ -2254 +2233 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsBoolean(jsIsObjectType(r[src].jsValue(exec)));
+        callFrame[dst] = jsBoolean(jsIsObjectType(callFrame[src].jsValue(callFrame)));
 
         ++vPC;
@@ -2268 +2247 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = jsBoolean(jsIsFunctionType(r[src].jsValue(exec)));
+        callFrame[dst] = jsBoolean(jsIsFunctionType(callFrame[src].jsValue(callFrame)));
 
         ++vPC;
@@ -2286 +2265 @@
         int base = (++vPC)->u.operand;
 
-        JSValue* baseVal = r[base].jsValue(exec);
-        if (isNotObject(exec, false, codeBlock(r), vPC, baseVal, exceptionValue))
+        JSValue* baseVal = callFrame[base].jsValue(callFrame);
+        if (isNotObject(callFrame, false, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
 
-        JSValue* propName = r[property].jsValue(exec);
+        JSValue* propName = callFrame[property].jsValue(callFrame);
 
         uint32_t i;
         if (propName->getUInt32(i))
-            r[dst] = jsBoolean(baseObj->hasProperty(exec, i));
+            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, i));
         else {
-            Identifier property(exec, propName->toString(exec));
+            Identifier property(callFrame, propName->toString(callFrame));
             VM_CHECK_EXCEPTION();
-            r[dst] = jsBoolean(baseObj->hasProperty(exec, property));
+            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, property));
         }
 
@@ -2313 +2292 @@
            dst. If the property is not found, raises an exception.
         */
-        if (UNLIKELY(!resolve(exec, vPC, r, exceptionValue)))
+        if (UNLIKELY(!resolve(callFrame, vPC, exceptionValue)))
             goto vm_throw;
 
@@ -2326 +2305 @@
          value to register dst. If the property is not found, raises an exception.
          */
-        if (UNLIKELY(!resolveSkip(exec, vPC, r, exceptionValue)))
+        if (UNLIKELY(!resolveSkip(callFrame, vPC, exceptionValue)))
             goto vm_throw;
 
@@ -2341 +2320 @@
            cache the new structureID and offset
          */
-        if (UNLIKELY(!resolveGlobal(exec, vPC, r,  exceptionValue)))
+        if (UNLIKELY(!resolveGlobal(callFrame, vPC, exceptionValue)))
             goto vm_throw;
         
@@ -2358 +2337 @@
         int index = (++vPC)->u.operand;
 
-        r[dst] = scope->registerAt(index);
+        callFrame[dst] = scope->registerAt(index);
         ++vPC;
         NEXT_OPCODE;
@@ -2372 +2351 @@
         int value = (++vPC)->u.operand;
         
-        scope->registerAt(index) = r[value].jsValue(exec);
+        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
         ++vPC;
         NEXT_OPCODE;
@@ -2384 +2363 @@
         int dst = (++vPC)->u.operand;
         int index = (++vPC)->u.operand;
-        int skip = (++vPC)->u.operand + codeBlock(r)->needsFullScopeChain;
-
-        ScopeChainNode* scopeChain = this->scopeChain(r);
+        int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain;
+
+        ScopeChainNode* scopeChain = callFrame->scopeChain();
         ScopeChainIterator iter = scopeChain->begin();
         ScopeChainIterator end = scopeChain->end();
@@ -2397 +2376 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        r[dst] = scope->registerAt(index);
+        callFrame[dst] = scope->registerAt(index);
         ++vPC;
         NEXT_OPCODE;
@@ -2406 +2385 @@
          */
         int index = (++vPC)->u.operand;
-        int skip = (++vPC)->u.operand + codeBlock(r)->needsFullScopeChain;
+        int skip = (++vPC)->u.operand + callFrame->codeBlock()->needsFullScopeChain;
         int value = (++vPC)->u.operand;
 
-        ScopeChainNode* scopeChain = this->scopeChain(r);
+        ScopeChainNode* scopeChain = callFrame->scopeChain();
         ScopeChainIterator iter = scopeChain->begin();
         ScopeChainIterator end = scopeChain->end();
@@ -2420 +2399 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        scope->registerAt(index) = r[value].jsValue(exec);
+        scope->registerAt(index) = callFrame[value].jsValue(callFrame);
         ++vPC;
         NEXT_OPCODE;
@@ -2432 +2411 @@
            will be the global object) is stored in register dst.
         */
-        resolveBase(exec, vPC, r);
+        resolveBase(callFrame, vPC);
 
         vPC += 3;
@@ -2449 +2428 @@
            avoids duplicate hash lookups.
         */
-        if (UNLIKELY(!resolveBaseAndProperty(exec, vPC, r, exceptionValue)))
+        if (UNLIKELY(!resolveBaseAndProperty(callFrame, vPC, exceptionValue)))
             goto vm_throw;
 
@@ -2470 +2449 @@
            calls but not for other property lookup.
         */
-        if (UNLIKELY(!resolveBaseAndFunc(exec, vPC, r, exceptionValue)))
+        if (UNLIKELY(!resolveBaseAndFunc(callFrame, vPC, exceptionValue)))
             goto vm_throw;
 
@@ -2486 +2465 @@
         int property = vPC[3].u.operand;
 
-        CodeBlock* codeBlock = this->codeBlock(r);
+        CodeBlock* codeBlock = callFrame->codeBlock();
         Identifier& ident = codeBlock->identifiers[property];
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(exec, ident, slot);
+        JSValue* result = baseValue->get(callFrame, ident, slot);
         VM_CHECK_EXCEPTION();
 
-        tryCacheGetByID(exec, codeBlock, vPC, baseValue, ident, slot);
-
-        r[dst] = result;
+        tryCacheGetByID(callFrame, codeBlock, vPC, baseValue, ident, slot);
+
+        callFrame[dst] = result;
         vPC += 8;
         NEXT_OPCODE;
@@ -2507 +2486 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2519 +2498 @@
                 int offset = vPC[5].u.operand;
 
-                ASSERT(baseObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
-                r[dst] = baseObject->getDirectOffset(offset);
+                ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
+                callFrame[dst] = baseObject->getDirectOffset(offset);
 
                 vPC += 8;
@@ -2527 +2506 @@
         }
 
-        uncacheGetByID(codeBlock(r), vPC);
+        uncacheGetByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2538 +2517 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2545 +2524 @@
 
             if (LIKELY(baseCell->structureID() == structureID)) {
-                ASSERT(structureID->prototypeForLookup(exec)->isObject());
-                JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(exec));
+                ASSERT(structureID->prototypeForLookup(callFrame)->isObject());
+                JSObject* protoObject = static_cast<JSObject*>(structureID->prototypeForLookup(callFrame));
                 StructureID* protoStructureID = vPC[5].u.structureID;
 
@@ -2553 +2532 @@
                     int offset = vPC[6].u.operand;
 
-                    ASSERT(protoObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == protoObject->getDirectOffset(offset));
-                    r[dst] = protoObject->getDirectOffset(offset);
+                    ASSERT(protoObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == protoObject->getDirectOffset(offset));
+                    callFrame[dst] = protoObject->getDirectOffset(offset);
 
                     vPC += 8;
@@ -2562 +2541 @@
         }
 
-        uncacheGetByID(codeBlock(r), vPC);
+        uncacheGetByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2573 +2552 @@
         */
         int base = vPC[2].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2586 +2565 @@
                 JSObject* baseObject = static_cast<JSObject*>(baseCell);
                 while (1) {
-                    baseObject = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(exec));
+                    baseObject = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(callFrame));
                     if (UNLIKELY(baseObject->structureID() != (*it).get()))
                         break;
@@ -2594 +2573 @@
                         int offset = vPC[7].u.operand;
 
-                        ASSERT(baseObject->get(exec, codeBlock(r)->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
-                        r[dst] = baseObject->getDirectOffset(offset);
+                        ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifiers[vPC[3].u.operand]) == baseObject->getDirectOffset(offset));
+                        callFrame[dst] = baseObject->getDirectOffset(offset);
 
                         vPC += 8;
@@ -2604 +2583 @@
         }
 
-        uncacheGetByID(codeBlock(r), vPC);
+        uncacheGetByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2617 +2596 @@
         int property = vPC[3].u.operand;
 
-        Identifier& ident = codeBlock(r)->identifiers[property];
-        JSValue* baseValue = r[base].jsValue(exec);
+        Identifier& ident = callFrame->codeBlock()->identifiers[property];
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         PropertySlot slot(baseValue);
-        JSValue* result = baseValue->get(exec, ident, slot);
+        JSValue* result = baseValue->get(callFrame, ident, slot);
         VM_CHECK_EXCEPTION();
 
-        r[dst] = result;
+        callFrame[dst] = result;
         vPC += 8;
         NEXT_OPCODE;
@@ -2636 +2615 @@
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         if (LIKELY(isJSArray(baseValue))) {
             int dst = vPC[1].u.operand;
-            r[dst] = jsNumber(exec, static_cast<JSArray*>(baseValue)->length());
+            callFrame[dst] = jsNumber(callFrame, static_cast<JSArray*>(baseValue)->length());
             vPC += 8;
             NEXT_OPCODE;
         }
 
-        uncacheGetByID(codeBlock(r), vPC);
+        uncacheGetByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2656 +2635 @@
 
         int base = vPC[2].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         if (LIKELY(isJSString(baseValue))) {
             int dst = vPC[1].u.operand;
-            r[dst] = jsNumber(exec, static_cast<JSString*>(baseValue)->value().size());
+            callFrame[dst] = jsNumber(callFrame, static_cast<JSString*>(baseValue)->value().size());
             vPC += 8;
             NEXT_OPCODE;
         }
 
-        uncacheGetByID(codeBlock(r), vPC);
+        uncacheGetByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2681 +2660 @@
         int value = vPC[3].u.operand;
 
-        CodeBlock* codeBlock = this->codeBlock(r);
-        JSValue* baseValue = r[base].jsValue(exec);
+        CodeBlock* codeBlock = callFrame->codeBlock();
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         Identifier& ident = codeBlock->identifiers[property];
         PutPropertySlot slot;
-        baseValue->put(exec, ident, r[value].jsValue(exec), slot);
+        baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
         VM_CHECK_EXCEPTION();
 
-        tryCachePutByID(exec, codeBlock, vPC, baseValue, slot);
+        tryCachePutByID(callFrame, codeBlock, vPC, baseValue, slot);
 
         vPC += 8;
@@ -2705 +2684 @@
          */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
         
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2718 +2697 @@
                 RefPtr<StructureID>* it = vPC[6].u.structureIDChain->head();
 
-                JSObject* proto = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(exec));
+                JSObject* proto = static_cast<JSObject*>(baseObject->structureID()->prototypeForLookup(callFrame));
                 while (!proto->isNull()) {
                     if (UNLIKELY(proto->structureID() != (*it).get())) {
-                        uncachePutByID(codeBlock(r), vPC);
+                        uncachePutByID(callFrame->codeBlock(), vPC);
                         NEXT_OPCODE;
                     }
                     ++it;
-                    proto = static_cast<JSObject*>(proto->structureID()->prototypeForLookup(exec));
+                    proto = static_cast<JSObject*>(proto->structureID()->prototypeForLookup(callFrame));
                 }
 
@@ -2732 +2711 @@
                 int value = vPC[3].u.operand;
                 unsigned offset = vPC[7].u.operand;
-                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(codeBlock(r)->identifiers[vPC[2].u.operand])) == offset);
-                baseObject->putDirectOffset(offset, r[value].jsValue(exec));
+                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifiers[vPC[2].u.operand])) == offset);
+                baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame));
 
                 vPC += 8;
@@ -2740 +2719 @@
         }
         
-        uncachePutByID(codeBlock(r), vPC);
+        uncachePutByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2755 +2734 @@
         */
         int base = vPC[1].u.operand;
-        JSValue* baseValue = r[base].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
@@ -2767 +2746 @@
                 unsigned offset = vPC[5].u.operand;
                 
-                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(codeBlock(r)->identifiers[vPC[2].u.operand])) == offset);
-                baseObject->putDirectOffset(offset, r[value].jsValue(exec));
+                ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifiers[vPC[2].u.operand])) == offset);
+                baseObject->putDirectOffset(offset, callFrame[value].jsValue(callFrame));
 
                 vPC += 8;
@@ -2775 +2754 @@
         }
 
-        uncachePutByID(codeBlock(r), vPC);
+        uncachePutByID(callFrame->codeBlock(), vPC);
         NEXT_OPCODE;
     }
@@ -2791 +2770 @@
         int value = vPC[3].u.operand;
 
-        JSValue* baseValue = r[base].jsValue(exec);
-        Identifier& ident = codeBlock(r)->identifiers[property];
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        Identifier& ident = callFrame->codeBlock()->identifiers[property];
         PutPropertySlot slot;
-        baseValue->put(exec, ident, r[value].jsValue(exec), slot);
+        baseValue->put(callFrame, ident, callFrame[value].jsValue(callFrame), slot);
         VM_CHECK_EXCEPTION();
 
@@ -2812 +2791 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = r[base].jsValue(exec)->toObject(exec);
-        Identifier& ident = codeBlock(r)->identifiers[property];
-        JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
+        JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame);
+        Identifier& ident = callFrame->codeBlock()->identifiers[property];
+        JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2832 +2811 @@
         int property = (++vPC)->u.operand;
         
-        JSValue* baseValue = r[base].jsValue(exec);
-        JSValue* subscript = r[property].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* subscript = callFrame[property].jsValue(callFrame);
 
         JSValue* result;
@@ -2845 +2824 @@
                     result = jsArray->getIndex(i);
                 else
-                    result = jsArray->JSArray::get(exec, i);
+                    result = jsArray->JSArray::get(callFrame, i);
             } else if (isJSString(baseValue) && static_cast<JSString*>(baseValue)->canGetIndex(i))
-                result = static_cast<JSString*>(baseValue)->getIndex(&exec->globalData(), i);
+                result = static_cast<JSString*>(baseValue)->getIndex(&callFrame->globalData(), i);
             else
-                result = baseValue->get(exec, i);
+                result = baseValue->get(callFrame, i);
         } else {
-            Identifier property(exec, subscript->toString(exec));
-            result = baseValue->get(exec, property);
+            Identifier property(callFrame, subscript->toString(callFrame));
+            result = baseValue->get(callFrame, property);
         }
 
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2875 +2854 @@
         int value = (++vPC)->u.operand;
 
-        JSValue* baseValue = r[base].jsValue(exec);
-        JSValue* subscript = r[property].jsValue(exec);
+        JSValue* baseValue = callFrame[base].jsValue(callFrame);
+        JSValue* subscript = callFrame[property].jsValue(callFrame);
 
         unsigned i;
@@ -2885 +2864 @@
                 JSArray* jsArray = static_cast<JSArray*>(baseValue);
                 if (jsArray->canSetIndex(i))
-                    jsArray->setIndex(i, r[value].jsValue(exec));
+                    jsArray->setIndex(i, callFrame[value].jsValue(callFrame));
                 else
-                    jsArray->JSArray::put(exec, i, r[value].jsValue(exec));
+                    jsArray->JSArray::put(callFrame, i, callFrame[value].jsValue(callFrame));
             } else
-                baseValue->put(exec, i, r[value].jsValue(exec));
+                baseValue->put(callFrame, i, callFrame[value].jsValue(callFrame));
         } else {
-            Identifier property(exec, subscript->toString(exec));
-            if (!exec->hadException()) { // Don't put to an object if toString threw an exception.
+            Identifier property(callFrame, subscript->toString(callFrame));
+            if (!globalData->exception) { // Don't put to an object if toString threw an exception.
                 PutPropertySlot slot;
-                baseValue->put(exec, property, r[value].jsValue(exec), slot);
+                baseValue->put(callFrame, property, callFrame[value].jsValue(callFrame), slot);
             }
         }
@@ -2914 +2893 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = r[base].jsValue(exec)->toObject(exec); // may throw
-
-        JSValue* subscript = r[property].jsValue(exec);
+        JSObject* baseObj = callFrame[base].jsValue(callFrame)->toObject(callFrame); // may throw
+
+        JSValue* subscript = callFrame[property].jsValue(callFrame);
         JSValue* result;
         uint32_t i;
         if (subscript->getUInt32(i))
-            result = jsBoolean(baseObj->deleteProperty(exec, i));
+            result = jsBoolean(baseObj->deleteProperty(callFrame, i));
         else {
             VM_CHECK_EXCEPTION();
-            Identifier property(exec, subscript->toString(exec));
+            Identifier property(callFrame, subscript->toString(callFrame));
             VM_CHECK_EXCEPTION();
-            result = jsBoolean(baseObj->deleteProperty(exec, property));
+            result = jsBoolean(baseObj->deleteProperty(callFrame, property));
         }
 
         VM_CHECK_EXCEPTION();
-        r[dst] = result;
+        callFrame[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -2949 +2928 @@
         int value = (++vPC)->u.operand;
 
-        r[base].jsValue(exec)->put(exec, property, r[value].jsValue(exec));
+        callFrame[base].jsValue(callFrame)->put(callFrame, property, callFrame[value].jsValue(callFrame));
 
         ++vPC;
@@ -2996 +2975 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (r[cond].jsValue(exec)->toBoolean(exec)) {
+        if (callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
             vPC += target;
             CHECK_FOR_TIMEOUT();
@@ -3013 +2992 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (r[cond].jsValue(exec)->toBoolean(exec)) {
+        if (callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
             vPC += target;
             NEXT_OPCODE;
@@ -3029 +3008 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (!r[cond].jsValue(exec)->toBoolean(exec)) {
+        if (!callFrame[cond].jsValue(callFrame)->toBoolean(callFrame)) {
             vPC += target;
             NEXT_OPCODE;
@@ -3048 +3027 @@
            the JS timeout is reached.
          */
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
         
-        bool result = jsLess(exec, src1, src2);
+        bool result = jsLess(callFrame, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3075 +3054 @@
            the JS timeout is reached.
         */
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
         
-        bool result = jsLessEq(exec, src1, src2);
+        bool result = jsLessEq(callFrame, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3099 +3078 @@
            result of the comparison is false.
         */
-        JSValue* src1 = r[(++vPC)->u.operand].jsValue(exec);
-        JSValue* src2 = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* src1 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
+        JSValue* src2 = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         int target = (++vPC)->u.operand;
 
-        bool result = jsLess(exec, src1, src2);
+        bool result = jsLess(callFrame, src1, src2);
         VM_CHECK_EXCEPTION();
         
@@ -3125 +3104 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!JSImmediate::isNumber(scrutinee))
             vPC += defaultOffset;
         else {
             int32_t value = JSImmediate::getTruncatedInt32(scrutinee);
-            vPC += codeBlock(r)->immediateSwitchJumpTables[tableIndex].offsetForValue(value, defaultOffset);
+            vPC += callFrame->codeBlock()->immediateSwitchJumpTables[tableIndex].offsetForValue(value, defaultOffset);
         }
         NEXT_OPCODE;
@@ -3145 +3124 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!scrutinee->isString())
             vPC += defaultOffset;
@@ -3153 +3132 @@
                 vPC += defaultOffset;
             else
-                vPC += codeBlock(r)->characterSwitchJumpTables[tableIndex].offsetForValue(value->data()[0], defaultOffset);
+                vPC += callFrame->codeBlock()->characterSwitchJumpTables[tableIndex].offsetForValue(value->data()[0], defaultOffset);
         }
         NEXT_OPCODE;
@@ -3168 +3147 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue* scrutinee = r[(++vPC)->u.operand].jsValue(exec);
+        JSValue* scrutinee = callFrame[(++vPC)->u.operand].jsValue(callFrame);
         if (!scrutinee->isString())
             vPC += defaultOffset;
         else 
-            vPC += codeBlock(r)->stringSwitchJumpTables[tableIndex].offsetForValue(static_cast<JSString*>(scrutinee)->value().rep(), defaultOffset);
+            vPC += callFrame->codeBlock()->stringSwitchJumpTables[tableIndex].offsetForValue(static_cast<JSString*>(scrutinee)->value().rep(), defaultOffset);
         NEXT_OPCODE;
     }
@@ -3186 +3165 @@
         int func = (++vPC)->u.operand;
 
-        r[dst] = codeBlock(r)->functions[func]->makeFunction(exec, scopeChain(r));
+        callFrame[dst] = callFrame->codeBlock()->functions[func]->makeFunction(callFrame, callFrame->scopeChain());
 
         ++vPC;
@@ -3202 +3181 @@
         int func = (++vPC)->u.operand;
 
-        r[dst] = codeBlock(r)->functionExpressions[func]->makeFunction(exec, scopeChain(r));
+        callFrame[dst] = callFrame->codeBlock()->functionExpressions[func]->makeFunction(callFrame, callFrame->scopeChain());
 
         ++vPC;
@@ -3226 +3205 @@
         ++vPC; // registerOffset
 
-        JSValue* funcVal = r[func].jsValue(exec);
-        JSValue* baseVal = r[thisVal].jsValue(exec);
-
-        ScopeChainNode* scopeChain = this->scopeChain(r);
+        JSValue* funcVal = callFrame[func].jsValue(callFrame);
+        JSValue* baseVal = callFrame[thisVal].jsValue(callFrame);
+
+        ScopeChainNode* scopeChain = callFrame->scopeChain();
         if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
-            JSObject* thisObject = static_cast<JSObject*>(r[codeBlock(r)->thisRegister].jsValue(exec));
-            JSValue* result = callEval(exec, thisObject, scopeChain, registerFile, r, firstArg, argCount, exceptionValue);
+            JSObject* thisObject = static_cast<JSObject*>(callFrame[callFrame->codeBlock()->thisRegister].jsValue(callFrame));
+            JSValue* result = callEval(callFrame, thisObject, scopeChain, registerFile, firstArg, argCount, exceptionValue);
             if (exceptionValue)
                 goto vm_throw;
 
-            r[dst] = result;
+            callFrame[dst] = result;
 
             ++vPC;
@@ -3246 +3225 @@
         // value.
         vPC -= 6;
-        r[thisVal] = baseVal->toThisObject(exec);
+        callFrame[thisVal] = baseVal->toThisObject(callFrame);
 
 #if HAVE(COMPUTED_GOTO)
@@ -3300 +3279 @@
         int registerOffset = (++vPC)->u.operand;
 
-        JSValue* v = r[func].jsValue(exec);
+        JSValue* v = callFrame[func].jsValue(callFrame);
 
         CallData callData;
@@ -3310 +3289 @@
             CodeBlock* newCodeBlock = &functionBodyNode->byteCode(callDataScopeChain);
 
-            r[firstArg] = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue(exec);
+            callFrame[firstArg] = thisVal == missingThisObjectMarker() ? callFrame->globalThisValue() : callFrame[thisVal].jsValue(callFrame);
             
-            Register* savedR = r;
-
-            r = slideRegisterWindowForCall(newCodeBlock, registerFile, r, registerOffset, argCount);
-            if (UNLIKELY(!r)) {
-                r = savedR;
-                exceptionValue = createStackOverflowError(CallFrame::create(r));
+            CallFrame* previousCallFrame = callFrame;
+
+            callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
+            if (UNLIKELY(!callFrame)) {
+                callFrame = previousCallFrame;
+                exceptionValue = createStackOverflowError(callFrame);
                 goto vm_throw;
             }
 
-            initializeCallFrame(r, newCodeBlock, vPC + 1, callDataScopeChain, savedR, dst, argCount, v);
+            callFrame->init(newCodeBlock, vPC + 1, callDataScopeChain, previousCallFrame, dst, argCount, static_cast<JSFunction*>(v));
     
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
 
             vPC = newCodeBlock->instructions.begin();
@@ -3336 +3315 @@
 
         if (callType == CallTypeHost) {
-            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);
+            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));
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(newCallFrame, static_cast<JSFunction*>(v));
 
             MACHINE_SAMPLING_callingHostFunction();
 
-            JSValue* returnValue = callData.native.function(callFrame, static_cast<JSObject*>(v), thisValue, args);
+            JSValue* returnValue = callData.native.function(newCallFrame, static_cast<JSFunction*>(v), thisValue, args);
             VM_CHECK_EXCEPTION();
 
-            r[dst] = returnValue;
+            newCallFrame[dst] = returnValue;
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(CallFrame::create(r), static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSFunction*>(v));
 
             ++vPC;
@@ -3362 +3341 @@
         ASSERT(callType == CallTypeNone);
 
-        exceptionValue = createNotAFunctionError(exec, v, vPC, codeBlock(r));
+        exceptionValue = createNotAFunctionError(callFrame, v, vPC, callFrame->codeBlock());
         goto vm_throw;
     }
     BEGIN_OPCODE(op_tear_off_activation) {
         int src = (++vPC)->u.operand;
-        JSActivation* activation = static_cast<JSActivation*>(r[src].getJSValue());
-        ASSERT(codeBlock(r)->needsFullScopeChain);
+        ASSERT(callFrame->codeBlock()->needsFullScopeChain);
+        JSActivation* activation = static_cast<JSActivation*>(callFrame[src].getJSValue());
         ASSERT(activation->isObject(&JSActivation::info));
 
-        Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
-        ASSERT(!arguments || arguments->isObject(&Arguments::info));
-        activation->copyRegisters(arguments);
+        activation->copyRegisters(callFrame->optionalCalleeArguments());
 
         ++vPC;
@@ -3379 +3356 @@
     }
     BEGIN_OPCODE(op_tear_off_arguments) {
-        Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
-        ASSERT(codeBlock(r)->usesArguments && !codeBlock(r)->needsFullScopeChain);
-        ASSERT(arguments->isObject(&Arguments::info));
-
-        arguments->copyRegisters();
+        ASSERT(callFrame->codeBlock()->usesArguments && !callFrame->codeBlock()->needsFullScopeChain);
+
+        callFrame->optionalCalleeArguments()->copyRegisters();
 
         ++vPC;
@@ -3401 +3376 @@
 
         if (*enabledProfilerReference)
-            (*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();
+            (*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();
         
-        if (isHostCallFrame(r))
+        if (callFrame->hasHostCallFrameFlag())
             return returnValue;
 
-        r[dst] = returnValue;
+        callFrame[dst] = returnValue;
 
         NEXT_OPCODE;
@@ -3431 +3406 @@
 
         size_t i = 0;
-        CodeBlock* codeBlock = this->codeBlock(r);
+        CodeBlock* codeBlock = callFrame->codeBlock();
         
         for (size_t count = codeBlock->numVars; i < count; ++i)
-            r[i] = jsUndefined();
+            callFrame[i] = jsUndefined();
 
         for (size_t count = codeBlock->constantRegisters.size(), j = 0; j < count; ++i, ++j)
-            r[i] = codeBlock->constantRegisters[j];
+            callFrame[i] = codeBlock->constantRegisters[j];
 
         ++vPC;
@@ -3456 +3431 @@
 
         size_t i = 0;
-        CodeBlock* codeBlock = this->codeBlock(r);
+        CodeBlock* codeBlock = callFrame->codeBlock();
 
         for (size_t count = codeBlock->numVars; i < count; ++i)
-            r[i] = jsUndefined();
+            callFrame[i] = jsUndefined();
 
         for (size_t count = codeBlock->constantRegisters.size(), j = 0; j < count; ++i, ++j)
-            r[i] = codeBlock->constantRegisters[j];
+            callFrame[i] = codeBlock->constantRegisters[j];
 
         int dst = (++vPC)->u.operand;
-        JSActivation* activation = new (globalData) JSActivation(exec, static_cast<FunctionBodyNode*>(codeBlock->ownerNode), r);
-        r[dst] = activation;
-        r[RegisterFile::ScopeChain] = scopeChain(r)->copy()->push(activation);
+        JSActivation* activation = new (globalData) JSActivation(callFrame, static_cast<FunctionBodyNode*>(codeBlock->ownerNode));
+        callFrame[dst] = activation;
+        callFrame->setScopeChain(callFrame->scopeChain()->copy()->push(activation));
 
         ++vPC;
@@ -3474 +3449 @@
     BEGIN_OPCODE(op_convert_this) {
         int thisRegister = (++vPC)->u.operand;
-        JSValue* thisVal = r[thisRegister].getJSValue();
+        JSValue* thisVal = callFrame[thisRegister].getJSValue();
         if (thisVal->needsThisConversion())
-            r[thisRegister] = thisVal->toThisObject(exec);
+            callFrame[thisRegister] = thisVal->toThisObject(callFrame);
 
         ++vPC;
@@ -3492 +3467 @@
         */
 
-        Arguments* arguments = new (globalData) Arguments(exec, r);
-        r[RegisterFile::OptionalCalleeArguments] = arguments;
-        r[RegisterFile::ArgumentsRegister] = arguments;
+        Arguments* arguments = new (globalData) Arguments(callFrame);
+        callFrame->setCalleeArguments(arguments);
+        callFrame[RegisterFile::ArgumentsRegister] = arguments;
         
         ++vPC;
@@ -3521 +3496 @@
         int registerOffset = (++vPC)->u.operand;
 
-        JSValue* v = r[constr].jsValue(exec);
+        JSValue* v = callFrame[constr].jsValue(callFrame);
 
         ConstructData constructData;
@@ -3528 +3503 @@
         if (constructType == ConstructTypeJS) {
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
 
             ScopeChainNode* callDataScopeChain = constructData.js.scopeChain;
@@ -3535 +3510 @@
 
             StructureID* structure;
-            JSValue* prototype = r[constrProto].jsValue(exec);
+            JSValue* prototype = callFrame[constrProto].jsValue(callFrame);
             if (prototype->isObject())
                 structure = static_cast<JSObject*>(prototype)->inheritorID();
@@ -3542 +3517 @@
             JSObject* newObject = new (globalData) JSObject(structure);
 
-            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));
+            callFrame[firstArg] = newObject; // "this" value
+
+            CallFrame* previousCallFrame = callFrame;
+
+            callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
+            if (UNLIKELY(!callFrame)) {
+                callFrame = previousCallFrame;
+                exceptionValue = createStackOverflowError(callFrame);
                 goto vm_throw;
             }
 
-            initializeCallFrame(r, newCodeBlock, vPC + 1, callDataScopeChain, savedR, dst, argCount, v);
+            callFrame->init(newCodeBlock, vPC + 1, callDataScopeChain, previousCallFrame, dst, argCount, static_cast<JSFunction*>(v));
     
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSObject*>(v));
 
             vPC = newCodeBlock->instructions.begin();
@@ -3568 +3543 @@
 
         if (constructType == ConstructTypeHost) {
-            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;
+            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);
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->willExecute(callFrame, static_cast<JSObject*>(v));
 
             MACHINE_SAMPLING_callingHostFunction();
 
-            JSValue* returnValue = constructData.native.function(exec, static_cast<JSObject*>(v), args);
-            r -= registerOffset;
+            JSValue* returnValue = constructData.native.function(callFrame, static_cast<JSObject*>(v), args);
+            callFrame = CallFrame::create(callFrame->registers() - registerOffset);
 
             VM_CHECK_EXCEPTION();
-            r[dst] = returnValue;
+            callFrame[dst] = returnValue;
 
             if (*enabledProfilerReference)
-                (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(v));
+                (*enabledProfilerReference)->didExecute(callFrame, static_cast<JSObject*>(v));
 
             ++vPC;
@@ -3594 +3569 @@
         ASSERT(constructType == ConstructTypeNone);
 
-        exceptionValue = createNotAConstructorError(exec, v, vPC, codeBlock(r));
+        exceptionValue = createNotAConstructorError(callFrame, v, vPC, callFrame->codeBlock());
         goto vm_throw;
     }
@@ -3605 +3580 @@
 
         int dst = vPC[1].u.operand;;
-        if (LIKELY(r[dst].jsValue(exec)->isObject())) {
+        if (LIKELY(callFrame[dst].jsValue(callFrame)->isObject())) {
             vPC += 3;
             NEXT_OPCODE;
@@ -3611 +3586 @@
 
         int override = vPC[2].u.operand;
-        r[dst] = r[override];
+        callFrame[dst] = callFrame[override];
 
         vPC += 3;
@@ -3623 +3598 @@
         */
         int scope = (++vPC)->u.operand;
-        JSValue* v = r[scope].jsValue(exec);
-        JSObject* o = v->toObject(exec);
+        JSValue* v = callFrame[scope].jsValue(callFrame);
+        JSObject* o = v->toObject(callFrame);
         VM_CHECK_EXCEPTION();
 
-        r[RegisterFile::ScopeChain] = scopeChain(r)->push(o);
+        callFrame->setScopeChain(callFrame->scopeChain()->push(o));
 
         ++vPC;
@@ -3637 +3612 @@
            Removes the top item from the current scope chain.
         */
-        r[RegisterFile::ScopeChain] = scopeChain(r)->pop();
+        callFrame->setScopeChain(callFrame->scopeChain()->pop());
 
         ++vPC;
@@ -3653 +3628 @@
         int base = (++vPC)->u.operand;
 
-        r[dst] = JSPropertyNameIterator::create(exec, r[base].jsValue(exec));
+        callFrame[dst] = JSPropertyNameIterator::create(callFrame, callFrame[base].jsValue(callFrame));
         ++vPC;
         NEXT_OPCODE;
@@ -3670 +3645 @@
         int target = (++vPC)->u.operand;
 
-        JSPropertyNameIterator* it = r[iter].jsPropertyNameIterator();
-        if (JSValue* temp = it->next(exec)) {
+        JSPropertyNameIterator* it = callFrame[iter].propertyNameIterator();
+        if (JSValue* temp = it->next(callFrame)) {
             CHECK_FOR_TIMEOUT();
-            r[dst] = temp;
+            callFrame[dst] = temp;
             vPC += target;
             NEXT_OPCODE;
@@ -3692 +3667 @@
         int target = (++vPC)->u.operand;
 
-        ScopeChainNode* tmp = scopeChain(r);
+        ScopeChainNode* tmp = callFrame->scopeChain();
         while (count--)
             tmp = tmp->pop();
-        r[RegisterFile::ScopeChain] = tmp;
+        callFrame->setScopeChain(tmp);
 
         vPC += target;
@@ -3711 +3686 @@
            in dst for GC.
          */
-        r[RegisterFile::ScopeChain] = createExceptionScope(exec, vPC, r);
+        callFrame->setScopeChain(createExceptionScope(callFrame, vPC));
 
         vPC += 4;
@@ -3727 +3702 @@
         */
         ASSERT(exceptionValue);
-        ASSERT(!exec->hadException());
+        ASSERT(!globalData->exception);
         int ex = (++vPC)->u.operand;
-        r[ex] = exceptionValue;
+        callFrame[ex] = exceptionValue;
         exceptionValue = 0;
 
@@ -3747 +3722 @@
 
         int ex = (++vPC)->u.operand;
-        exceptionValue = r[ex].jsValue(exec);
-
-        handlerVPC = throwException(exec, exceptionValue, vPC, r, true);
+        exceptionValue = callFrame[ex].jsValue(callFrame);
+
+        handlerVPC = throwException(callFrame, exceptionValue, vPC, true);
         if (!handlerVPC) {
             *exception = exceptionValue;
@@ -3774 +3749 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst] = codeBlock(r)->unexpectedConstants[src];
+        callFrame[dst] = callFrame->codeBlock()->unexpectedConstants[src];
 
         ++vPC;
@@ -3791 +3766 @@
         int message = (++vPC)->u.operand;
 
-        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());
+        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());
 
         ++vPC;
@@ -3804 +3779 @@
         */
 
-        if (codeBlock(r)->needsFullScopeChain) {
-            ScopeChainNode* scopeChain = this->scopeChain(r);
+        if (callFrame->codeBlock()->needsFullScopeChain) {
+            ScopeChainNode* scopeChain = callFrame->scopeChain();
             ASSERT(scopeChain->refCount > 1);
             scopeChain->deref();
         }
         int result = (++vPC)->u.operand;
-        return r[result].jsValue(exec);
+        return callFrame[result].jsValue(callFrame);
     }
     BEGIN_OPCODE(op_put_getter) {
@@ -3827 +3802 @@
         int function = (++vPC)->u.operand;
 
-        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)));
+        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)));
 
         ++vPC;
@@ -3851 +3826 @@
         int function = (++vPC)->u.operand;
 
-        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)));
+        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)));
 
         ++vPC;
@@ -3868 +3843 @@
         int retAddrDst = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        r[retAddrDst] = vPC + 1;
+        callFrame[retAddrDst] = vPC + 1;
 
         vPC += target;
@@ -3881 +3856 @@
         */
         int retAddrSrc = (++vPC)->u.operand;
-        vPC = r[retAddrSrc].vPC();
+        vPC = callFrame[retAddrSrc].vPC();
         NEXT_OPCODE;
     }
@@ -3894 +3869 @@
         int lastLine = (++vPC)->u.operand;
 
-        debug(exec, r, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
+        debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 
         ++vPC;
@@ -3906 +3881 @@
             exceptionValue = createInterruptedExecutionException(globalData);
         }
-        handlerVPC = throwException(exec, exceptionValue, vPC, r, false);
+        handlerVPC = throwException(callFrame, exceptionValue, vPC, false);
         if (!handlerVPC) {
             *exception = exceptionValue;
@@ -3922 +3897 @@
     #undef VM_CHECK_EXCEPTION
     #undef CHECK_FOR_TIMEOUT
-    #undef exec
-}
-
-JSValue* Machine::retrieveArguments(ExecState* exec, JSFunction* function) const
-{
-    Register* r = this->callFrame(exec, function);
-    if (!r)
+}
+
+JSValue* Machine::retrieveArguments(CallFrame* callFrame, JSFunction* function) const
+{
+    CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
+    if (!functionCallFrame)
         return jsNull();
 
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CodeBlock* codeBlock = functionCallFrame->codeBlock();
     if (codeBlock->usesArguments) {
         ASSERT(codeBlock->codeType == FunctionCode);
         SymbolTable& symbolTable = static_cast<FunctionBodyNode*>(codeBlock->ownerNode)->symbolTable();
-        int argumentsIndex = symbolTable.get(exec->propertyNames().arguments.ustring().rep()).getIndex();
-        return r[argumentsIndex].jsValue(exec);
-    }
-
-    Arguments* arguments = static_cast<Arguments*>(r[RegisterFile::OptionalCalleeArguments].getJSValue());
+        int argumentsIndex = symbolTable.get(functionCallFrame->propertyNames().arguments.ustring().rep()).getIndex();
+        return functionCallFrame[argumentsIndex].jsValue(callFrame);
+    }
+
+    Arguments* arguments = functionCallFrame->optionalCalleeArguments();
     if (!arguments) {
-        arguments = new (exec) Arguments(exec, r);
+        arguments = new (functionCallFrame) Arguments(functionCallFrame);
         arguments->copyRegisters();
-        r[RegisterFile::OptionalCalleeArguments] = arguments;
-    }
-    ASSERT(arguments->isObject(&Arguments::info));
+        callFrame->setCalleeArguments(arguments);
+    }
 
     return arguments;
 }
 
-JSValue* Machine::retrieveCaller(ExecState* exec, InternalFunction* function) const
-{
-    Register* r = this->callFrame(exec, function);
-    if (!r)
+JSValue* Machine::retrieveCaller(CallFrame* callFrame, InternalFunction* function) const
+{
+    CallFrame* functionCallFrame = findFunctionCallFrame(callFrame, function);
+    if (!functionCallFrame)
         return jsNull();
 
-    Register* callerR = r[RegisterFile::CallerRegisters].r();
-    if (isHostCallFrame(callerR))
+    CallFrame* callerFrame = functionCallFrame->callerFrame();
+    if (callerFrame->hasHostCallFrameFlag())
         return jsNull();
 
-    JSValue* caller = callerR[RegisterFile::Callee].jsValue(exec);
+    JSValue* caller = callerFrame->callee();
     if (!caller)
         return jsNull();
@@ -3967 +3940 @@
 }
 
-void Machine::retrieveLastCaller(ExecState* exec, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
+void Machine::retrieveLastCaller(CallFrame* callFrame, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue*& function) const
 {
     function = 0;
@@ -3973 +3946 @@
     sourceURL = UString();
 
-    Register* r = exec->registers();
-    Register* callerR = r[RegisterFile::CallerRegisters].r();
-    if (isHostCallFrame(callerR))
+    CallFrame* callerFrame = callFrame->callerFrame();
+    if (callerFrame->hasHostCallFrameFlag())
         return;
 
-    CodeBlock* callerCodeBlock = codeBlock(callerR);
+    CodeBlock* callerCodeBlock = callerFrame->codeBlock();
     if (!callerCodeBlock)
         return;
 
-    Instruction* vPC = vPCForPC(callerCodeBlock, r[RegisterFile::ReturnPC].v());
+    Instruction* vPC = vPCForPC(callerCodeBlock, callFrame->returnPC());
     lineNumber = callerCodeBlock->lineNumberForVPC(vPC - 1);
     sourceID = callerCodeBlock->ownerNode->sourceID();
     sourceURL = callerCodeBlock->ownerNode->sourceURL();
-
-    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;
+    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;
+    }
     return 0;
 }
 
-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));
+void Machine::getArgumentsData(CallFrame* callFrame, JSFunction*& function, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc)
+{
+    function = callFrame->callee();
     
     CodeBlock* codeBlock = &function->m_body->generatedByteCode();
     int numParameters = codeBlock->numParameters;
-    argc = callFrame[RegisterFile::ArgumentCount].i();
+    argc = callFrame->argumentCount();
 
     if (argc <= numParameters)
-        argv = callFrame - RegisterFile::CallFrameHeaderSize - numParameters + 1; // + 1 to skip "this"
+        argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters + 1; // + 1 to skip "this"
     else
-        argv = callFrame - RegisterFile::CallFrameHeaderSize - numParameters - argc + 1; // + 1 to skip "this"
+        argv = callFrame->registers() - RegisterFile::CallFrameHeaderSize - numParameters - argc + 1; // + 1 to skip "this"
 
     argc -= 1; // - 1 to skip "this"
@@ -4027 +3994 @@
 }
 
-NEVER_INLINE void Machine::tryCTICachePutByID(ExecState* exec, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
+NEVER_INLINE void Machine::tryCTICachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const PutPropertySlot& slot)
 {
     // The interpreter checks for recursion here; I do not believe this can occur in CTI.
@@ -4069 +4036 @@
         StructureIDChain* chain = structureID->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(exec, structureID);
+            chain = cachePrototypeChain(callFrame, structureID);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
@@ -4079 +4046 @@
         vPC[7] = slot.cachedOffset();
         codeBlock->refStructureIDs(vPC);
-        CTI::compilePutByIdTransition(this, exec, codeBlock, structureID->previousID(), structureID, slot.cachedOffset(), chain, returnAddress);
+        CTI::compilePutByIdTransition(this, callFrame, codeBlock, structureID->previousID(), structureID, slot.cachedOffset(), chain, returnAddress);
         return;
     }
@@ -4089 +4056 @@
 
 #if USE(CTI_REPATCH_PIC)
-    UNUSED_PARAM(exec);
+    UNUSED_PARAM(callFrame);
     CTI::patchPutByIdReplace(codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #else
-    CTI::compilePutByIdReplace(this, exec, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+    CTI::compilePutByIdReplace(this, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #endif
 }
 
-void* Machine::getCTIArrayLengthTrampoline(ExecState* exec, CodeBlock* codeBlock)
+void* Machine::getCTIArrayLengthTrampoline(CallFrame* callFrame, CodeBlock* codeBlock)
 {
     if (!m_ctiArrayLengthTrampoline)
-        m_ctiArrayLengthTrampoline = CTI::compileArrayLengthTrampoline(this, exec, codeBlock);
+        m_ctiArrayLengthTrampoline = CTI::compileArrayLengthTrampoline(this, callFrame, codeBlock);
         
     return m_ctiArrayLengthTrampoline;
 }
 
-void* Machine::getCTIStringLengthTrampoline(ExecState* exec, CodeBlock* codeBlock)
+void* Machine::getCTIStringLengthTrampoline(CallFrame* callFrame, CodeBlock* codeBlock)
 {
     if (!m_ctiStringLengthTrampoline)
-        m_ctiStringLengthTrampoline = CTI::compileStringLengthTrampoline(this, exec, codeBlock);
+        m_ctiStringLengthTrampoline = CTI::compileStringLengthTrampoline(this, callFrame, codeBlock);
         
     return m_ctiStringLengthTrampoline;
 }
 
-NEVER_INLINE void Machine::tryCTICacheGetByID(ExecState* exec, CodeBlock* codeBlock, void* returnAddress, JSValue* baseValue, const Identifier& propertyName, const PropertySlot& slot)
+NEVER_INLINE void Machine::tryCTICacheGetByID(CallFrame* callFrame, 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
@@ -4123 +4090 @@
     }
 
-    if (isJSArray(baseValue) && propertyName == exec->propertyNames().length) {
+    if (isJSArray(baseValue) && propertyName == callFrame->propertyNames().length) {
 #if USE(CTI_REPATCH_PIC)
-        CTI::compilePatchGetArrayLength(this, exec, codeBlock, returnAddress);
+        CTI::compilePatchGetArrayLength(this, callFrame, codeBlock, returnAddress);
 #else
-        ctiRepatchCallByReturnAddress(returnAddress, getCTIArrayLengthTrampoline(exec, codeBlock));
+        ctiRepatchCallByReturnAddress(returnAddress, getCTIArrayLengthTrampoline(callFrame, codeBlock));
 #endif
         return;
     }
-    if (isJSString(baseValue) && propertyName == exec->propertyNames().length) {
+    if (isJSString(baseValue) && propertyName == callFrame->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(exec, codeBlock));
+        ctiRepatchCallByReturnAddress(returnAddress, getCTIStringLengthTrampoline(callFrame, codeBlock));
         return;
     }
@@ -4170 +4137 @@
         CTI::patchGetByIdSelf(codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #else
-        CTI::compileGetByIdSelf(this, exec, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdSelf(this, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
 #endif
         return;
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(exec)) {
+    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
         ASSERT(slot.slotBase()->isObject());
 
@@ -4194 +4161 @@
         codeBlock->refStructureIDs(vPC);
 
-        CTI::compileGetByIdProto(this, exec, codeBlock, structureID, slotBaseObject->structureID(), slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdProto(this, callFrame, codeBlock, structureID, slotBaseObject->structureID(), slot.cachedOffset(), returnAddress);
         return;
     }
@@ -4201 +4168 @@
     JSObject* o = static_cast<JSObject*>(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(exec);
+        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
 
         // If we didn't find slotBase in baseValue's prototype chain, then baseValue
@@ -4226 +4193 @@
     StructureIDChain* chain = structureID->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(exec, structureID);
+        chain = cachePrototypeChain(callFrame, structureID);
 
     ASSERT(chain);
@@ -4236 +4203 @@
     codeBlock->refStructureIDs(vPC);
 
-    CTI::compileGetByIdChain(this, exec, codeBlock, structureID, chain, count, slot.cachedOffset(), returnAddress);
+    CTI::compileGetByIdChain(this, callFrame, codeBlock, structureID, chain, count, slot.cachedOffset(), returnAddress);
 }
 
@@ -4291 +4258 @@
 {
     JSValue* v1 = ARG_src1;
-    ExecState* exec = ARG_exec;
-
-    JSObject* result = v1->toThisObject(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSObject* result = v1->toThisObject(callFrame);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4300 +4267 @@
 void Machine::cti_op_end(CTI_ARGS)
 {
-    Register* r = ARG_r;
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    ScopeChainNode* scopeChain = ARG_callFrame->scopeChain();
     ASSERT(scopeChain->refCount > 1);
     scopeChain->deref();
@@ -4318 +4284 @@
         return jsNumber(ARG_globalData, left + right);
     
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     bool leftIsString = v1->isString();
@@ -4324 +4290 @@
         RefPtr<UString::Rep> value = concatenate(static_cast<JSString*>(v1)->value().rep(), static_cast<JSString*>(v2)->value().rep());
         if (UNLIKELY(!value)) {
-            throwOutOfMemoryError(exec);
+            throwOutOfMemoryError(callFrame);
             VM_THROW_EXCEPTION();
         }
@@ -4337 +4303 @@
 
         if (UNLIKELY(!value)) {
-            throwOutOfMemoryError(exec);
+            throwOutOfMemoryError(callFrame);
             VM_THROW_EXCEPTION();
         }
@@ -4344 +4310 @@
 
     // All other cases are pretty uncommon
-    JSValue* result = jsAddSlowCase(exec, v1, v2);
+    JSValue* result = jsAddSlowCase(callFrame, v1, v2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4353 +4319 @@
     JSValue* v = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(exec) + 1);
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) + 1);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4361 +4327 @@
 void Machine::cti_timeout_check(CTI_ARGS)
 {
-    if (ARG_globalData->machine->checkTimeout(ARG_exec->dynamicGlobalObject())) {
+    if (ARG_globalData->machine->checkTimeout(ARG_callFrame->dynamicGlobalObject())) {
         ARG_globalData->exception = createInterruptedExecutionException(ARG_globalData);
         VM_THROW_EXCEPTION_AT_END();
@@ -4371 +4337 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    ExecState* exec = ARG_exec;
-
-    bool result = jsLess(exec, src1, src2);
+    CallFrame* callFrame = ARG_callFrame;
+
+    bool result = jsLess(callFrame, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4382 +4348 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    ExecState* exec = ARG_exec;
-
-    bool result = jsLessEq(exec, src1, src2);
+    CallFrame* callFrame = ARG_callFrame;
+
+    bool result = jsLessEq(callFrame, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4391 +4357 @@
 JSValue* Machine::cti_op_new_object(CTI_ARGS)
 {
-    return constructEmptyObject(ARG_exec);;
+    return constructEmptyObject(ARG_callFrame);;
 }
 
 void Machine::cti_op_put_by_id(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     PutPropertySlot slot;
-    ARG_src1->put(exec, ident, ARG_src3, slot);
+    ARG_src1->put(callFrame, ident, ARG_src3, slot);
 
     ctiRepatchCallByReturnAddress(CTI_RETURN_ADDRESS, (void*)cti_op_put_by_id_second);
@@ -4409 +4375 @@
 void Machine::cti_op_put_by_id_second(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    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);
+    VM_CHECK_EXCEPTION_AT_END();
+}
+
+void Machine::cti_op_put_by_id_generic(CTI_ARGS)
+{
+    PutPropertySlot slot;
+    ARG_src1->put(ARG_callFrame, *ARG_id2, ARG_src3, slot);
+    VM_CHECK_EXCEPTION_AT_END();
+}
+
+void Machine::cti_op_put_by_id_fail(CTI_ARGS)
+{
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
-    JSValue* baseValue = ARG_src1;
     PutPropertySlot 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();
-}
-
-void Machine::cti_op_put_by_id_generic(CTI_ARGS)
-{
-    ExecState* exec = ARG_exec;
-    Identifier& ident = *ARG_id2;
-
-    PutPropertySlot slot;
-    ARG_src1->put(exec, ident, ARG_src3, slot);
-
-    VM_CHECK_EXCEPTION_AT_END();
-}
-
-void Machine::cti_op_put_by_id_fail(CTI_ARGS)
-{
-    ExecState* exec = ARG_exec;
-    Identifier& ident = *ARG_id2;
-
-    PutPropertySlot slot;
-    ARG_src1->put(exec, ident, ARG_src3, slot);
+    ARG_src1->put(callFrame, ident, ARG_src3, slot);
 
     // should probably uncachePutByID() ... this would mean doing a vPC lookup - might be worth just bleeding this until the end.
@@ -4449 +4404 @@
 JSValue* Machine::cti_op_get_by_id(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(exec, ident, slot);
+    JSValue* result = baseValue->get(callFrame, ident, slot);
 
     ctiRepatchCallByReturnAddress(CTI_RETURN_ADDRESS, (void*)cti_op_get_by_id_second);
@@ -4464 +4419 @@
 JSValue* Machine::cti_op_get_by_id_second(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(exec, ident, slot);
-
-    Register* r = ARG_r;
-    ARG_globalData->machine->tryCTICacheGetByID(exec, codeBlock(r), CTI_RETURN_ADDRESS, baseValue, ident, slot);
+    JSValue* result = baseValue->get(callFrame, ident, slot);
+
+    ARG_globalData->machine->tryCTICacheGetByID(callFrame, callFrame->codeBlock(), CTI_RETURN_ADDRESS, baseValue, ident, slot);
 
     VM_CHECK_EXCEPTION_AT_END();
@@ -4480 +4434 @@
 JSValue* Machine::cti_op_get_by_id_generic(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(exec, ident, slot);
+    JSValue* result = baseValue->get(callFrame, ident, slot);
 
     VM_CHECK_EXCEPTION_AT_END();
@@ -4493 +4447 @@
 JSValue* Machine::cti_op_get_by_id_fail(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
 
     JSValue* baseValue = ARG_src1;
     PropertySlot slot(baseValue);
-    JSValue* result = baseValue->get(exec, ident, slot);
+    JSValue* result = baseValue->get(callFrame, ident, slot);
 
     // should probably uncacheGetByID() ... this would mean doing a vPC lookup - might be worth just bleeding this until the end.
@@ -4509 +4463 @@
 JSValue* Machine::cti_op_instanceof(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     JSValue* value = ARG_src1;
     JSValue* baseVal = ARG_src2;
@@ -4523 +4477 @@
 
     if (!baseVal->isObject()) {
-        Register* r = ARG_r;
-        CodeBlock* codeBlock = Machine::codeBlock(r);
+        CallFrame* callFrame = ARG_callFrame;
+        CodeBlock* codeBlock = callFrame->codeBlock();
         ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
         unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-        ARG_globalData->exception = createInvalidParamError(exec, "instanceof", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
+        ARG_globalData->exception = createInvalidParamError(callFrame, "instanceof", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
         VM_THROW_EXCEPTION();
     }
@@ -4535 +4489 @@
 
     if (!proto->isObject()) {
-        throwError(exec, TypeError, "instanceof called on an object with an invalid prototype property.");
+        throwError(callFrame, TypeError, "instanceof called on an object with an invalid prototype property.");
         VM_THROW_EXCEPTION();
     }
@@ -4542 +4496 @@
         return jsBoolean(false);
 
-    JSValue* result = jsBoolean(static_cast<JSObject*>(baseCell)->hasInstance(exec, valueCell, protoCell));
+    JSValue* result = jsBoolean(static_cast<JSObject*>(baseCell)->hasInstance(callFrame, valueCell, protoCell));
     VM_CHECK_EXCEPTION_AT_END();
 
@@ -4550 +4504 @@
 JSValue* Machine::cti_op_del_by_id(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Identifier& ident = *ARG_id2;
     
-    JSObject* baseObj = ARG_src1->toObject(exec);
-
-    JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
+    JSObject* baseObj = ARG_src1->toObject(callFrame);
+
+    JSValue* result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4570 +4524 @@
         return jsNumber(ARG_globalData, left * right);
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) * src2->toNumber(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) * src2->toNumber(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4578 +4532 @@
 JSValue* Machine::cti_op_new_func(CTI_ARGS)
 {
-    return ARG_func1->makeFunction(ARG_exec, Machine::scopeChain(ARG_r));
+    return ARG_func1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
@@ -4589 +4543 @@
 
     if (UNLIKELY(*ARG_profilerReference != 0))
-        (*ARG_profilerReference)->willExecute(CallFrame::create(ARG_r), static_cast<JSObject*>(ARG_src1));
+        (*ARG_profilerReference)->willExecute(ARG_callFrame, static_cast<JSFunction*>(ARG_src1));
 
     ScopeChainNode* callDataScopeChain = static_cast<JSFunction*>(ARG_src1)->m_scopeChain.node();
     CodeBlock* newCodeBlock = &static_cast<JSFunction*>(ARG_src1)->m_body->byteCode(callDataScopeChain);
 
-    Register* r = slideRegisterWindowForCall(newCodeBlock, ARG_registerFile, ARG_r, ARG_int2, ARG_int3);
-    if (UNLIKELY(!r)) {
-        ARG_globalData->exception = createStackOverflowError(CallFrame::create(ARG_r));
+    CallFrame* callFrame = slideRegisterWindowForCall(newCodeBlock, ARG_registerFile, ARG_callFrame, ARG_int2, ARG_int3);
+    if (UNLIKELY(!callFrame)) {
+        ARG_globalData->exception = createStackOverflowError(ARG_callFrame);
         VM_THROW_EXCEPTION_2();
     }
 
-    VoidPtrPair pair = { newCodeBlock, r };
+    VoidPtrPair pair = { newCodeBlock, callFrame };
     return pair;
 }
@@ -4606 +4560 @@
 void* Machine::cti_vm_compile(CTI_ARGS)
 {
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
-
+    CodeBlock* codeBlock = ARG_callFrame->codeBlock();
     if (!codeBlock->ctiCode)
-        CTI::compile(ARG_globalData->machine, CallFrame::create(r), codeBlock);
-
+        CTI::compile(ARG_globalData->machine, ARG_callFrame, codeBlock);
     return codeBlock->ctiCode;
 }
@@ -4617 +4568 @@
 JSValue* Machine::cti_op_push_activation(CTI_ARGS)
 {
-    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);
+    JSActivation* activation = new (ARG_globalData) JSActivation(ARG_callFrame, static_cast<FunctionBodyNode*>(ARG_callFrame->codeBlock()->ownerNode));
+    ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->copy()->push(activation));
     return activation;
 }
@@ -4639 +4585 @@
         int registerOffset = ARG_int2;
         int argCount = ARG_int3;
-        Register* savedR = ARG_r;
-        Register* r = savedR + registerOffset;
-
-        initializeCallFrame(r, 0, ARG_instr4 + 1, scopeChain(savedR), savedR, 0, argCount, funcVal);
-        ARG_setR(r);
+        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);
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->willExecute(CallFrame::create(r), static_cast<JSObject*>(funcVal));
-
-        Register* argv = r - RegisterFile::CallFrameHeaderSize - argCount;
+            (*ARG_profilerReference)->willExecute(callFrame, static_cast<JSFunction*>(funcVal));
+
+        Register* argv = ARG_callFrame->registers() - RegisterFile::CallFrameHeaderSize - argCount;
         ArgList argList(argv + 1, argCount - 1);
 
         CTI_MACHINE_SAMPLING_callingHostFunction();
 
-        JSValue* returnValue = callData.native.function(CallFrame::create(r), static_cast<JSObject*>(funcVal), argv[0].jsValue(CallFrame::create(r)), argList);
-        ARG_setR(savedR);
+        JSValue* returnValue = callData.native.function(callFrame, static_cast<JSFunction*>(funcVal), argv[0].jsValue(callFrame), argList);
+        ARG_setCallFrame(previousCallFrame);
         VM_CHECK_EXCEPTION();
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->didExecute(CallFrame::create(savedR), static_cast<JSObject*>(funcVal));
+            (*ARG_profilerReference)->didExecute(previousCallFrame, static_cast<JSFunction*>(funcVal));
 
         return returnValue;
@@ -4665 +4611 @@
     ASSERT(callType == CallTypeNone);
 
-    ARG_globalData->exception = createNotAFunctionError(CallFrame::create(ARG_r), funcVal, ARG_instr4, codeBlock(ARG_r));
+    ARG_globalData->exception = createNotAFunctionError(ARG_callFrame, funcVal, ARG_instr4, ARG_callFrame->codeBlock());
     VM_THROW_EXCEPTION();
 }
@@ -4671 +4617 @@
 void Machine::cti_op_create_arguments(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-
-    Arguments* arguments = new (ARG_globalData) Arguments(exec, r);
-    r[RegisterFile::OptionalCalleeArguments] = arguments;
-    r[RegisterFile::ArgumentsRegister] = arguments;
+    Arguments* arguments = new (ARG_globalData) Arguments(ARG_callFrame);
+    ARG_callFrame->setCalleeArguments(arguments);
+    ARG_callFrame[RegisterFile::ArgumentsRegister] = arguments;
 }
 
 void Machine::cti_op_tear_off_activation(CTI_ARGS)
 {
-    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);
+    ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain);
+    ASSERT(ARG_src1->isObject(&JSActivation::info));
+    static_cast<JSActivation*>(ARG_src1)->copyRegisters(ARG_callFrame->optionalCalleeArguments());
 }
 
 void Machine::cti_op_tear_off_arguments(CTI_ARGS)
 {
-    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();
+    ASSERT(ARG_callFrame->codeBlock()->usesArguments && !ARG_callFrame->codeBlock()->needsFullScopeChain);
+    ARG_callFrame->optionalCalleeArguments()->copyRegisters();
 }
 
 void Machine::cti_op_ret_profiler(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-
-    Register* r = ARG_r;
     ASSERT(*ARG_profilerReference);
-    (*ARG_profilerReference)->didExecute(exec, static_cast<JSObject*>(r[RegisterFile::Callee].jsValue(exec)));
+    (*ARG_profilerReference)->didExecute(ARG_callFrame, ARG_callFrame->callee());
 }
 
 void Machine::cti_op_ret_scopeChain(CTI_ARGS)
 {
-    Register* r = ARG_r;
-    ASSERT(codeBlock(r)->needsFullScopeChain);
-    scopeChain(r)->deref();
+    ASSERT(ARG_callFrame->codeBlock()->needsFullScopeChain);
+    ARG_callFrame->scopeChain()->deref();
 }
 
 JSValue* Machine::cti_op_new_array(CTI_ARGS)
 {
-    ArgList argsList(ARG_registers1, ARG_int2);
-    return constructArray(ARG_exec, argsList);
+    ArgList argList(ARG_registers1, ARG_int2);
+    return constructArray(ARG_callFrame, argList);
 }
 
 JSValue* Machine::cti_op_resolve(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    CallFrame* callFrame = ARG_callFrame;
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -4739 +4666 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
+        if (o->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
             VM_CHECK_EXCEPTION_AT_END();
             return result;
@@ -4746 +4673 @@
     } while (++iter != end);
 
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
+    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
@@ -4756 +4683 @@
 {
     RegisterFile* registerFile = ARG_registerFile;
-    Register* r = ARG_r;
+    CallFrame* callFrame = ARG_callFrame;
 
     JSFunction* constructor = static_cast<JSFunction*>(ARG_src1);
@@ -4770 +4697 @@
 
     if (*ARG_profilerReference)
-        (*ARG_profilerReference)->willExecute(CallFrame::create(r), constructor);
+        (*ARG_profilerReference)->willExecute(callFrame, constructor);
 
     ScopeChainNode* callDataScopeChain = constructor->m_scopeChain.node();
@@ -4783 +4710 @@
     JSObject* newObject = new (ARG_globalData) JSObject(structure);
 
-    r[firstArg] = newObject; // "this" value
-
-    r = slideRegisterWindowForCall(newCodeBlock, registerFile, r, registerOffset, argCount);
-    if (UNLIKELY(!r)) {
-        ARG_globalData->exception = createStackOverflowError(CallFrame::create(ARG_r));
+    callFrame[firstArg] = newObject; // "this" value
+
+    callFrame = slideRegisterWindowForCall(newCodeBlock, registerFile, callFrame, registerOffset, argCount);
+    if (UNLIKELY(!callFrame)) {
+        ARG_globalData->exception = createStackOverflowError(ARG_callFrame);
         VM_THROW_EXCEPTION_2();
     }
 
-    VoidPtrPair pair = { newCodeBlock, r };
+    VoidPtrPair pair = { newCodeBlock, callFrame };
     return pair;
 }
@@ -4797 +4724 @@
 JSValue* Machine::cti_op_construct_NotJSConstruct(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
+    CallFrame* callFrame = ARG_callFrame;
 
     JSValue* constrVal = ARG_src1;
@@ -4811 +4737 @@
     if (constructType == ConstructTypeHost) {
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->willExecute(exec, constructor);
-
-        ArgList argList(r + firstArg + 1, argCount - 1);
+            (*ARG_profilerReference)->willExecute(callFrame, constructor);
+
+        ArgList argList(callFrame->registers() + firstArg + 1, argCount - 1);
 
         CTI_MACHINE_SAMPLING_callingHostFunction();
 
-        JSValue* returnValue = constructData.native.function(exec, constructor, argList);
+        JSValue* returnValue = constructData.native.function(callFrame, constructor, argList);
         VM_CHECK_EXCEPTION();
 
         if (*ARG_profilerReference)
-            (*ARG_profilerReference)->didExecute(exec, constructor);
+            (*ARG_profilerReference)->didExecute(callFrame, constructor);
 
         return returnValue;
@@ -4828 +4754 @@
     ASSERT(constructType == ConstructTypeNone);
 
-    exec->setException(createNotAConstructorError(exec, constrVal, ARG_instr6, codeBlock(r)));
+    ARG_globalData->exception = createNotAConstructorError(callFrame, constrVal, ARG_instr6, callFrame->codeBlock());
     VM_THROW_EXCEPTION();
 }
@@ -4834 +4760 @@
 JSValue* Machine::cti_op_get_by_val(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Machine* machine = ARG_globalData->machine;
 
@@ -4850 +4776 @@
                 result = jsArray->getIndex(i);
             else
-                result = jsArray->JSArray::get(exec, i);
+                result = jsArray->JSArray::get(callFrame, 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(exec, i);
+            result = baseValue->get(callFrame, i);
     } else {
-        Identifier property(exec, subscript->toString(exec));
-        result = baseValue->get(exec, property);
+        Identifier property(callFrame, subscript->toString(callFrame));
+        result = baseValue->get(callFrame, property);
     }
 
@@ -4866 +4792 @@
 VoidPtrPair Machine::cti_op_resolve_func(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    CallFrame* callFrame = ARG_callFrame;
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -4882 +4807 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(exec, ident, slot)) {            
+        if (base->getPropertySlot(callFrame, 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
@@ -4890 +4815 @@
             // 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(exec);
-            JSValue* result = slot.getValue(exec, ident);
+            JSObject* thisObj = base->toThisObject(callFrame);
+            JSValue* result = slot.getValue(callFrame, ident);
             VM_CHECK_EXCEPTION_AT_END();
 
@@ -4900 +4825 @@
     } while (iter != end);
 
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
+    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
     VM_THROW_EXCEPTION_2();
 }
@@ -4917 +4842 @@
         return jsNumber(ARG_globalData, left - right);
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) - src2->toNumber(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) - src2->toNumber(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4925 +4850 @@
 void Machine::cti_op_put_by_val(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     Machine* machine = ARG_globalData->machine;
 
@@ -4941 +4866 @@
                 jsArray->setIndex(i, value);
             else
-                jsArray->JSArray::put(exec, i, value);
+                jsArray->JSArray::put(callFrame, i, value);
         } else
-            baseValue->put(exec, i, value);
+            baseValue->put(callFrame, i, value);
     } else {
-        Identifier property(exec, subscript->toString(exec));
+        Identifier property(callFrame, subscript->toString(callFrame));
         if (!ARG_globalData->exception) { // Don't put to an object if toString threw an exception.
             PutPropertySlot slot;
-            baseValue->put(exec, property, value, slot);
+            baseValue->put(callFrame, property, value, slot);
         }
     }
@@ -4957 +4882 @@
 void Machine::cti_op_put_by_val_array(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     JSValue* baseValue = ARG_src1;
@@ -4966 +4891 @@
 
     if (LIKELY(i >= 0))
-        static_cast<JSArray*>(baseValue)->JSArray::put(exec, i, value);
+        static_cast<JSArray*>(baseValue)->JSArray::put(callFrame, i, value);
     else {
-        Identifier property(exec, JSImmediate::from(i)->toString(exec));
+        Identifier property(callFrame, JSImmediate::from(i)->toString(callFrame));
         // 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(exec, property, value, slot);
+            baseValue->put(callFrame, property, value, slot);
         }
     }
@@ -4981 +4906 @@
 JSValue* Machine::cti_op_lesseq(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsBoolean(jsLessEq(exec, ARG_src1, ARG_src2));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsBoolean(jsLessEq(callFrame, ARG_src1, ARG_src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -4991 +4916 @@
     JSValue* src1 = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-
-    bool result = src1->toBoolean(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    bool result = src1->toBoolean(callFrame);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5006 +4931 @@
         return jsNumber(ARG_globalData, -v);
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, -src->toNumber(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, -src->toNumber(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5014 +4939 @@
 JSValue* Machine::cti_op_resolve_base(CTI_ARGS)
 {
-    return inlineResolveBase(ARG_exec, *ARG_id1, scopeChain(ARG_r));
+    return inlineResolveBase(ARG_callFrame, *ARG_id1, ARG_callFrame->scopeChain());
 }
 
 JSValue* Machine::cti_op_resolve_skip(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    CallFrame* callFrame = ARG_callFrame;
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     int skip = ARG_int2;
@@ -5036 +4960 @@
         JSObject* o = *iter;
         PropertySlot slot(o);
-        if (o->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
+        if (o->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
             VM_CHECK_EXCEPTION_AT_END();
             return result;
@@ -5043 +4967 @@
     } while (++iter != end);
 
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
+    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
     VM_THROW_EXCEPTION();
 }
@@ -5052 +4976 @@
 JSValue* Machine::cti_op_resolve_global(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>(ARG_src1);
     Identifier& ident = *ARG_id2;
@@ -5059 +4983 @@
 
     PropertySlot slot(globalObject);
-    if (globalObject->getPropertySlot(exec, ident, slot)) {
-        JSValue* result = slot.getValue(exec, ident);
+    if (globalObject->getPropertySlot(callFrame, ident, slot)) {
+        JSValue* result = slot.getValue(callFrame, ident);
         if (slot.isCacheable()) {
             if (vPC[4].u.structureID)
@@ -5074 +4998 @@
     }
     
-    Register* r = ARG_r;
-    exec->setException(createUndefinedVariableError(exec, ident, vPC, codeBlock(r)));    
+    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, vPC, callFrame->codeBlock());
     VM_THROW_EXCEPTION();
 }
@@ -5089 +5012 @@
         return jsNumber(ARG_globalData, left / right);
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(exec) / src2->toNumber(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, src1->toNumber(callFrame) / src2->toNumber(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5099 +5022 @@
     JSValue* v = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, v->toNumber(exec) - 1);
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, v->toNumber(callFrame) - 1);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5109 +5032 @@
     JSValue* src1 = ARG_src1;
     JSValue* src2 = ARG_src2;
-    ExecState* exec = ARG_exec;
-
-    bool result = jsLess(exec, src1, src2);
+    CallFrame* callFrame = ARG_callFrame;
+
+    bool result = jsLess(callFrame, src1, src2);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5120 +5043 @@
     JSValue* src = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-
-    JSValue* result = jsBoolean(!src->toBoolean(exec));
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* result = jsBoolean(!src->toBoolean(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5131 +5054 @@
     JSValue* src1 = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-
-    bool result = src1->toBoolean(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    bool result = src1->toBoolean(callFrame);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5142 +5065 @@
     JSValue* v = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-
-    JSValue* number = v->toJSNumber(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* number = v->toJSNumber(callFrame);
     VM_CHECK_EXCEPTION_2();
 
@@ -5156 +5079 @@
     JSValue* src2 = ARG_src2;
 
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
-    JSValue* result = jsBoolean(equalSlowCaseInline(exec, src1, src2));
+    JSValue* result = jsBoolean(equalSlowCaseInline(callFrame, src1, src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5176 +5099 @@
         return jsNumber(ARG_globalData, left << (right & 0x1f));
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) << (shift->toUInt32(callFrame) & 0x1f));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5192 +5115 @@
         return jsNumber(ARG_globalData, left & right);
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) & src2->toInt32(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) & src2->toInt32(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5210 +5133 @@
         return jsNumber(ARG_globalData, left >> (right & 0x1f));
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, (val->toInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5224 +5147 @@
         return jsNumber(ARG_globalData, ~value);
             
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsNumber(ARG_globalData, ~src->toInt32(exec));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsNumber(ARG_globalData, ~src->toInt32(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5232 +5155 @@
 VoidPtrPair Machine::cti_op_resolve_with_base(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    CallFrame* callFrame = ARG_callFrame;
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     ScopeChainIterator iter = scopeChain->begin();
@@ -5248 +5170 @@
         base = *iter;
         PropertySlot slot(base);
-        if (base->getPropertySlot(exec, ident, slot)) {
-            JSValue* result = slot.getValue(exec, ident);
+        if (base->getPropertySlot(callFrame, ident, slot)) {
+            JSValue* result = slot.getValue(callFrame, ident);
             VM_CHECK_EXCEPTION_AT_END();
 
@@ -5258 +5180 @@
     } while (iter != end);
 
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-    exec->setException(createUndefinedVariableError(exec, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock));
+    ARG_globalData->exception = createUndefinedVariableError(callFrame, ident, codeBlock->instructions.begin() + vPCIndex, codeBlock);
     VM_THROW_EXCEPTION_2();
 }
@@ -5267 +5189 @@
 JSValue* Machine::cti_op_new_func_exp(CTI_ARGS)
 {
-    return ARG_funcexp1->makeFunction(ARG_exec, scopeChain(ARG_r));
+    return ARG_funcexp1->makeFunction(ARG_callFrame, ARG_callFrame->scopeChain());
 }
 
@@ -5275 +5197 @@
     JSValue* divisorValue = ARG_src2;
 
-    ExecState* exec = ARG_exec;
-    double d = dividendValue->toNumber(exec);
-    JSValue* result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(exec)));
+    CallFrame* callFrame = ARG_callFrame;
+    double d = dividendValue->toNumber(callFrame);
+    JSValue* result = jsNumber(ARG_globalData, fmod(d, divisorValue->toNumber(callFrame)));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5284 +5206 @@
 JSValue* Machine::cti_op_less(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsBoolean(jsLess(exec, ARG_src1, ARG_src2));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsBoolean(jsLess(callFrame, ARG_src1, ARG_src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5297 +5219 @@
     ASSERT(!JSImmediate::areBothImmediateNumbers(src1, src2));
 
-    ExecState* exec = ARG_exec;
-    JSValue* result = jsBoolean(!equalSlowCaseInline(exec, src1, src2));
+    CallFrame* callFrame = ARG_callFrame;
+    JSValue* result = jsBoolean(!equalSlowCaseInline(callFrame, src1, src2));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5307 +5229 @@
     JSValue* v = ARG_src1;
 
-    ExecState* exec = ARG_exec;
-
-    JSValue* number = v->toJSNumber(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* number = v->toJSNumber(callFrame);
     VM_CHECK_EXCEPTION_2();
 
@@ -5321 +5243 @@
     JSValue* shift = ARG_src2;
 
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
         return JSImmediate::rightShiftImmediateNumbers(val, shift);
     else {
-        JSValue* result = jsNumber(ARG_globalData, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+        JSValue* result = jsNumber(ARG_globalData, (val->toUInt32(callFrame)) >> (shift->toUInt32(callFrame) & 0x1f));
         VM_CHECK_EXCEPTION_AT_END();
         return result;
@@ -5337 +5259 @@
     JSValue* src2 = ARG_src2;
 
-    ExecState* exec = ARG_exec;
-
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) ^ src2->toInt32(exec));
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) ^ src2->toInt32(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5346 +5268 @@
 JSValue* Machine::cti_op_new_regexp(CTI_ARGS)
 {
-    return new (ARG_globalData) RegExpObject(scopeChain(ARG_r)->globalObject()->regExpStructure(), ARG_regexp1);
+    return new (ARG_globalData) RegExpObject(ARG_callFrame->lexicalGlobalObject()->regExpStructure(), ARG_regexp1);
 }
 
@@ -5354 +5276 @@
     JSValue* src2 = ARG_src2;
 
-    ExecState* exec = ARG_exec;
-
-    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(exec) | src2->toInt32(exec));
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* result = jsNumber(ARG_globalData, src1->toInt32(callFrame) | src2->toInt32(callFrame));
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5363 +5285 @@
 JSValue* Machine::cti_op_call_eval(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     RegisterFile* registerFile = ARG_registerFile;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
-    ScopeChainNode* scopeChain = Machine::scopeChain(r);
+    CodeBlock* codeBlock = callFrame->codeBlock();
+    ScopeChainNode* scopeChain = callFrame->scopeChain();
 
     Machine* machine = ARG_globalData->machine;
@@ -5377 +5298 @@
 
     if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
-        JSObject* thisObject = static_cast<JSObject*>(r[codeBlock->thisRegister].jsValue(exec));
+        JSObject* thisObject = static_cast<JSObject*>(callFrame[codeBlock->thisRegister].jsValue(callFrame));
         JSValue* exceptionValue = 0;
-        JSValue* result = machine->callEval(exec, thisObject, scopeChain, registerFile,  r, registerOffset - RegisterFile::CallFrameHeaderSize - argCount, argCount, exceptionValue);
+        JSValue* result = machine->callEval(callFrame, thisObject, scopeChain, registerFile, registerOffset - RegisterFile::CallFrameHeaderSize - argCount, argCount, exceptionValue);
         VM_CHECK_EXCEPTION_ARG(exceptionValue);
         return result;
@@ -5389 +5310 @@
 void* Machine::cti_op_throw(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
@@ -5399 +5319 @@
     ASSERT(exceptionValue);
 
-    Instruction* handlerVPC = ARG_globalData->machine->throwException(exec, exceptionValue, codeBlock->instructions.begin() + vPCIndex, r, true);
+    Instruction* handlerVPC = ARG_globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, true);
 
     if (!handlerVPC) {
@@ -5406 +5326 @@
     }
 
-    ARG_setR(r);
-    void* catchRoutine = Machine::codeBlock(r)->nativeExceptionCodeForHandlerVPC(handlerVPC);
+    ARG_setCallFrame(callFrame);
+    void* catchRoutine = callFrame->codeBlock()->nativeExceptionCodeForHandlerVPC(handlerVPC);
     ASSERT(catchRoutine);
     ctiSetReturnAddress(&CTI_RETURN_ADDRESS, catchRoutine);
@@ -5415 +5335 @@
 JSPropertyNameIterator* Machine::cti_op_get_pnames(CTI_ARGS)
 {
-    return JSPropertyNameIterator::create(ARG_exec, ARG_src1);
+    return JSPropertyNameIterator::create(ARG_callFrame, ARG_src1);
 }
 
@@ -5421 +5341 @@
 {
     JSPropertyNameIterator* it = ARG_pni1;
-    JSValue* temp = it->next(ARG_exec);
+    JSValue* temp = it->next(ARG_callFrame);
     if (!temp)
         it->invalidate();
@@ -5429 +5349 @@
 void Machine::cti_op_push_scope(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    JSValue* v = ARG_src1;
-
-    JSObject* o = v->toObject(exec);
+    JSObject* o = ARG_src1->toObject(ARG_callFrame);
     VM_CHECK_EXCEPTION_VOID();
-
-    Register* r = ARG_r;
-    r[RegisterFile::ScopeChain] = scopeChain(r)->push(o);
+    ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->push(o));
 }
 
 void Machine::cti_op_pop_scope(CTI_ARGS)
 {
-    Register* r = ARG_r;
-    r[RegisterFile::ScopeChain] = scopeChain(r)->pop();
+    ARG_callFrame->setScopeChain(ARG_callFrame->scopeChain()->pop());
 }
 
 JSValue* Machine::cti_op_typeof(CTI_ARGS)
 {
-    return jsTypeStringForValue(ARG_exec, ARG_src1);
+    return jsTypeStringForValue(ARG_callFrame, ARG_src1);
 }
 
@@ -5508 +5422 @@
 {
     JSValue* src = ARG_src1;
-    ExecState* exec = ARG_exec;
-
-    JSValue* result = src->toJSNumber(exec);
+    CallFrame* callFrame = ARG_callFrame;
+
+    JSValue* result = src->toJSNumber(callFrame);
     VM_CHECK_EXCEPTION_AT_END();
     return result;
@@ -5517 +5431 @@
 JSValue* Machine::cti_op_in(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     JSValue* baseVal = ARG_src2;
 
     if (!baseVal->isObject()) {
-        Register* r = ARG_r;
-        CodeBlock* codeBlock = Machine::codeBlock(r);
+        CallFrame* callFrame = ARG_callFrame;
+        CodeBlock* codeBlock = callFrame->codeBlock();
         ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(CTI_RETURN_ADDRESS));
         unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(CTI_RETURN_ADDRESS);
-        exec->setException(createInvalidParamError(exec, "in", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock));
+        ARG_globalData->exception = createInvalidParamError(callFrame, "in", baseVal, codeBlock->instructions.begin() + vPCIndex, codeBlock);
         VM_THROW_EXCEPTION();
     }
@@ -5534 +5448 @@
     uint32_t i;
     if (propName->getUInt32(i))
-        return jsBoolean(baseObj->hasProperty(exec, i));
-
-    Identifier property(exec, propName->toString(exec));
+        return jsBoolean(baseObj->hasProperty(callFrame, i));
+
+    Identifier property(callFrame, propName->toString(callFrame));
     VM_CHECK_EXCEPTION();
-    return jsBoolean(baseObj->hasProperty(exec, property));
+    return jsBoolean(baseObj->hasProperty(callFrame, property));
 }
 
 JSValue* Machine::cti_op_push_new_scope(CTI_ARGS)
 {
-    JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_exec, *ARG_id1, ARG_src2, DontDelete);
-
-    Register* r = ARG_r;
-    r[RegisterFile::ScopeChain] = scopeChain(r)->push(scope);
+    JSObject* scope = new (ARG_globalData) JSStaticScopeObject(ARG_callFrame, *ARG_id1, ARG_src2, DontDelete);
+
+    CallFrame* callFrame = ARG_callFrame;
+    callFrame->setScopeChain(callFrame->scopeChain()->push(scope));
     return scope;
 }
@@ -5553 +5467 @@
 {
     unsigned count = ARG_int1;
-    Register* r = ARG_r;
-
-    ScopeChainNode* tmp = scopeChain(r);
+    CallFrame* callFrame = ARG_callFrame;
+
+    ScopeChainNode* tmp = callFrame->scopeChain();
     while (count--)
         tmp = tmp->pop();
-    r[RegisterFile::ScopeChain] = tmp;
+    callFrame->setScopeChain(tmp);
 }
 
 void Machine::cti_op_put_by_index(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
     unsigned property = ARG_int2;
 
-    ARG_src1->put(exec, property, ARG_src3);
+    ARG_src1->put(callFrame, property, ARG_src3);
 }
 
@@ -5573 +5487 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     if (JSImmediate::isNumber(scrutinee)) {
@@ -5588 +5502 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     void* result = codeBlock->characterSwitchJumpTables[tableIndex].ctiDefault;
@@ -5606 +5520 @@
     JSValue* scrutinee = ARG_src1;
     unsigned tableIndex = ARG_int2;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     void* result = codeBlock->stringSwitchJumpTables[tableIndex].ctiDefault;
@@ -5621 +5535 @@
 JSValue* Machine::cti_op_del_by_val(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     JSValue* baseValue = ARG_src1;
-    JSObject* baseObj = baseValue->toObject(exec); // may throw
+    JSObject* baseObj = baseValue->toObject(callFrame); // may throw
 
     JSValue* subscript = ARG_src2;
@@ -5630 +5544 @@
     uint32_t i;
     if (subscript->getUInt32(i))
-        result = jsBoolean(baseObj->deleteProperty(exec, i));
+        result = jsBoolean(baseObj->deleteProperty(callFrame, i));
     else {
         VM_CHECK_EXCEPTION();
-        Identifier property(exec, subscript->toString(exec));
+        Identifier property(callFrame, subscript->toString(callFrame));
         VM_CHECK_EXCEPTION();
-        result = jsBoolean(baseObj->deleteProperty(exec, property));
+        result = jsBoolean(baseObj->deleteProperty(callFrame, property));
     }
 
@@ -5644 +5558 @@
 void Machine::cti_op_put_getter(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(ARG_src1->isObject());
@@ -5650 +5564 @@
     Identifier& ident = *ARG_id2;
     ASSERT(ARG_src3->isObject());
-    baseObj->defineGetter(exec, ident, static_cast<JSObject*>(ARG_src3));
+    baseObj->defineGetter(callFrame, ident, static_cast<JSObject*>(ARG_src3));
 }
 
 void Machine::cti_op_put_setter(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
+    CallFrame* callFrame = ARG_callFrame;
 
     ASSERT(ARG_src1->isObject());
@@ -5661 +5575 @@
     Identifier& ident = *ARG_id2;
     ASSERT(ARG_src3->isObject());
-    baseObj->defineSetter(exec, ident, static_cast<JSObject*>(ARG_src3));
+    baseObj->defineSetter(callFrame, ident, static_cast<JSObject*>(ARG_src3));
 }
 
 JSValue* Machine::cti_op_new_error(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
     unsigned type = ARG_int1;
     JSValue* message = ARG_src2;
     unsigned lineNumber = ARG_int3;
 
-    return Error::create(exec, static_cast<ErrorType>(type), message->toString(exec), lineNumber, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
+    return Error::create(callFrame, static_cast<ErrorType>(type), message->toString(callFrame), lineNumber, codeBlock->ownerNode->sourceID(), codeBlock->ownerNode->sourceURL());
 }
 
 void Machine::cti_op_debug(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
+    CallFrame* callFrame = ARG_callFrame;
 
     int debugHookID = ARG_int1;
@@ -5685 +5597 @@
     int lastLine = ARG_int3;
 
-    ARG_globalData->machine->debug(exec, r, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
+    ARG_globalData->machine->debug(callFrame, static_cast<DebugHookID>(debugHookID), firstLine, lastLine);
 }
 
 void* Machine::cti_vm_throw(CTI_ARGS)
 {
-    ExecState* exec = ARG_exec;
-    Register* r = ARG_r;
-    CodeBlock* codeBlock = Machine::codeBlock(r);
+    CallFrame* callFrame = ARG_callFrame;
+    CodeBlock* codeBlock = callFrame->codeBlock();
 
     ASSERT(codeBlock->ctiReturnAddressVPCMap.contains(ARG_globalData->throwReturnAddress));
@@ -5701 +5612 @@
     ARG_globalData->exception = 0;
 
-    Instruction* handlerVPC = ARG_globalData->machine->throwException(exec, exceptionValue, codeBlock->instructions.begin() + vPCIndex, r, false);
+    Instruction* handlerVPC = ARG_globalData->machine->throwException(callFrame, exceptionValue, codeBlock->instructions.begin() + vPCIndex, false);
 
     if (!handlerVPC) {
@@ -5708 +5619 @@
     }
 
-    ARG_setR(r);
-    void* catchRoutine = Machine::codeBlock(r)->nativeExceptionCodeForHandlerVPC(handlerVPC);
+    ARG_setCallFrame(callFrame);
+    void* catchRoutine = callFrame->codeBlock()->nativeExceptionCodeForHandlerVPC(handlerVPC);
     ASSERT(catchRoutine);
     ctiSetReturnAddress(&CTI_RETURN_ADDRESS, catchRoutine);